fundon

<?php
function e($str){echo $str , "\n";}

class AOP
{
    static function getInstance()
    {
        $args = func_get_args();
        $class = array_shift($args);

luqui

Let [ ] : Ord -> Relation Nat be a function that realizes an ordinal into a well-ordering of the naturals with that order type.

Given a relation R on the naturals, we define the restricted relation R(<n) to be R but just acting on the first n naturals.

Defn: [ ] is continuous iff for every series of ordinals a_i whose limit is l, for every natural n, there exists an i such that for all j > i, [a_i](<n) = [l](<n).

Intuitively, if you are only looking at a finite prefix of the naturals, you can get to a limit ordinal by going finitely high up its limit sequence.

dg

<?php

/**
 * This file is part of the Nette Framework (http://nette.org)
 *
 * Copyright (c) 2004, 2011 David Grudl (http://davidgrudl.com)
 *
 * For the full copyright and license information, please view
 * the file license.txt that was distributed with this source code.
 */

jdp

<?php
require_once "lib/compra.php";
require_once "lib/sheen.php";
require_once "lib/beggar.php";

use compra\Compra;
use sheen\View;
use beggar\Request;

function templatize($req, $res) {

svebal

<?php
/**
 * Smarty plugin
 * @package Smarty
 * @subpackage PluginsModifier
 */

/**
 * Smarty {$xml|parseXML} function plugin
 *

jorgeortiz85

type ¬[A] = A => Nothing
type ∨[T, U] = ¬[¬[T] with ¬[U]]
type ¬¬[A] = ¬[¬[A]]
type |∨|[T, U] = { type λ[X] = ¬¬[X] <:< (T ∨ U) }

class FoldUnion[T](t: T) {
  def boxClass(x: java.lang.Class[_]): java.lang.Class[_] = x.toString match {
    case "byte" => manifest[java.lang.Byte].erasure
    case "char" => manifest[java.lang.Character].erasure
    case "short" => manifest[java.lang.Short].erasure

panesofglass

namespace Fracture

/// Agent alias for MailboxProcessor
type Agent<'a> = MailboxProcessor<'a>

/// One of three messages for our Object Pool agent
type PoolMessage<'a> =
    | Get of AsyncReplyChannel<'a>
    | Count of AsyncReplyChannel<int>
    | Put of 'a

johan

johan

kencan

def fibFast1(num: Int): BigInt = {
   var a: BigInt = 1
   var b: BigInt = 0
   var c: BigInt = 1
   for(bit <- bits(num)){
     bit match {
        case 1 => {
           a = (a+c)*b
           b = b*b + c*c
        }