From f344b250f6f062a1a1902bf69b23ebf9b565de0e Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Sat, 17 Sep 2016 15:01:51 -0700 Subject: 3395 --- html/lambda_to_mu.mu.html | 244 +++++++++++++++++++++++----------------------- 1 file changed, 122 insertions(+), 122 deletions(-) (limited to 'html/lambda_to_mu.mu.html') diff --git a/html/lambda_to_mu.mu.html b/html/lambda_to_mu.mu.html index a615b34f..0bfee036 100644 --- a/html/lambda_to_mu.mu.html +++ b/html/lambda_to_mu.mu.html @@ -41,19 +41,19 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color run [ local-scope 1:text/raw <- lambda-to-mu [(add a (multiply b c))] - 2:array:character/raw <- copy *1:text/raw + 2:@:char/raw <- copy *1:text/raw ] memory-should-contain [ - 2:array:character <- [t1 <- multiply b c + 2:@:char <- [t1 <- multiply b c result <- add a t1] ] ] -def lambda-to-mu in:address:array:character -> out:address:array:character [ +def lambda-to-mu in:text -> out:text [ local-scope load-ingredients out <- copy 0 - cells:address:cell <- parse in + cells:&:cell <- parse in out <- to-mu cells ] @@ -65,32 +65,32 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color # printed below as < first | rest > container pair [ - first:address:cell - rest:address:cell + first:&:cell + rest:&:cell ] -def new-atom name:address:array:character -> result:address:cell [ +def new-atom name:text -> result:&:cell [ local-scope load-ingredients result <- new cell:type *result <- merge 0/tag:atom, name ] -def new-pair a:address:cell, b:address:cell -> result:address:cell [ +def new-pair a:&:cell, b:&:cell -> result:&:cell [ local-scope load-ingredients result <- new cell:type *result <- merge 1/tag:pair, a/first, b/rest ] -def is-atom? x:address:cell -> result:boolean [ +def is-atom? x:&:cell -> result:boolean [ local-scope load-ingredients reply-unless x, 0/false _, result <- maybe-convert *x, atom:variant ] -def is-pair? x:address:cell -> result:boolean [ +def is-pair? x:&:cell -> result:boolean [ local-scope load-ingredients reply-unless x, 0/false @@ -100,7 +100,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color scenario atom-is-not-pair [ local-scope s:text <- new [a] - x:address:cell <- new-atom s + x:&:cell <- new-atom s 10:boolean/raw <- is-atom? x 11:boolean/raw <- is-pair? x memory-should-contain [ @@ -113,8 +113,8 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color local-scope # construct (a . nil) s:text <- new [a] - x:address:cell <- new-atom s - y:address:cell <- new-pair x, 0/nil + x:&:cell <- new-atom s + y:&:cell <- new-pair x, 0/nil 10:boolean/raw <- is-atom? y 11:boolean/raw <- is-pair? y memory-should-contain [ @@ -123,7 +123,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color ] ] -def atom-match? x:address:cell, pat:address:array:character -> result:boolean [ +def atom-match? x:&:cell, pat:text -> result:boolean [ local-scope load-ingredients s:text, is-atom?:boolean <- maybe-convert *x, atom:variant @@ -133,14 +133,14 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color scenario atom-match [ local-scope - x:address:cell <- new-atom [abc] + x:&:cell <- new-atom [abc] 10:boolean/raw <- atom-match? x, [abc] memory-should-contain [ 10 <- 1 ] ] -def first x:address:cell -> result:address:cell [ +def first x:&:cell -> result:&:cell [ local-scope load-ingredients pair:pair, pair?:boolean <- maybe-convert *x, pair:variant @@ -148,7 +148,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color result <- get pair, first:offset ] -def rest x:address:cell -> result:address:cell [ +def rest x:&:cell -> result:&:cell [ local-scope load-ingredients pair:pair, pair?:boolean <- maybe-convert *x, pair:variant @@ -156,7 +156,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color result <- get pair, rest:offset ] -def set-first base:address:cell, new-first:address:cell -> base:address:cell [ +def set-first base:&:cell, new-first:&:cell -> base:&:cell [ local-scope load-ingredients pair:pair, is-pair?:boolean <- maybe-convert *base, pair:variant @@ -165,7 +165,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color *base <- merge 1/pair, pair ] -def set-rest base:address:cell, new-rest:address:cell -> base:address:cell [ +def set-rest base:&:cell, new-rest:&:cell -> base:&:cell [ local-scope load-ingredients pair:pair, is-pair?:boolean <- maybe-convert *base, pair:variant @@ -177,9 +177,9 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color scenario cell-operations-on-atom [ local-scope s:text <- new [a] - x:address:cell <- new-atom s - 10:address:cell/raw <- first x - 11:address:cell/raw <- rest x + x:&:cell <- new-atom s + 10:&:cell/raw <- first x + 11:&:cell/raw <- rest x memory-should-contain [ 10 <- 0 # first is nil 11 <- 0 # rest is nil @@ -190,11 +190,11 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color local-scope # construct (a . nil) s:text <- new [a] - x:address:cell <- new-atom s - y:address:cell <- new-pair x, 0/nil - x2:address:cell <- first y + x:&:cell <- new-atom s + y:&:cell <- new-pair x, 0/nil + x2:&:cell <- first y 10:boolean/raw <- equal x, x2 - 11:address:cell/raw <- rest y + 11:&:cell/raw <- rest y memory-should-contain [ 10 <- 1 # first is correct 11 <- 0 # rest is nil @@ -203,31 +203,31 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color ## convert lambda text to a tree of cells -def parse in:address:array:character -> out:address:cell [ +def parse in:text -> out:&:cell [ local-scope load-ingredients - s:address:stream:character <- new-stream in + s:&:stream:char <- new-stream in out, s <- parse s trace 2, [app/parse], out ] -def parse in:address:stream:character -> out:address:cell, in:address:stream:character [ +def parse in:&:stream:char -> out:&:cell, in:&:stream:char [ local-scope load-ingredients # skip whitespace in <- skip-whitespace in - c:character, eof?:boolean <- peek in + c:char, eof?:boolean <- peek in reply-if eof?, 0/nil pair?:boolean <- equal c, 40/open-paren { break-if pair? # atom - b:address:buffer <- new-buffer 30 + b:&:buffer <- new-buffer 30 { done?:boolean <- end-of-stream? in break-if done? # stop before close paren or space - c:character <- peek in + c:char <- peek in done? <- equal c, 41/close-paren break-if done? done? <- space? c @@ -252,11 +252,11 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color c <- peek in close-paren?:boolean <- equal c, 41/close-paren break-if close-paren? - first:address:cell, in <- parse in + first:&:cell, in <- parse in *out <- merge 1/pair, first, 0/nil } # read in any remaining elements - curr:address:cell <- copy out + curr:&:cell <- copy out { in <- skip-whitespace in end?:boolean <- end-of-stream? in @@ -271,11 +271,11 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color break +end-pair:label } # still here? read next element of pair - next:address:cell, in <- parse in + next:&:cell, in <- parse in is-dot?:boolean <- atom-match? next, [.] { break-if is-dot? - next-curr:address:cell <- new-pair next, 0/nil + next-curr:&:cell <- new-pair next, 0/nil curr <- set-rest curr, next-curr curr <- rest curr } @@ -286,7 +286,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color c <- peek in not-close-paren?:boolean <- not-equal c, 41/close-paren assert not-close-paren?, [')' cannot immediately follow '.'] - final:address:cell <- parse in + final:&:cell <- parse in curr <- set-rest curr, final # we're not gonna update curr, so better make sure the next iteration # is going to end the pair @@ -301,13 +301,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color } ] -def skip-whitespace in:address:stream:character -> in:address:stream:character [ +def skip-whitespace in:&:stream:char -> in:&:stream:char [ local-scope load-ingredients { done?:boolean <- end-of-stream? in reply-if done?, 0/null - c:character <- peek in + c:char <- peek in space?:boolean <- space? c break-unless space? read in # skip @@ -315,15 +315,15 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color } ] -def to-text x:address:cell -> out:address:array:character [ +def to-text x:&:cell -> out:text [ local-scope load-ingredients - buf:address:buffer <- new-buffer 30 + buf:&:buffer <- new-buffer 30 buf <- to-buffer x, buf out <- buffer-to-array buf ] -def to-buffer x:address:cell, buf:address:buffer -> buf:address:buffer [ +def to-buffer x:&:cell, buf:&:buffer -> buf:&:buffer [ local-scope load-ingredients # base case: empty cell @@ -341,10 +341,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color } # recursive case: pair buf <- append buf, [< ] - first:address:cell <- first x + first:&:cell <- first x buf <- to-buffer first, buf buf <- append buf, [ | ] - rest:address:cell <- rest x + rest:&:cell <- rest x buf <- to-buffer rest, buf buf <- append buf, [ >] ] @@ -352,105 +352,105 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color scenario parse-single-letter-atom [ local-scope s:text <- new [a] - x:address:cell <- parse s + x:&:cell <- parse s s2:text, 10:boolean/raw <- maybe-convert *x, atom:variant - 11:array:character/raw <- copy *s2 + 11:@:char/raw <- copy *s2 memory-should-contain [ 10 <- 1 # parse result is an atom - 11:array:character <- [a] + 11:@:char <- [a] ] ] scenario parse-atom [ local-scope s:text <- new [abc] - x:address:cell <- parse s + x:&:cell <- parse s s2:text, 10:boolean/raw <- maybe-convert *x, atom:variant - 11:array:character/raw <- copy *s2 + 11:@:char/raw <- copy *s2 memory-should-contain [ 10 <- 1 # parse result is an atom - 11:array:character <- [abc] + 11:@:char <- [abc] ] ] scenario parse-list-of-two-atoms [ local-scope s:text <- new [(abc def)] - x:address:cell <- parse s + x:&:cell <- parse s trace-should-contain [ app/parse: < abc | < def | <> > > ] 10:boolean/raw <- is-pair? x - x1:address:cell <- first x - x2:address:cell <- rest x + x1:&:cell <- first x + x2:&:cell <- rest x s1:text, 11:boolean/raw <- maybe-convert *x1, atom:variant 12:boolean/raw <- is-pair? x2 - x3:address:cell <- first x2 + x3:&:cell <- first x2 s2:text, 13:boolean/raw <- maybe-convert *x3, atom:variant - 14:address:cell/raw <- rest x2 - 20:array:character/raw <- copy *s1 - 30:array:character/raw <- copy *s2 + 14:&:cell/raw <- rest x2 + 20:@:char/raw <- copy *s1 + 30:@:char/raw <- copy *s2 memory-should-contain [ 10 <- 1 # parse result is a pair 11 <- 1 # result.first is an atom 12 <- 1 # result.rest is a pair 13 <- 1 # result.rest.first is an atom 14 <- 0 # result.rest.rest is nil - 20:array:character <- [abc] # result.first - 30:array:character <- [def] # result.rest.first + 20:@:char <- [abc] # result.first + 30:@:char <- [def] # result.rest.first ] ] scenario parse-list-with-extra-spaces [ local-scope s:text <- new [ ( abc def ) ] # extra spaces - x:address:cell <- parse s + x:&:cell <- parse s trace-should-contain [ app/parse: < abc | < def | <> > > ] 10:boolean/raw <- is-pair? x - x1:address:cell <- first x - x2:address:cell <- rest x + x1:&:cell <- first x + x2:&:cell <- rest x s1:text, 11:boolean/raw <- maybe-convert *x1, atom:variant 12:boolean/raw <- is-pair? x2 - x3:address:cell <- first x2 + x3:&:cell <- first x2 s2:text, 13:boolean/raw <- maybe-convert *x3, atom:variant - 14:address:cell/raw <- rest x2 - 20:array:character/raw <- copy *s1 - 30:array:character/raw <- copy *s2 + 14:&:cell/raw <- rest x2 + 20:@:char/raw <- copy *s1 + 30:@:char/raw <- copy *s2 memory-should-contain [ 10 <- 1 # parse result is a pair 11 <- 1 # result.first is an atom 12 <- 1 # result.rest is a pair 13 <- 1 # result.rest.first is an atom 14 <- 0 # result.rest.rest is nil - 20:array:character <- [abc] # result.first - 30:array:character <- [def] # result.rest.first + 20:@:char <- [abc] # result.first + 30:@:char <- [def] # result.rest.first ] ] scenario parse-list-of-more-than-two-atoms [ local-scope s:text <- new [(abc def ghi)] - x:address:cell <- parse s + x:&:cell <- parse s trace-should-contain [ app/parse: < abc | < def | < ghi | <> > > > ] 10:boolean/raw <- is-pair? x - x1:address:cell <- first x - x2:address:cell <- rest x + x1:&:cell <- first x + x2:&:cell <- rest x s1:text, 11:boolean/raw <- maybe-convert *x1, atom:variant 12:boolean/raw <- is-pair? x2 - x3:address:cell <- first x2 + x3:&:cell <- first x2 s2:text, 13:boolean/raw <- maybe-convert *x3, atom:variant - x4:address:cell <- rest x2 + x4:&:cell <- rest x2 14:boolean/raw <- is-pair? x4 - x5:address:cell <- first x4 + x5:&:cell <- first x4 s3:text, 15:boolean/raw <- maybe-convert *x5, atom:variant - 16:address:cell/raw <- rest x4 - 20:array:character/raw <- copy *s1 - 30:array:character/raw <- copy *s2 - 40:array:character/raw <- copy *s3 + 16:&:cell/raw <- rest x4 + 20:@:char/raw <- copy *s1 + 30:@:char/raw <- copy *s2 + 40:@:char/raw <- copy *s3 memory-should-contain [ 10 <- 1 # parse result is a pair 11 <- 1 # result.first is an atom @@ -459,56 +459,56 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color 14 <- 1 # result.rest.rest is a pair 15 <- 1 # result.rest.rest.first is an atom 16 <- 0 # result.rest.rest.rest is nil - 20:array:character <- [abc] # result.first - 30:array:character <- [def] # result.rest.first - 40:array:character <- [ghi] # result.rest.rest + 20:@:char <- [abc] # result.first + 30:@:char <- [def] # result.rest.first + 40:@:char <- [ghi] # result.rest.rest ] ] scenario parse-nested-list [ local-scope s:text <- new [((abc))] - x:address:cell <- parse s + x:&:cell <- parse s trace-should-contain [ app/parse: < < abc | <> > | <> > ] 10:boolean/raw <- is-pair? x - x1:address:cell <- first x + x1:&:cell <- first x 11:boolean/raw <- is-pair? x - x2:address:cell <- first x1 + x2:&:cell <- first x1 s1:text, 12:boolean/raw <- maybe-convert *x2, atom:variant - 13:address:cell/raw <- rest x1 - 14:address:cell/raw <- rest x - 20:array:character/raw <- copy *s1 + 13:&:cell/raw <- rest x1 + 14:&:cell/raw <- rest x + 20:@:char/raw <- copy *s1 memory-should-contain [ 10 <- 1 # parse result is a pair 11 <- 1 # result.first is a pair 12 <- 1 # result.first.first is an atom 13 <- 0 # result.first.rest is nil 14 <- 0 # result.rest is nil - 20:array:character <- [abc] # result.first.first + 20:@:char <- [abc] # result.first.first ] ] scenario parse-nested-list-2 [ local-scope s:text <- new [((abc) def)] - x:address:cell <- parse s + x:&:cell <- parse s trace-should-contain [ app/parse: < < abc | <> > | < def | <> > > ] 10:boolean/raw <- is-pair? x - x1:address:cell <- first x + x1:&:cell <- first x 11:boolean/raw <- is-pair? x - x2:address:cell <- first x1 + x2:&:cell <- first x1 s1:text, 12:boolean/raw <- maybe-convert *x2, atom:variant - 13:address:cell/raw <- rest x1 - x3:address:cell <- rest x - x4:address:cell <- first x3 + 13:&:cell/raw <- rest x1 + x3:&:cell <- rest x + x4:&:cell <- first x3 s2:text, 14:boolean/raw <- maybe-convert *x4, atom:variant - 15:address:cell/raw <- rest x3 - 20:array:character/raw <- copy *s1 - 30:array:character/raw <- copy *s2 + 15:&:cell/raw <- rest x3 + 20:@:char/raw <- copy *s1 + 30:@:char/raw <- copy *s2 memory-should-contain [ 10 <- 1 # parse result is a pair 11 <- 1 # result.first is a pair @@ -516,8 +516,8 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color 13 <- 0 # result.first.rest is nil 14 <- 1 # result.rest.first is an atom 15 <- 0 # result.rest.rest is nil - 20:array:character <- [abc] # result.first.first - 30:array:character <- [def] # result.rest.first + 20:@:char <- [abc] # result.first.first + 30:@:char <- [def] # result.rest.first ] ] @@ -527,7 +527,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color #? local-scope #? s:text <- new [(] #? #? hide-errors -#? x:address:cell <- parse s +#? x:&:cell <- parse s #? #? show-errors #? trace-should-contain [ #? error: unbalanced '(' in expression @@ -538,7 +538,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color #? local-scope #? s:text <- new [(abc] #? #? hide-errors -#? x:address:cell <- parse s +#? x:&:cell <- parse s #? #? show-errors #? trace-should-contain [ #? error: unbalanced '(' in expression @@ -548,69 +548,69 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color scenario parse-dotted-list-of-two-atoms [ local-scope s:text <- new [(abc . def)] - x:address:cell <- parse s + x:&:cell <- parse s trace-should-contain [ app/parse: < abc | def > ] 10:boolean/raw <- is-pair? x - x1:address:cell <- first x - x2:address:cell <- rest x + x1:&:cell <- first x + x2:&:cell <- rest x s1:text, 11:boolean/raw <- maybe-convert *x1, atom:variant s2:text, 12:boolean/raw <- maybe-convert *x2, atom:variant - 20:array:character/raw <- copy *s1 - 30:array:character/raw <- copy *s2 + 20:@:char/raw <- copy *s1 + 30:@:char/raw <- copy *s2 memory-should-contain [ # parses to < abc | def > 10 <- 1 # parse result is a pair 11 <- 1 # result.first is an atom 12 <- 1 # result.rest is an atom - 20:array:character <- [abc] # result.first - 30:array:character <- [def] # result.rest + 20:@:char <- [abc] # result.first + 30:@:char <- [def] # result.rest ] ] scenario parse-dotted-list-of-more-than-two-atoms [ local-scope s:text <- new [(abc def . ghi)] - x:address:cell <- parse s + x:&:cell <- parse s trace-should-contain [ app/parse: < abc | < def | ghi > > ] 10:boolean/raw <- is-pair? x - x1:address:cell <- first x - x2:address:cell <- rest x + x1:&:cell <- first x + x2:&:cell <- rest x s1:text, 11:boolean/raw <- maybe-convert *x1, atom:variant 12:boolean/raw <- is-pair? x2 - x3:address:cell <- first x2 + x3:&:cell <- first x2 s2:text, 13:boolean/raw <- maybe-convert *x3, atom:variant - x4:address:cell <- rest x2 + x4:&:cell <- rest x2 s3:text, 14:boolean/raw <- maybe-convert *x4, atom:variant - 20:array:character/raw <- copy *s1 - 30:array:character/raw <- copy *s2 - 40:array:character/raw <- copy *s3 + 20:@:char/raw <- copy *s1 + 30:@:char/raw <- copy *s2 + 40:@:char/raw <- copy *s3 memory-should-contain [ 10 <- 1 # parse result is a pair 11 <- 1 # result.first is an atom 12 <- 1 # result.rest is a pair 13 <- 1 # result.rest.first is an atom 14 <- 1 # result.rest.rest is an atom - 20:array:character <- [abc] # result.first - 30:array:character <- [def] # result.rest.first - 40:array:character <- [ghi] # result.rest.rest + 20:@:char <- [abc] # result.first + 30:@:char <- [def] # result.rest.first + 40:@:char <- [ghi] # result.rest.rest ] ] ## convert tree of cells to mu text -def to-mu in:address:cell -> out:address:array:character [ +def to-mu in:&:cell -> out:text [ local-scope load-ingredients - buf:address:buffer <- new-buffer 30 + buf:&:buffer <- new-buffer 30 buf <- to-mu in, buf out <- buffer-to-array buf ] -def to-mu in:address:cell, buf:address:buffer -> buf:address:buffer, result-name:address:array:character [ +def to-mu in:&:cell, buf:&:buffer -> buf:&:buffer, result-name:text [ local-scope load-ingredients # null cell? no change. -- cgit 1.4.1-2-gfad0