CarstenKoenig

module Main where

import Data.List (foldl')
import Data.Char (toLower, isDigit)

data Move
  = MoveUp
  | MoveDown
  | MoveLeft
  | MoveRight

CarstenKoenig

Run Suave on Linux

Step 1 - Install Forge

• clone the forge-project git clone https://github.com/fsharp-editing/Forge.git
• change directory cd Forge
• run the build script ./build.sh

if all works out you should have a Forge.exe in ./temp/bin that you can call with mono (assuming you use mono)

CarstenKoenig

function CaseA (value) {
    return function(caseA, caseB) { return caseA(value); }
}

function CaseB (value) {
    return function(caseA, caseB) { return caseA(value); }
}

function match (union, caseA, caseB) {
    return union(caseA, caseB);

CarstenKoenig

{-# LANGUAGE RankNTypes #-}
module PoorMans where

-- should be easy to translate into JS ... no types needed

newtype Union a b = MkUnion (forall c . (a -> c, b -> c) -> c)

valueA :: a -> Union a b
valueA a = MkUnion (\ (f, _) -> f a)

CarstenKoenig

module Poly

fT : (img:Type->Type) -> Type
fT img = (a:Type) -> (a -> img a)

g : {a:Type} -> {b:Type} -> (img : Type -> Type) -> (fT img) -> a -> b -> (img a, img b)
g {a} {b} _ f x y = ((f a) x, (f b) y)

f1 : a -> List a
f1 x = [x]

CarstenKoenig

module Unsafe where

import System.Random
import System.IO.Unsafe(unsafePerformIO)

generateUUID :: () -> String
generateUUID () = show $ unsafePerformIO (randomIO :: IO Int)

wuiPanel :: () ->  IO String
wuiPanel () = do

CarstenKoenig

module FizzBuzz
    (
      fizzBuzz
    ) where

import Data.Maybe (fromMaybe)

fizzBuzz :: Integer -> String
fizzBuzz n = fromMaybe (show n) $ fizz n `mappend` buzz n
  where fizz = maybeWord 3 "Fizz"

CarstenKoenig

module HW06 where

import Prelude hiding (repeat)
import Data.List(intercalate)

data Stream a = Cons a (Stream a)

toList :: Stream a -> [a]
toList (Cons a s) = a : toList s

CarstenKoenig

// let's start with something easy: Chruch-encoded-Booleans:

type BoolC =
    abstract apply : 'a -> 'a -> 'a
   
let trueC : BoolC = 
    { new BoolC with member __.apply t _ = t  }

let falseC : BoolC = 

CarstenKoenig

module Rooms where

import Data.List (intercalate)

data Room = Room [Person]
data Person = Person [Star]
data Star = Star

instance Show Room where
  show (Room ps) = "room: " ++ intercalate ", " (map show ps)