nvanderw

#lang racket

; Solution to Project Euler problem #23
 
(require racket/set)

; Predicate to check if m | n
(define (divides? m n)
  (= 0 (modulo n m)))

nvanderw

API_HANDLERS = {}
def register_handler(func, name=None):
    if name is None:
        name=func.__name__
    API_HANDLERS[name] = func
    return func

def dispatch(name, request):
    return API_HANDLERS[name](request)

nvanderw

(* Type of natural numbers *)
type nat = Zero
         | Succ of nat ;;

exception Undefined ;;

type comparison = LT
                | EQ
                | GT ;;

nvanderw

import Data.Either
import System.Random

-- |An association list mapping random variable outputs to their
-- probabilities, which should add up to 1.
type ProbMass a = [(a, Double)]

-- |Given a uniform random number in [0, 1) and a probability mass function
-- (PMF) describing the probabilities of various outcomes of a random
-- variable X, give a random outcome.

nvanderw

public class Thunks {
    /**
     * Interface which represents unary functions. Can be anonymously
     * instantiated to simulate lambdas.
     */
    public static interface Fn<A, B> {
        public B call(A arg);
    }

    /**

nvanderw

from __future__ import division

import sys
from random import SystemRandom

# A list of unicode combining characters
COMBINING = [unichr(c) for c in xrange(0x300, 0x370)]

ZalgoError = KeyError

nvanderw

# why do blocks even exist?
def fibs1
    a, b = 0, 1
    while b < 1000
        yield b
        a, b = b, a + b
    end
end

# it seems like "yield" is just syntax for "invoke this weird callback"

nvanderw

import Data.Word
import Data.List
import Control.Monad.State.Strict
import Control.DeepSeq

data EmitterState = EmitterState {
  emNextLabel :: Int
} deriving (Read, Show, Eq, Ord)

instance NFData EmitterState where

nvanderw

module Stack where

import Control.Arrow

class List a

-- Use pairs to represent a cons list which can be statically checked
instance List ()
instance List b => List (a, b)

nvanderw

{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances, ScopedTypeVariables #-}
module TuringMachine where

import Control.Monad.State.Lazy
import Data.Array.ST
import Data.Array
import Data.Default
import Control.Monad.ST
import Control.Arrow ((&&&))