i as NatList cons = n : Nat. l : NatList. h cons = { n, l }i as NatList isnil = l : NatList. case l of h nil = u i ) true | h cons = p i ) false hd = l : NatList. case l of h nil = u i ) 0 | h cons = p i ) p. 1 tl = l : NatList. case l of h nil = u i ) 1 | h cons = p i ) p. 2 sumlist = fix ( s : NatList ! Nat. l : NatList. if isnil l then 0 else plus ( hd l ) ( s ( tl l ))) data NatList = Nil () | Cons (Nat, NatList) deriving (Eq, Show) nil :: NatList nil = Nil () cons :: Nat -> NatList -> NatList cons = \n -> \l -> Cons (n, l) isnil :: NatList -> Bool isnil = \l -> case l of Nil _ -> True Cons _ -> False hd :: NatList -> Nat hd = \l -> case l of Nil _ -> 0 Cons p -> fst p tl :: NatList -> NatList tl = \l -> case l of Nil _ -> l Cons p -> snd p sumlist :: NatList -> Nat sumlist = \l -> if isnil l then 0 else hd l + sumlist (tl l)
= µA. Unit ! { Nat, A } hd = s : Stream. ( s unit ) . 1 tl = s : Stream. ( s unit ) . 2 upfrom 0 = fix ( f : Nat ! Stream. n : Nat. : Unit. { n, f ( succ n )}) 0 data Stream a = Stream (() -> (Nat, Stream a)) hd_s :: Stream Nat -> Nat hd_s = \(Stream s) -> fst (s ()) tl_s :: Stream Nat -> Stream Nat tl_s = \(Stream s) -> snd (s ()) upfrom0 :: Stream Int upfrom0 = f 0 where f n = Stream (\_ -> (n, f (n+1)))
µA. Nat ! { Nat, A } curr = s : Process. ( s 0) . 1 send = n : Nat. s : Process. ( s n ) . 2 p = fix ( f : Nat ! Process. acc : Nat. n : Nat. { acc + n, f ( acc + n )}) 0 data Process a = Process (Nat -> (Nat, Process a)) curr :: Process a -> Nat curr = \(Process s) -> fst (s 0) send :: Nat -> Process a -> Process a send = \n -> \(Process s) -> snd (s n) process :: Process a process = f 0 where f acc = Process (\n -> (acc+n, f (acc+n)))
inc :: () -> Counter, dec :: () -> Counter } data X = X { x :: Nat } counter :: Counter counter = create $ X { x = 0 } where create s = Counter { get = x s, inc = \_ -> create $ X { x = x s + 1 }, dec = \_ -> create $ X { x = x s - 1 } }
ʹͳΔ ྫ͑ɺ ʹల։Ͱ͖Δɻ 17 µX.T µX.T [X 7! µX.T] T µX. h nil : Unit, cons : { Nat, X }i µX.T [X 7! µX.T] T h nil : Unit, cons : { Nat, µX. h nil : Unit, cons : { Nat, X }i
| Cons of int * nlbody let isnil l = match l with Nil (_) -> true | Cons (_) -> false let hd l = match l with Nil (_) -> 0 | Cons (i1, _) -> i1 let tl l = match l with Nil (_) -> l | Cons (_, tl) -> tl NLBody = h nil : Unit, cons : { Nat, NatList }i nil = fold [ NatList ](h nil = unit i as NLBody cons = n : Nat. l : NatList. fold [ NatList ]h cons = { n, l }i as NLBody isnil = l : NatList. case unfold [ NatList ] l of h nil = u i ) true | h cons = p i ) false hd = l : NatList. case unfold [ NatList ] l of h nil = u i ) 0 | h cons = p i ) p. 1 tl = ...
daimatz
sshimizu2006
vika97
asnowberger
tok41
jscarto
takasehideki
valentinbeuchillot
bob3bob3
emeij
line_developers_tw
lahuuki
chriscoyier
rasmusluckow
revolveconf
mza
gr2m
destraynor
bryan
jrom
eileencodes
lynnandtonic
marcduiker
jennybc
