Mu - immutable-error.mu

From bf37b4d56e0ff1c0eba338ff094c75762e3b1811 Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Sun, 18 Sep 2016 09:55:49 -0700 Subject: 3401 --- html/091socket.cc.html | 73 +++-- html/immutable-error.mu.html | 47 ++++ html/immutable_error.mu.html | 47 ---- html/lambda-to-mu.mu.html | 624 +++++++++++++++++++++++++++++++++++++++++++ html/lambda_to_mu.mu.html | 624 ------------------------------------------- html/real-files.mu.html | 52 ++++ html/real_files.mu.html | 52 ---- html/server-socket.mu.html | 24 +- html/static-dispatch.mu.html | 55 ++++ html/static_dispatch.mu.html | 55 ---- index.html | 2 +- 11 files changed, 857 insertions(+), 798 deletions(-) create mode 100644 html/immutable-error.mu.html delete mode 100644 html/immutable_error.mu.html create mode 100644 html/lambda-to-mu.mu.html delete mode 100644 html/lambda_to_mu.mu.html create mode 100644 html/real-files.mu.html delete mode 100644 html/real_files.mu.html create mode 100644 html/static-dispatch.mu.html delete mode 100644 html/static_dispatch.mu.html diff --git a/html/091socket.cc.html b/html/091socket.cc.html index 306f3a31..a33755ef 100644 --- a/html/091socket.cc.html +++ b/html/091socket.cc.html @@ -19,6 +19,7 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color .Identifier { color: #fcb165; } .Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; } .PreProc { color: #800080; } +.Comment { color: #9090ff; } --> @@ -88,13 +89,14 @@ put(Recipe_ordinal,:(before "End Primitive Recipe Implementations") case _SOCKET: { int port = ingredients.at(0).at(0); - socket_t server; - server_socket(port, &server); - if (server.fd < 0) { + socket_t* server = new socket_t(); + server_socket(port, server); + if (server->fd < 0) { break; } + long long int result = reinterpret_cast<long long int>(server); products.resize(1); - products.at(0).push_back(server.fd); + products.at(0).push_back(static_cast<double>(result)); break; } @@ -129,11 +131,14 @@ put(Recipe_ordinal,} :(before "End Primitive Recipe Implementations") case _ACCEPT: { - double socket_fd = ingredients.at(0).at(0); - socket_t session; - session_socket(socket_fd, &session); - products.resize(1); - products.at(0).push_back(session.fd); + long long int x = static_cast<long long int>(ingredients.at(0).at(0)); + socket_t* socket = reinterpret_cast<socket_t*>(x); + socket_t* session = new socket_t(); + session_socket(socket->fd, session); + products.resize(2); + long long int result = reinterpret_cast<long long int>(session); + products.at(0).push_back(static_cast<double>(result)); + products.at(1).push_back(ingredients.at(0).at(0)); break; } @@ -151,7 +156,7 @@ put(Recipe_ordinal,(get(Recipe, r).name) << "first ingredient of '$read-from-socket' should be a number, but got '" << to_string(inst.ingredients.at(0)) << "'\n" << end(); break; } - if (SIZE(inst.products) != 1) { + if (SIZE(inst.products) != 2) { raise << maybe(get(Recipe, r).name) << "'$read-from-socket' requires exactly one product, but got '" << inst.original_string << "'\n" << end(); break; } @@ -159,21 +164,57 @@ put(Recipe_ordinal,(get(Recipe, r).name) << "first product of '$read-from-socket' should be a character, but got '" << to_string(inst.products.at(0)) << "'\n" << end(); break; } + if (!is_mu_boolean(inst.products.at(1))) { + raise << maybe(get(Recipe, r).name) << "second product of '$read-from-socket' should be a boolean but got '" << to_string(inst.products.at(1)) << "'\n" << end(); + break; + } break; } :(before "End Primitive Recipe Implementations") case _READ_FROM_SOCKET: { - products.resize(1); - double socket_fd = ingredients.at(0).at(0); + long long int x = static_cast<long long int>(ingredients.at(0).at(0)); + socket_t* socket = reinterpret_cast<socket_t*>(x); + int socket_fd = socket->fd; char single_char[2]; bzero(single_char, 2); - if (read(socket_fd, single_char, 1) < 0) { - raise << maybe(current_recipe_name()) << "read from socket failed\n" << end(); - products.at(0).push_back(0); - break; + int bytes_read = read(socket_fd, single_char, 1); + products.resize(2); + if (single_char[0]== EOF || bytes_read == 0) { + products.at(1).push_back(1); // eof + } + else { + products.at(1).push_back(0); } products.at(0).push_back(single_char[0]); break; + break; +} + +:(before "End Primitive Recipe Declarations") +_WRITE_TO_SOCKET, +:(before "End Primitive Recipe Numbers") +put(Recipe_ordinal, "$write-to-socket", _WRITE_TO_SOCKET); +:(before "End Primitive Recipe Checks") +case _WRITE_TO_SOCKET: { + if (SIZE(inst.ingredients) != 2) { + raise << maybe(get(Recipe, r).name) << "'$write-to-socket' requires exactly two ingredient, but got '" << inst.original_string << "'\n" << end(); + break; + } + break; +} +:(before "End Primitive Recipe Implementations") +case _WRITE_TO_SOCKET: { + long long int x = static_cast<long long int>(ingredients.at(0).at(0)); + socket_t* session = reinterpret_cast<socket_t*>(x); + // Write one character to a session at a time. + long long int y = static_cast<long long int>(ingredients.at(1).at(0)); + char c = static_cast<char>(y); + char payload[2] = { c }; + write(session->fd, payload, 1); + long long int result = reinterpret_cast<long long int>(session); + products.resize(1); + products.at(0).push_back(result); + break; } :(before "End Primitive Recipe Declarations") diff --git a/html/immutable-error.mu.html b/html/immutable-error.mu.html new file mode 100644 index 00000000..0a757e21 --- /dev/null +++ b/html/immutable-error.mu.html @@ -0,0 +1,47 @@ + + + + +Mu - immutable-error.mu + + + + + + + + + + +

+# compare mutable.mu
+
+def main [
+  local-scope
+  x:&:num <- new number:type
+  foo x
+]
+
+def foo x:&:num [
+  local-scope
+  load-ingredients
+  *x <- copy 34  # will cause an error because x is immutable in this function
+]
+

+ + + diff --git a/html/immutable_error.mu.html b/html/immutable_error.mu.html deleted file mode 100644 index 0e2a141a..00000000 --- a/html/immutable_error.mu.html +++ /dev/null @@ -1,47 +0,0 @@ - - - - -Mu - immutable_error.mu - - - - - - - - - - -

-# compare mutable.mu
-
-def main [
-  local-scope
-  x:&:num <- new number:type
-  foo x
-]
-
-def foo x:&:num [
-  local-scope
-  load-ingredients
-  *x <- copy 34  # will cause an error because x is immutable in this function
-]
-

- - - diff --git a/html/lambda-to-mu.mu.html b/html/lambda-to-mu.mu.html new file mode 100644 index 00000000..5383acd5 --- /dev/null +++ b/html/lambda-to-mu.mu.html @@ -0,0 +1,624 @@ + + + + +Mu - lambda-to-mu.mu + + + + + + + + + + +

+## experimental compiler to translate programs written in a generic
+## expression-oriented language called 'lambda' into mu
+
+scenario convert-lambda [
+  run [
+    local-scope
+    1:text/raw <- lambda-to-mu [(add a (multiply b c))]
+    2:@:char/raw <- copy *1:text/raw
+  ]
+  memory-should-contain [
+    2:@:char <- [t1 <- multiply b c
+result <- add a t1]
+  ]
+]
+
+def lambda-to-mu in:text -> out:text [
+  local-scope
+  load-ingredients
+  out <- copy 0
+  cells:&:cell <- parse in
+  out <- to-mu cells
+]
+
+# 'parse' will turn lambda expressions into trees made of cells
+exclusive-container cell [
+  atom:text
+  pair:pair
+]
+
+# printed below as < first | rest >
+container pair [
+  first:&:cell
+  rest:&: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:&: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:&:cell -> result:boolean [
+  local-scope
+  load-ingredients
+  reply-unless x, 0/false
+  _, result <- maybe-convert *x, atom:variant
+]
+
+def is-pair? x:&:cell -> result:boolean [
+  local-scope
+  load-ingredients
+  reply-unless x, 0/false
+  _, result <- maybe-convert *x, pair:variant
+]
+
+scenario atom-is-not-pair [
+  local-scope
+  s:text <- new [a]
+  x:&:cell <- new-atom s
+  10:boolean/raw <- is-atom? x
+  11:boolean/raw <- is-pair? x
+  memory-should-contain [
+    10 <- 1
+    11 <- 0
+  ]
+]
+
+scenario pair-is-not-atom [
+  local-scope
+  # construct (a . nil)
+  s:text <- new [a]
+  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 [
+    10 <- 0
+    11 <- 1
+  ]
+]
+
+def atom-match? x:&:cell, pat:text -> result:boolean [
+  local-scope
+  load-ingredients
+  s:text, is-atom?:boolean <- maybe-convert *x, atom:variant
+  reply-unless is-atom?, 0/false
+  result <- equal pat, s
+]
+
+scenario atom-match [
+  local-scope
+  x:&:cell <- new-atom [abc]
+  10:boolean/raw <- atom-match? x, [abc]
+  memory-should-contain [
+    10 <- 1
+  ]
+]
+
+def first x:&:cell -> result:&:cell [
+  local-scope
+  load-ingredients
+  pair:pair, pair?:boolean <- maybe-convert *x, pair:variant
+  reply-unless pair?, 0/nil
+  result <- get pair, first:offset
+]
+
+def rest x:&:cell -> result:&:cell [
+  local-scope
+  load-ingredients
+  pair:pair, pair?:boolean <- maybe-convert *x, pair:variant
+  reply-unless pair?, 0/nil
+  result <- get pair, rest:offset
+]
+
+def set-first base:&:cell, new-first:&:cell -> base:&:cell [
+  local-scope
+  load-ingredients
+  pair:pair, is-pair?:boolean <- maybe-convert *base, pair:variant
+  reply-unless is-pair?
+  pair <- put pair, first:offset, new-first
+  *base <- merge 1/pair, pair
+]
+
+def set-rest base:&:cell, new-rest:&:cell -> base:&:cell [
+  local-scope
+  load-ingredients
+  pair:pair, is-pair?:boolean <- maybe-convert *base, pair:variant
+  reply-unless is-pair?
+  pair <- put pair, rest:offset, new-rest
+  *base <- merge 1/pair, pair
+]
+
+scenario cell-operations-on-atom [
+  local-scope
+  s:text <- new [a]
+  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
+  ]
+]
+
+scenario cell-operations-on-pair [
+  local-scope
+  # construct (a . nil)
+  s:text <- new [a]
+  x:&:cell <- new-atom s
+  y:&:cell <- new-pair x, 0/nil
+  x2:&:cell <- first y
+  10:boolean/raw <- equal x, x2
+  11:&:cell/raw <- rest y
+  memory-should-contain [
+    10 <- 1  # first is correct
+    11 <- 0  # rest is nil
+  ]
+]
+
+## convert lambda text to a tree of cells
+
+def parse in:text -> out:&:cell [
+  local-scope
+  load-ingredients
+  s:&:stream:char <- new-stream in
+  out, s <- parse s
+  trace 2, [app/parse], out
+]
+
+def parse in:&:stream:char -> out:&:cell, in:&:stream:char [
+  local-scope
+  load-ingredients
+  # skip whitespace
+  in <- skip-whitespace in
+  c:char, eof?:boolean <- peek in
+  reply-if eof?, 0/nil
+  pair?:boolean <- equal c, 40/open-paren
+  {
+    break-if pair?
+    # atom
+    b:&:buffer <- new-buffer 30
+    {
+      done?:boolean <- end-of-stream? in
+      break-if done?
+      # stop before close paren or space
+      c:char <- peek in
+      done? <- equal c, 41/close-paren
+      break-if done?
+      done? <- space? c
+      break-if done?
+      c <- read in
+      b <- append b, c
+      loop
+    }
+    s:text <- buffer-to-array b
+    out <- new-atom s
+  }
+  {
+    break-unless pair?
+    # pair
+    read in  # skip the open-paren
+    out <- new cell:type  # start out with nil
+    # read in first element of pair
+    {
+      end?:boolean <- end-of-stream? in
+      not-end?:boolean <- not end?
+      assert not-end?, [unbalanced '(' in expression]
+      c <- peek in
+      close-paren?:boolean <- equal c, 41/close-paren
+      break-if close-paren?
+      first:&:cell, in <- parse in
+      *out <- merge 1/pair, first, 0/nil
+    }
+    # read in any remaining elements
+    curr:&:cell <- copy out
+    {
+      in <- skip-whitespace in
+      end?:boolean <- end-of-stream? in
+      not-end?:boolean <- not end?
+      assert not-end?, [unbalanced '(' in expression]
+      # termination check: ')'
+      c <- peek in
+      {
+        close-paren?:boolean <- equal c, 41/close-paren
+        break-unless close-paren?
+        read in  # skip ')'
+        break +end-pair:label
+      }
+      # still here? read next element of pair
+      next:&:cell, in <- parse in
+      is-dot?:boolean <- atom-match? next, [.]
+      {
+        break-if is-dot?
+        next-curr:&:cell <- new-pair next, 0/nil
+        curr <- set-rest curr, next-curr
+        curr <- rest curr
+      }
+      {
+        break-unless is-dot?
+        # deal with dotted pair
+        in <- skip-whitespace in
+        c <- peek in
+        not-close-paren?:boolean <- not-equal c, 41/close-paren
+        assert not-close-paren?, [')' cannot immediately follow '.']
+        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
+        in <- skip-whitespace in
+        c <- peek in
+        close-paren?:boolean <- equal c, 41/close-paren
+        assert close-paren?, ['.' must be followed by exactly one expression before ')']
+      }
+      loop
+    }
+    +end-pair
+  }
+]
+
+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:char <- peek in
+    space?:boolean <- space? c
+    break-unless space?
+    read in  # skip
+    loop
+  }
+]
+
+def to-text x:&:cell -> out:text [
+  local-scope
+  load-ingredients
+  buf:&:buffer <- new-buffer 30
+  buf <- to-buffer x, buf
+  out <- buffer-to-array buf
+]
+
+def to-buffer x:&:cell, buf:&:buffer -> buf:&:buffer [
+  local-scope
+  load-ingredients
+  # base case: empty cell
+  {
+    break-if x
+    buf <- append buf, [<>]
+    reply
+  }
+  # base case: atom
+  {
+    s:text, atom?:boolean <- maybe-convert *x, atom:variant
+    break-unless atom?
+    buf <- append buf, s
+    reply
+  }
+  # recursive case: pair
+  buf <- append buf, [< ]
+  first:&:cell <- first x
+  buf <- to-buffer first, buf
+  buf <- append buf, [ | ]
+  rest:&:cell <- rest x
+  buf <- to-buffer rest, buf
+  buf <- append buf, [ >]
+]
+
+scenario parse-single-letter-atom [
+  local-scope
+  s:text <- new [a]
+  x:&:cell <- parse s
+  s2:text, 10:boolean/raw <- maybe-convert *x, atom:variant
+  11:@:char/raw <- copy *s2
+  memory-should-contain [
+    10 <- 1  # parse result is an atom
+    11:@:char <- [a]
+  ]
+]
+
+scenario parse-atom [
+  local-scope
+  s:text <- new [abc]
+  x:&:cell <- parse s
+  s2:text, 10:boolean/raw <- maybe-convert *x, atom:variant
+  11:@:char/raw <- copy *s2
+  memory-should-contain [
+    10 <- 1  # parse result is an atom
+    11:@:char <- [abc]
+  ]
+]
+
+scenario parse-list-of-two-atoms [
+  local-scope
+  s:text <- new [(abc def)]
+  x:&:cell <- parse s
+  trace-should-contain [
+    app/parse: < abc | < def | <> > >
+  ]
+  10:boolean/raw <- is-pair? 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:&:cell <- first x2
+  s2:text, 13:boolean/raw <- maybe-convert *x3, atom:variant
+  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:@: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:&:cell <- parse s
+  trace-should-contain [
+    app/parse: < abc | < def | <> > >
+  ]
+  10:boolean/raw <- is-pair? 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:&:cell <- first x2
+  s2:text, 13:boolean/raw <- maybe-convert *x3, atom:variant
+  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:@: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:&:cell <- parse s
+  trace-should-contain [
+    app/parse: < abc | < def | < ghi | <> > > >
+  ]
+  10:boolean/raw <- is-pair? 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:&:cell <- first x2
+  s2:text, 13:boolean/raw <- maybe-convert *x3, atom:variant
+  x4:&:cell <- rest x2
+  14:boolean/raw <- is-pair? x4
+  x5:&:cell <- first x4
+  s3:text, 15:boolean/raw <- maybe-convert *x5, atom:variant
+  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
+    12 <- 1  # result.rest is a pair
+    13 <- 1  # result.rest.first is an atom
+    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:@: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:&:cell <- parse s
+  trace-should-contain [
+    app/parse: < < abc | <> > | <> >
+  ]
+  10:boolean/raw <- is-pair? x
+  x1:&:cell <- first x
+  11:boolean/raw <- is-pair? x
+  x2:&:cell <- first x1
+  s1:text, 12:boolean/raw <- maybe-convert *x2, atom:variant
+  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:@:char <- [abc]  # result.first.first
+  ]
+]
+
+scenario parse-nested-list-2 [
+  local-scope
+  s:text <- new [((abc) def)]
+  x:&:cell <- parse s
+  trace-should-contain [
+    app/parse: < < abc | <> > | < def | <> > >
+  ]
+  10:boolean/raw <- is-pair? x
+  x1:&:cell <- first x
+  11:boolean/raw <- is-pair? x
+  x2:&:cell <- first x1
+  s1:text, 12:boolean/raw <- maybe-convert *x2, atom:variant
+  13:&:cell/raw <- rest x1
+  x3:&:cell <- rest x
+  x4:&:cell <- first x3
+  s2:text, 14:boolean/raw <- maybe-convert *x4, atom:variant
+  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
+    12 <- 1  # result.first.first is an atom
+    13 <- 0  # result.first.rest is nil
+    14 <- 1  # result.rest.first is an atom
+    15 <- 0  # result.rest.rest is nil
+    20:@:char <- [abc]  # result.first.first
+    30:@:char <- [def]  # result.rest.first
+  ]
+]
+
+# todo: uncomment these tests after we figure out how to continue tests after
+# assertion failures
+#? scenario parse-error [
+#?   local-scope
+#?   s:text <- new [(]
+#? #?   hide-errors
+#?   x:&:cell <- parse s
+#? #?   show-errors
+#?   trace-should-contain [
+#?     error: unbalanced '(' in expression
+#?   ]
+#? ]
+#? 
+#? scenario parse-error-after-element [
+#?   local-scope
+#?   s:text <- new [(abc]
+#? #?   hide-errors
+#?   x:&:cell <- parse s
+#? #?   show-errors
+#?   trace-should-contain [
+#?     error: unbalanced '(' in expression
+#?   ]
+#? ]
+
+scenario parse-dotted-list-of-two-atoms [
+  local-scope
+  s:text <- new [(abc . def)]
+  x:&:cell <- parse s
+  trace-should-contain [
+    app/parse: < abc | def >
+  ]
+  10:boolean/raw <- is-pair? 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:@: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:@: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:&:cell <- parse s
+  trace-should-contain [
+    app/parse: < abc | < def | ghi > >
+  ]
+  10:boolean/raw <- is-pair? 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:&:cell <- first x2
+  s2:text, 13:boolean/raw <- maybe-convert *x3, atom:variant
+  x4:&:cell <- rest x2
+  s3:text, 14:boolean/raw <- maybe-convert *x4, atom:variant
+  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:@: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:&:cell -> out:text [
+  local-scope
+  load-ingredients
+  buf:&:buffer <- new-buffer 30
+  buf <- to-mu in, buf
+  out <- buffer-to-array buf
+]
+
+def to-mu in:&:cell, buf:&:buffer -> buf:&:buffer, result-name:text [
+  local-scope
+  load-ingredients
+  # null cell? no change.
+  # pair with all atoms? gensym a new variable
+  # pair containing other pairs? recurse
+  result-name <- copy 0
+]
+

+ + + diff --git a/html/lambda_to_mu.mu.html b/html/lambda_to_mu.mu.html deleted file mode 100644 index 0bfee036..00000000 --- a/html/lambda_to_mu.mu.html +++ /dev/null @@ -1,624 +0,0 @@ - - - - -Mu - lambda_to_mu.mu - - - - - - - - - - -

-## experimental compiler to translate programs written in a generic
-## expression-oriented language called 'lambda' into mu
-
-scenario convert-lambda [
-  run [
-    local-scope
-    1:text/raw <- lambda-to-mu [(add a (multiply b c))]
-    2:@:char/raw <- copy *1:text/raw
-  ]
-  memory-should-contain [
-    2:@:char <- [t1 <- multiply b c
-result <- add a t1]
-  ]
-]
-
-def lambda-to-mu in:text -> out:text [
-  local-scope
-  load-ingredients
-  out <- copy 0
-  cells:&:cell <- parse in
-  out <- to-mu cells
-]
-
-# 'parse' will turn lambda expressions into trees made of cells
-exclusive-container cell [
-  atom:text
-  pair:pair
-]
-
-# printed below as < first | rest >
-container pair [
-  first:&:cell
-  rest:&: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:&: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:&:cell -> result:boolean [
-  local-scope
-  load-ingredients
-  reply-unless x, 0/false
-  _, result <- maybe-convert *x, atom:variant
-]
-
-def is-pair? x:&:cell -> result:boolean [
-  local-scope
-  load-ingredients
-  reply-unless x, 0/false
-  _, result <- maybe-convert *x, pair:variant
-]
-
-scenario atom-is-not-pair [
-  local-scope
-  s:text <- new [a]
-  x:&:cell <- new-atom s
-  10:boolean/raw <- is-atom? x
-  11:boolean/raw <- is-pair? x
-  memory-should-contain [
-    10 <- 1
-    11 <- 0
-  ]
-]
-
-scenario pair-is-not-atom [
-  local-scope
-  # construct (a . nil)
-  s:text <- new [a]
-  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 [
-    10 <- 0
-    11 <- 1
-  ]
-]
-
-def atom-match? x:&:cell, pat:text -> result:boolean [
-  local-scope
-  load-ingredients
-  s:text, is-atom?:boolean <- maybe-convert *x, atom:variant
-  reply-unless is-atom?, 0/false
-  result <- equal pat, s
-]
-
-scenario atom-match [
-  local-scope
-  x:&:cell <- new-atom [abc]
-  10:boolean/raw <- atom-match? x, [abc]
-  memory-should-contain [
-    10 <- 1
-  ]
-]
-
-def first x:&:cell -> result:&:cell [
-  local-scope
-  load-ingredients
-  pair:pair, pair?:boolean <- maybe-convert *x, pair:variant
-  reply-unless pair?, 0/nil
-  result <- get pair, first:offset
-]
-
-def rest x:&:cell -> result:&:cell [
-  local-scope
-  load-ingredients
-  pair:pair, pair?:boolean <- maybe-convert *x, pair:variant
-  reply-unless pair?, 0/nil
-  result <- get pair, rest:offset
-]
-
-def set-first base:&:cell, new-first:&:cell -> base:&:cell [
-  local-scope
-  load-ingredients
-  pair:pair, is-pair?:boolean <- maybe-convert *base, pair:variant
-  reply-unless is-pair?
-  pair <- put pair, first:offset, new-first
-  *base <- merge 1/pair, pair
-]
-
-def set-rest base:&:cell, new-rest:&:cell -> base:&:cell [
-  local-scope
-  load-ingredients
-  pair:pair, is-pair?:boolean <- maybe-convert *base, pair:variant
-  reply-unless is-pair?
-  pair <- put pair, rest:offset, new-rest
-  *base <- merge 1/pair, pair
-]
-
-scenario cell-operations-on-atom [
-  local-scope
-  s:text <- new [a]
-  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
-  ]
-]
-
-scenario cell-operations-on-pair [
-  local-scope
-  # construct (a . nil)
-  s:text <- new [a]
-  x:&:cell <- new-atom s
-  y:&:cell <- new-pair x, 0/nil
-  x2:&:cell <- first y
-  10:boolean/raw <- equal x, x2
-  11:&:cell/raw <- rest y
-  memory-should-contain [
-    10 <- 1  # first is correct
-    11 <- 0  # rest is nil
-  ]
-]
-
-## convert lambda text to a tree of cells
-
-def parse in:text -> out:&:cell [
-  local-scope
-  load-ingredients
-  s:&:stream:char <- new-stream in
-  out, s <- parse s
-  trace 2, [app/parse], out
-]
-
-def parse in:&:stream:char -> out:&:cell, in:&:stream:char [
-  local-scope
-  load-ingredients
-  # skip whitespace
-  in <- skip-whitespace in
-  c:char, eof?:boolean <- peek in
-  reply-if eof?, 0/nil
-  pair?:boolean <- equal c, 40/open-paren
-  {
-    break-if pair?
-    # atom
-    b:&:buffer <- new-buffer 30
-    {
-      done?:boolean <- end-of-stream? in
-      break-if done?
-      # stop before close paren or space
-      c:char <- peek in
-      done? <- equal c, 41/close-paren
-      break-if done?
-      done? <- space? c
-      break-if done?
-      c <- read in
-      b <- append b, c
-      loop
-    }
-    s:text <- buffer-to-array b
-    out <- new-atom s
-  }
-  {
-    break-unless pair?
-    # pair
-    read in  # skip the open-paren
-    out <- new cell:type  # start out with nil
-    # read in first element of pair
-    {
-      end?:boolean <- end-of-stream? in
-      not-end?:boolean <- not end?
-      assert not-end?, [unbalanced '(' in expression]
-      c <- peek in
-      close-paren?:boolean <- equal c, 41/close-paren
-      break-if close-paren?
-      first:&:cell, in <- parse in
-      *out <- merge 1/pair, first, 0/nil
-    }
-    # read in any remaining elements
-    curr:&:cell <- copy out
-    {
-      in <- skip-whitespace in
-      end?:boolean <- end-of-stream? in
-      not-end?:boolean <- not end?
-      assert not-end?, [unbalanced '(' in expression]
-      # termination check: ')'
-      c <- peek in
-      {
-        close-paren?:boolean <- equal c, 41/close-paren
-        break-unless close-paren?
-        read in  # skip ')'
-        break +end-pair:label
-      }
-      # still here? read next element of pair
-      next:&:cell, in <- parse in
-      is-dot?:boolean <- atom-match? next, [.]
-      {
-        break-if is-dot?
-        next-curr:&:cell <- new-pair next, 0/nil
-        curr <- set-rest curr, next-curr
-        curr <- rest curr
-      }
-      {
-        break-unless is-dot?
-        # deal with dotted pair
-        in <- skip-whitespace in
-        c <- peek in
-        not-close-paren?:boolean <- not-equal c, 41/close-paren
-        assert not-close-paren?, [')' cannot immediately follow '.']
-        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
-        in <- skip-whitespace in
-        c <- peek in
-        close-paren?:boolean <- equal c, 41/close-paren
-        assert close-paren?, ['.' must be followed by exactly one expression before ')']
-      }
-      loop
-    }
-    +end-pair
-  }
-]
-
-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:char <- peek in
-    space?:boolean <- space? c
-    break-unless space?
-    read in  # skip
-    loop
-  }
-]
-
-def to-text x:&:cell -> out:text [
-  local-scope
-  load-ingredients
-  buf:&:buffer <- new-buffer 30
-  buf <- to-buffer x, buf
-  out <- buffer-to-array buf
-]
-
-def to-buffer x:&:cell, buf:&:buffer -> buf:&:buffer [
-  local-scope
-  load-ingredients
-  # base case: empty cell
-  {
-    break-if x
-    buf <- append buf, [<>]
-    reply
-  }
-  # base case: atom
-  {
-    s:text, atom?:boolean <- maybe-convert *x, atom:variant
-    break-unless atom?
-    buf <- append buf, s
-    reply
-  }
-  # recursive case: pair
-  buf <- append buf, [< ]
-  first:&:cell <- first x
-  buf <- to-buffer first, buf
-  buf <- append buf, [ | ]
-  rest:&:cell <- rest x
-  buf <- to-buffer rest, buf
-  buf <- append buf, [ >]
-]
-
-scenario parse-single-letter-atom [
-  local-scope
-  s:text <- new [a]
-  x:&:cell <- parse s
-  s2:text, 10:boolean/raw <- maybe-convert *x, atom:variant
-  11:@:char/raw <- copy *s2
-  memory-should-contain [
-    10 <- 1  # parse result is an atom
-    11:@:char <- [a]
-  ]
-]
-
-scenario parse-atom [
-  local-scope
-  s:text <- new [abc]
-  x:&:cell <- parse s
-  s2:text, 10:boolean/raw <- maybe-convert *x, atom:variant
-  11:@:char/raw <- copy *s2
-  memory-should-contain [
-    10 <- 1  # parse result is an atom
-    11:@:char <- [abc]
-  ]
-]
-
-scenario parse-list-of-two-atoms [
-  local-scope
-  s:text <- new [(abc def)]
-  x:&:cell <- parse s
-  trace-should-contain [
-    app/parse: < abc | < def | <> > >
-  ]
-  10:boolean/raw <- is-pair? 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:&:cell <- first x2
-  s2:text, 13:boolean/raw <- maybe-convert *x3, atom:variant
-  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:@: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:&:cell <- parse s
-  trace-should-contain [
-    app/parse: < abc | < def | <> > >
-  ]
-  10:boolean/raw <- is-pair? 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:&:cell <- first x2
-  s2:text, 13:boolean/raw <- maybe-convert *x3, atom:variant
-  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:@: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:&:cell <- parse s
-  trace-should-contain [
-    app/parse: < abc | < def | < ghi | <> > > >
-  ]
-  10:boolean/raw <- is-pair? 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:&:cell <- first x2
-  s2:text, 13:boolean/raw <- maybe-convert *x3, atom:variant
-  x4:&:cell <- rest x2
-  14:boolean/raw <- is-pair? x4
-  x5:&:cell <- first x4
-  s3:text, 15:boolean/raw <- maybe-convert *x5, atom:variant
-  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
-    12 <- 1  # result.rest is a pair
-    13 <- 1  # result.rest.first is an atom
-    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:@: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:&:cell <- parse s
-  trace-should-contain [
-    app/parse: < < abc | <> > | <> >
-  ]
-  10:boolean/raw <- is-pair? x
-  x1:&:cell <- first x
-  11:boolean/raw <- is-pair? x
-  x2:&:cell <- first x1
-  s1:text, 12:boolean/raw <- maybe-convert *x2, atom:variant
-  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:@:char <- [abc]  # result.first.first
-  ]
-]
-
-scenario parse-nested-list-2 [
-  local-scope
-  s:text <- new [((abc) def)]
-  x:&:cell <- parse s
-  trace-should-contain [
-    app/parse: < < abc | <> > | < def | <> > >
-  ]
-  10:boolean/raw <- is-pair? x
-  x1:&:cell <- first x
-  11:boolean/raw <- is-pair? x
-  x2:&:cell <- first x1
-  s1:text, 12:boolean/raw <- maybe-convert *x2, atom:variant
-  13:&:cell/raw <- rest x1
-  x3:&:cell <- rest x
-  x4:&:cell <- first x3
-  s2:text, 14:boolean/raw <- maybe-convert *x4, atom:variant
-  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
-    12 <- 1  # result.first.first is an atom
-    13 <- 0  # result.first.rest is nil
-    14 <- 1  # result.rest.first is an atom
-    15 <- 0  # result.rest.rest is nil
-    20:@:char <- [abc]  # result.first.first
-    30:@:char <- [def]  # result.rest.first
-  ]
-]
-
-# todo: uncomment these tests after we figure out how to continue tests after
-# assertion failures
-#? scenario parse-error [
-#?   local-scope
-#?   s:text <- new [(]
-#? #?   hide-errors
-#?   x:&:cell <- parse s
-#? #?   show-errors
-#?   trace-should-contain [
-#?     error: unbalanced '(' in expression
-#?   ]
-#? ]
-#? 
-#? scenario parse-error-after-element [
-#?   local-scope
-#?   s:text <- new [(abc]
-#? #?   hide-errors
-#?   x:&:cell <- parse s
-#? #?   show-errors
-#?   trace-should-contain [
-#?     error: unbalanced '(' in expression
-#?   ]
-#? ]
-
-scenario parse-dotted-list-of-two-atoms [
-  local-scope
-  s:text <- new [(abc . def)]
-  x:&:cell <- parse s
-  trace-should-contain [
-    app/parse: < abc | def >
-  ]
-  10:boolean/raw <- is-pair? 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:@: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:@: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:&:cell <- parse s
-  trace-should-contain [
-    app/parse: < abc | < def | ghi > >
-  ]
-  10:boolean/raw <- is-pair? 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:&:cell <- first x2
-  s2:text, 13:boolean/raw <- maybe-convert *x3, atom:variant
-  x4:&:cell <- rest x2
-  s3:text, 14:boolean/raw <- maybe-convert *x4, atom:variant
-  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:@: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:&:cell -> out:text [
-  local-scope
-  load-ingredients
-  buf:&:buffer <- new-buffer 30
-  buf <- to-mu in, buf
-  out <- buffer-to-array buf
-]
-
-def to-mu in:&:cell, buf:&:buffer -> buf:&:buffer, result-name:text [
-  local-scope
-  load-ingredients
-  # null cell? no change.
-  # pair with all atoms? gensym a new variable
-  # pair containing other pairs? recurse
-  result-name <- copy 0
-]
-

- - - diff --git a/html/real-files.mu.html b/html/real-files.mu.html new file mode 100644 index 00000000..3ef5bc3c --- /dev/null +++ b/html/real-files.mu.html @@ -0,0 +1,52 @@ + + + + +Mu - real-files.mu + + + + + + + + + + +

+# example program: read a character from one file and write it to another
+# BEWARE: this will modify your file system
+# before running it, put a character into /tmp/mu-x
+# after running it, check /tmp/mu-y
+
+def main [
+  local-scope
+  f:num/file <- $open-file-for-reading [/tmp/mu-x]
+  $print [file to read from: ], f, 10/newline
+  c:char, eof?:boolean <- $read-from-file f
+  $print [copying ], c, 10/newline
+  f <- $close-file f
+  $print [file after closing: ], f, 10/newline
+  f <- $open-file-for-writing [/tmp/mu-y]
+  $print [file to write to: ], f, 10/newline
+  $write-to-file f, c
+  f <- $close-file f
+]
+

+ + + diff --git a/html/real_files.mu.html b/html/real_files.mu.html deleted file mode 100644 index 90700144..00000000 --- a/html/real_files.mu.html +++ /dev/null @@ -1,52 +0,0 @@ - - - - -Mu - real_files.mu - - - - - - - - - - -

-# example program: read a character from one file and write it to another
-# BEWARE: this will modify your file system
-# before running it, put a character into /tmp/mu-x
-# after running it, check /tmp/mu-y
-
-def main [
-  local-scope
-  f:num/file <- $open-file-for-reading [/tmp/mu-x]
-  $print [file to read from: ], f, 10/newline
-  c:char, eof?:boolean <- $read-from-file f
-  $print [copying ], c, 10/newline
-  f <- $close-file f
-  $print [file after closing: ], f, 10/newline
-  f <- $open-file-for-writing [/tmp/mu-y]
-  $print [file to write to: ], f, 10/newline
-  $write-to-file f, c
-  f <- $close-file f
-]
-

- - - diff --git a/html/server-socket.mu.html b/html/server-socket.mu.html index 5c11d638..0095f59a 100644 --- a/html/server-socket.mu.html +++ b/html/server-socket.mu.html @@ -34,15 +34,33 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color socket:num <- $socket 8080/port $print [Mu socket creation returned ], socket, 10/newline session:num <- $accept socket + write-to-socket session, [HTTP/1.0 200 OK + +OK] { - client-message:&:buffer <- new-buffer 1024 - c:char <- $read-from-socket session - break-unless c + c:char, eof?:boolean <- $read-from-socket session $print c + break-if eof? loop } + $print 10/newline, [Hit end of socket, closing...], 10/newline $close-socket socket, session ] + +def write-to-socket session-socket:number, s:address:array:character [ + local-scope + load-ingredients + len:number <- length *s + i:number <- copy 0 + { + done?:boolean <- greater-or-equal i, len + break-if done? + c:character <- index *s, i + $write-to-socket session-socket, c + i <- add i, 1 + loop + } +] diff --git a/html/static-dispatch.mu.html b/html/static-dispatch.mu.html new file mode 100644 index 00000000..466fbf50 --- /dev/null +++ b/html/static-dispatch.mu.html @@ -0,0 +1,55 @@ + + + + +Mu - static-dispatch.mu + + + + + + + + + + +

+def test a:num -> b:num [
+  local-scope
+  load-ingredients
+  b <- add a, 1
+]
+
+def test a:num, b:num -> c:num [
+  local-scope
+  load-ingredients
+  c <- add a, b
+]
+
+def main [
+  local-scope
+  a:num <- test 3  # selects single-ingredient version
+  $print a, 10/newline
+  b:num <- test 3, 4  # selects double-ingredient version
+  $print b, 10/newline
+  c:num <- test 3, 4, 5  # prefers double- to single-ingredient version
+  $print c, 10/newline
+]
+

+ + + diff --git a/html/static_dispatch.mu.html b/html/static_dispatch.mu.html deleted file mode 100644 index 22097281..00000000 --- a/html/static_dispatch.mu.html +++ /dev/null @@ -1,55 +0,0 @@ - - - - -Mu - static_dispatch.mu - - - - - - - - - - -

-def test a:num -> b:num [
-  local-scope
-  load-ingredients
-  b <- add a, 1
-]
-
-def test a:num, b:num -> c:num [
-  local-scope
-  load-ingredients
-  c <- add a, b
-]
-
-def main [
-  local-scope
-  a:num <- test 3  # selects single-ingredient version
-  $print a, 10/newline
-  b:num <- test 3, 4  # selects double-ingredient version
-  $print b, 10/newline
-  c:num <- test 3, 4, 5  # prefers double- to single-ingredient version
-  $print c, 10/newline
-]
-

- - - diff --git a/index.html b/index.html index 38a7ca62..1cf62ef2 100644 --- a/index.html +++ b/index.html @@ -40,7 +40,7 @@ for testing.

filesystem.mu: example program showing file primitives that inject a 'filesystem' dependency which can be faked for testing. -

static_dispatch.mu: example +

static-dispatch.mu: example program showing mu's ability to define recipes with headers, and allow recipes with the same name but different headers to coexist.

chessboard.mu: a little program for -- cgit 1.4.1-2-gfad0