about summary refs log tree commit diff stats
path: root/README.org
blob: df63385f63e2245bf21f938a34512ab015b56394 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
#+title: Fornax
#+subtitle: Collection of tools to visualize Path Finding Algorithms
#+export_file_name: index
#+setupfile: ~/.emacs.d/org-templates/projects.org

| Website         | https://andinus.unfla.me/projects/fornax |
| Source          | https://git.unfla.me/fornax              |
| GitHub (mirror) | https://github.com/andinus/fornax        |

This collection includes:
- ~fornax~: Program that parses /Fornax Format/ and outputs video solution.
- Algorithms: Various algorithms solved in several programming
  languages.

* Demo

Solution for /DFS-33/, generated on /2021-11-03/ (click to play).

[[https://andinus.unfla.me/resources/projects/fornax/2021-11-03-DFS-33.mp4][https://andinus.unfla.me/resources/projects/fornax/2021-11-03-DFS-33.png]]

* Installation

~fornax~ is written in Raku, it can be installed with ~zef~. You can also
run it without ~zef~,  just run ~raku -Ilib bin/fornax~ from within the
source directory.

- *Note*: ~Cairo~ module & ~ffmpeg~ program is required.

** Release

1. Run ~zef install fornax~.

Fornax should be installed, try running ~fornax --version~ to confirm.

- Solving programs / solutions are not included in the distribution, get
  them from this repository.

** From Source

You can either download the release archive generated by cgit/GitHub or
clone the project if you have ~git~ installed.

*** Without ~git~

1. Download the release:
   - https://git.unfla.me/andinus/fornax
   - https://github.com/andinus/fornax/releases
2. Extract the file.
3. Run ~zef install .~ in source directory.

*** With ~git~

All commits by /Andinus/ will be signed by this [[https://andinus.nand.sh/static/D9AE4AEEE1F1B3598E81D9DFB67D55D482A799FD.asc][PGP Key]].

#+begin_src sh
# Clone the project.
git clone https://git.tilde.institute/andinus/fornax
cd fornax

# Install fornax.
zef install .
#+end_src

* Documentation

Fornax parses /Fornax format/, generates a ~PNG~ for each iteration which is
later converted to a slideshow with ~ffmpeg~.

- Solved paths are highlighted if the iteration is preceded by ~|~.
- Illegal paths are highlighted if the iteration is preceded by ~!~.

- *Note*: If the number of iterations are greater than an 8 digit number
  then the slideshow might be incorrect.

* Project Structure

- Algorithms are located in ~algorithms/~ directory, sub-directory needs
  to be created for programming languages which will hold the actual
  source.

- Sample solutions can be found in ~resources/solutions/~ directory.

  - *Note*: Some solutions might output illegal moves (like walking over
    blocked path), this error is only in visualization, the solution is
    correct.

    This has been fixed in commit
    ~8cef86f0eb8b46b0ed2d7c37fa216890300249f6~.

* Fornax Format

Fornax format is an intermediate output file generated after solving the
maze. Algorithms must output the solution in this format.

#+begin_src
rows:<number of rows> cols:<number of columns>

...iterations
#+end_src

~...iterations~ is to be replaced by the resulting grid in each iteration
that is to be included in the final video. Since the number of rows and
columns is known, the whole grid should be printed in a single line.

- Every iteration should be separated by a newline.

- If the iteration cells is not equal to ~rows * columns~ or ~(rows *
  columns) + 1~ then it may be ignored by the program that parses the
  file.

- Solved iteration can be preceded by ~|~ character.

- Iteration that tries to walk on a blocked path can be preceded by ~!~
  character.

- First iteration is assumed to be the maze.

** Grids

A grid is printed for every iteration. Grids are composed of cells.

| Cell             | Symbol |
|------------------+--------|
| Path             | ~.~      |
| Blocked          | ~#~      |
| Destination      | ~$~      |
|------------------+--------|
| Visited          | ~-~      |
| Current Position | ~@~      |

- /Current Position/ is prioritized over /Blocked/ & /Destination/ symbol if
  it makes sense.

* News

** v0.1.0 - 2021-11-03

+ Initial implementation. Includes DFS solver in Java, tool to visualize
  the solution.
erIndex) AddUser(nick string, url string) { rfc3339date, err := time.Now().MarshalText() if err != nil { log.Printf("Error formatting user add time as RFC3339: %v\n", err) } imutex.Lock() index[url] = &Data{nick: nick, date: time.Now(), apidate: rfc3339date} imutex.Unlock() } // DelUser removes a user from the index completely. func (index UserIndex) DelUser(url string) { imutex.Lock() delete(index, url) imutex.Unlock() } func (index UserIndex) QueryUser(name string) []string { var users []string var entry string for k, v := range index { if strings.Contains(v.nick, name) { entry = v.nick + "\t" + k + "\t" + string(v.apidate) users = append(users, entry) } } return users } // FindTag takes a user's tweets and looks for a given tag. // Returns the tweets with the tag as a []string. func (userdata *Data) FindTag(tag string) { //for _, e := range userdata.status { //parts := strings.Split(e, "\t") //} } 1' href='#n641'>641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Mu - lambda-to-mu.mu</title>
<meta name="Generator" content="Vim/8.0">
<meta name="plugin-version" content="vim7.4_v2">
<meta name="syntax" content="none">
<meta name="settings" content="number_lines,use_css,pre_wrap,no_foldcolumn,expand_tabs,line_ids,prevent_copy=">
<meta name="colorscheme" content="minimal-light">
<style type="text/css">
<!--
pre { white-space: pre-wrap; font-family: monospace; color: #000000; background-color: #c6c6c6; }
body { font-size:12pt; font-family: monospace; color: #000000; background-color: #c6c6c6; }
a { color:inherit; }
* { font-size:12pt; font-size: 1em; }
.CommentedCode { color: #8a8a8a; }
.muControl { color: #804000; }
.muRecipe { color: #ff8700; }
.muScenario { color: #00af00; }
.LineNr { }
.muData { color: #ffff00; }
.Delimiter { color: #c000c0; }
.Constant { color: #008787; }
.Special { color: #ff6060; }
.Comment { color: #005faf; }
.SalientComment { color: #0000af; }
-->
</style>

<script type='text/javascript'>
<!--

/* function to open any folds containing a jumped-to line before jumping to it */
function JumpToLine()
{
  var lineNum;
  lineNum = window.location.hash;
  lineNum = lineNum.substr(1); /* strip off '#' */

  if (lineNum.indexOf('L') == -1) {
    lineNum = 'L'+lineNum;
  }
  lineElem = document.getElementById(lineNum);
  /* Always jump to new location even if the line was hidden inside a fold, or
   * we corrected the raw number to a line ID.
   */
  if (lineElem) {
    lineElem.scrollIntoView(true);
  }
  return true;
}
if ('onhashchange' in window) {
  window.onhashchange = JumpToLine;
}

-->
</script>
</head>
<body onload='JumpToLine();'>
<a href='https://github.com/akkartik/mu/blob/master/lambda-to-mu.mu'>https://github.com/akkartik/mu/blob/master/lambda-to-mu.mu</a>
<pre id='vimCodeElement'>
<span id="L1" class="LineNr">  1 </span><span class="SalientComment">## experimental compiler to translate programs written in a generic</span>
<span id="L2" class="LineNr">  2 </span><span class="SalientComment">## expression-oriented language called 'lambda' into Mu</span>
<span id="L3" class="LineNr">  3 </span>
<span id="L4" class="LineNr">  4 </span><span class="Comment"># incomplete; code generator not done</span>
<span id="L5" class="LineNr">  5 </span><span class="Comment"># potential enhancements:</span>
<span id="L6" class="LineNr">  6 </span><span class="Comment">#   symbol table</span>
<span id="L7" class="LineNr">  7 </span><span class="Comment">#   poor man's macros</span>
<span id="L8" class="LineNr">  8 </span><span class="Comment">#     substitute one instruction with multiple, parameterized by inputs and products</span>
<span id="L9" class="LineNr">  9 </span>
<span id="L10" class="LineNr"> 10 </span><span class="muScenario">scenario</span> convert-lambda [
<span id="L11" class="LineNr"> 11 </span>  run [
<span id="L12" class="LineNr"> 12 </span>    <span class="Constant">local-scope</span>
<span id="L13" class="LineNr"> 13 </span>    1:text/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L22'>lambda-to-mu</a> <span class="Constant">[(add a (multiply b c))]</span>
<span id="L14" class="LineNr"> 14 </span>    2:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *1:text/<span class="Special">raw</span>
<span id="L15" class="LineNr"> 15 </span>  ]
<span id="L16" class="LineNr"> 16 </span>  memory-should-contain [
<span id="L17" class="LineNr"> 17 </span>    2:array:character <span class="Special">&lt;-</span> <span class="Constant">[t1 &lt;- multiply b c</span>
<span id="L18" class="LineNr"> 18 </span><span class="Constant">result &lt;- add a t1]</span>
<span id="L19" class="LineNr"> 19 </span>  ]
<span id="L20" class="LineNr"> 20 </span>]
<span id="L21" class="LineNr"> 21 </span>
<span id="L22" class="LineNr"> 22 </span><span class="muRecipe">def</span> <a href='lambda-to-mu.mu.html#L22'>lambda-to-mu</a> in:text<span class="muRecipe"> -&gt; </span>out:text [
<span id="L23" class="LineNr"> 23 </span>  <span class="Constant">local-scope</span>
<span id="L24" class="LineNr"> 24 </span>  <span class="Constant">load-inputs</span>
<span id="L25" class="LineNr"> 25 </span>  out <span class="Special">&lt;-</span> copy<span class="Constant"> null</span>
<span id="L26" class="LineNr"> 26 </span>  cells:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> parse in
<span id="L27" class="LineNr"> 27 </span>  out <span class="Special">&lt;-</span> to-mu cells
<span id="L28" class="LineNr"> 28 </span>]
<span id="L29" class="LineNr"> 29 </span>
<span id="L30" class="LineNr"> 30 </span><span class="Comment"># 'parse' will turn lambda expressions into trees made of cells</span>
<span id="L31" class="LineNr"> 31 </span><span class="muData">exclusive-container</span> <a href='lambda-to-mu.mu.html#L31'>cell</a> [
<span id="L32" class="LineNr"> 32 </span>  atom:text
<span id="L33" class="LineNr"> 33 </span>  <a href='lambda-to-mu.mu.html#L37'>pair</a>:<a href='lambda-to-mu.mu.html#L37'>pair</a>
<span id="L34" class="LineNr"> 34 </span>]
<span id="L35" class="LineNr"> 35 </span>
<span id="L36" class="LineNr"> 36 </span><span class="Comment"># printed below as &lt; first | rest &gt;</span>
<span id="L37" class="LineNr"> 37 </span><span class="muData">container</span> <a href='lambda-to-mu.mu.html#L37'>pair</a> [
<span id="L38" class="LineNr"> 38 </span>  first:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>
<span id="L39" class="LineNr"> 39 </span>  rest:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>
<span id="L40" class="LineNr"> 40 </span>]
<span id="L41" class="LineNr"> 41 </span>
<span id="L42" class="LineNr"> 42 </span><span class="muRecipe">def</span> <a href='lambda-to-mu.mu.html#L42'>new-atom</a> name:text<span class="muRecipe"> -&gt; </span>result:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> [
<span id="L43" class="LineNr"> 43 </span>  <span class="Constant">local-scope</span>
<span id="L44" class="LineNr"> 44 </span>  <span class="Constant">load-inputs</span>
<span id="L45" class="LineNr"> 45 </span>  result <span class="Special">&lt;-</span> new <span class="Constant"><a href='lambda-to-mu.mu.html#L31'>cell</a>:type</span>
<span id="L46" class="LineNr"> 46 </span>  *result <span class="Special">&lt;-</span> merge <span class="Constant">0/tag:atom</span>, name
<span id="L47" class="LineNr"> 47 </span>]
<span id="L48" class="LineNr"> 48 </span>
<span id="L49" class="LineNr"> 49 </span><span class="muRecipe">def</span> <a href='lambda-to-mu.mu.html#L49'>new-pair</a> a:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>, b:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a><span class="muRecipe"> -&gt; </span>result:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> [
<span id="L50" class="LineNr"> 50 </span>  <span class="Constant">local-scope</span>
<span id="L51" class="LineNr"> 51 </span>  <span class="Constant">load-inputs</span>
<span id="L52" class="LineNr"> 52 </span>  result <span class="Special">&lt;-</span> new <span class="Constant"><a href='lambda-to-mu.mu.html#L31'>cell</a>:type</span>
<span id="L53" class="LineNr"> 53 </span>  *result <span class="Special">&lt;-</span> merge <span class="Constant">1/tag:<a href='lambda-to-mu.mu.html#L37'>pair</a></span>, a/first, b/rest
<span id="L54" class="LineNr"> 54 </span>]
<span id="L55" class="LineNr"> 55 </span>
<span id="L56" class="LineNr"> 56 </span><span class="muRecipe">def</span> <a href='lambda-to-mu.mu.html#L56'>is-atom?</a> x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a><span class="muRecipe"> -&gt; </span>result:bool [
<span id="L57" class="LineNr"> 57 </span>  <span class="Constant">local-scope</span>
<span id="L58" class="LineNr"> 58 </span>  <span class="Constant">load-inputs</span>
<span id="L59" class="LineNr"> 59 </span>  <span class="muControl">return-unless</span> x,<span class="Constant"> false</span>
<span id="L60" class="LineNr"> 60 </span>  _, result <span class="Special">&lt;-</span> maybe-convert *x, <span class="Constant">atom:variant</span>
<span id="L61" class="LineNr"> 61 </span>]
<span id="L62" class="LineNr"> 62 </span>
<span id="L63" class="LineNr"> 63 </span><span class="muRecipe">def</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a><span class="muRecipe"> -&gt; </span>result:bool [
<span id="L64" class="LineNr"> 64 </span>  <span class="Constant">local-scope</span>
<span id="L65" class="LineNr"> 65 </span>  <span class="Constant">load-inputs</span>
<span id="L66" class="LineNr"> 66 </span>  <span class="muControl">return-unless</span> x,<span class="Constant"> false</span>
<span id="L67" class="LineNr"> 67 </span>  _, result <span class="Special">&lt;-</span> maybe-convert *x, <span class="Constant"><a href='lambda-to-mu.mu.html#L37'>pair</a>:variant</span>
<span id="L68" class="LineNr"> 68 </span>]
<span id="L69" class="LineNr"> 69 </span>
<span id="L70" class="LineNr"> 70 </span><span class="muScenario">scenario</span> atom-is-not-pair [
<span id="L71" class="LineNr"> 71 </span>  <span class="Constant">local-scope</span>
<span id="L72" class="LineNr"> 72 </span>  s:text <span class="Special">&lt;-</span> new <span class="Constant">[a]</span>
<span id="L73" class="LineNr"> 73 </span>  x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L42'>new-atom</a> s
<span id="L74" class="LineNr"> 74 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L56'>is-atom?</a> x
<span id="L75" class="LineNr"> 75 </span>  11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x
<span id="L76" class="LineNr"> 76 </span>  memory-should-contain [
<span id="L77" class="LineNr"> 77 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>
<span id="L78" class="LineNr"> 78 </span>   <span class="Constant"> 11</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>
<span id="L79" class="LineNr"> 79 </span>  ]
<span id="L80" class="LineNr"> 80 </span>]
<span id="L81" class="LineNr"> 81 </span>
<span id="L82" class="LineNr"> 82 </span><span class="muScenario">scenario</span> pair-is-not-atom [
<span id="L83" class="LineNr"> 83 </span>  <span class="Constant">local-scope</span>
<span id="L84" class="LineNr"> 84 </span>  <span class="Comment"># construct (a . nil)</span>
<span id="L85" class="LineNr"> 85 </span>  s:text <span class="Special">&lt;-</span> new <span class="Constant">[a]</span>
<span id="L86" class="LineNr"> 86 </span>  x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L42'>new-atom</a> s
<span id="L87" class="LineNr"> 87 </span>  y:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L49'>new-pair</a> x,<span class="Constant"> null</span>
<span id="L88" class="LineNr"> 88 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L56'>is-atom?</a> y
<span id="L89" class="LineNr"> 89 </span>  11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> y
<span id="L90" class="LineNr"> 90 </span>  memory-should-contain [
<span id="L91" class="LineNr"> 91 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>
<span id="L92" class="LineNr"> 92 </span>   <span class="Constant"> 11</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>
<span id="L93" class="LineNr"> 93 </span>  ]
<span id="L94" class="LineNr"> 94 </span>]
<span id="L95" class="LineNr"> 95 </span>
<span id="L96" class="LineNr"> 96 </span><span class="muRecipe">def</span> <a href='lambda-to-mu.mu.html#L96'>atom-match?</a> x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>, pat:text<span class="muRecipe"> -&gt; </span>result:bool [
<span id="L97" class="LineNr"> 97 </span>  <span class="Constant">local-scope</span>
<span id="L98" class="LineNr"> 98 </span>  <span class="Constant">load-inputs</span>
<span id="L99" class="LineNr"> 99 </span>  s:text, <a href='lambda-to-mu.mu.html#L56'>is-atom?</a>:bool <span class="Special">&lt;-</span> maybe-convert *x, <span class="Constant">atom:variant</span>
<span id="L100" class="LineNr">100 </span>  <span class="muControl">return-unless</span> <a href='lambda-to-mu.mu.html#L56'>is-atom?</a>,<span class="Constant"> false</span>
<span id="L101" class="LineNr">101 </span>  result <span class="Special">&lt;-</span> equal pat, s
<span id="L102" class="LineNr">102 </span>]
<span id="L103" class="LineNr">103 </span>
<span id="L104" class="LineNr">104 </span><span class="muScenario">scenario</span> atom-match [
<span id="L105" class="LineNr">105 </span>  <span class="Constant">local-scope</span>
<span id="L106" class="LineNr">106 </span>  x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L42'>new-atom</a> <span class="Constant">[abc]</span>
<span id="L107" class="LineNr">107 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L96'>atom-match?</a> x, <span class="Constant">[abc]</span>
<span id="L108" class="LineNr">108 </span>  memory-should-contain [
<span id="L109" class="LineNr">109 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>
<span id="L110" class="LineNr">110 </span>  ]
<span id="L111" class="LineNr">111 </span>]
<span id="L112" class="LineNr">112 </span>
<span id="L113" class="LineNr">113 </span><span class="muRecipe">def</span> first x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a><span class="muRecipe"> -&gt; </span>result:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> [
<span id="L114" class="LineNr">114 </span>  <span class="Constant">local-scope</span>
<span id="L115" class="LineNr">115 </span>  <span class="Constant">load-inputs</span>
<span id="L116" class="LineNr">116 </span>  <a href='lambda-to-mu.mu.html#L37'>pair</a>:<a href='lambda-to-mu.mu.html#L37'>pair</a>, pair?:bool <span class="Special">&lt;-</span> maybe-convert *x, <span class="Constant"><a href='lambda-to-mu.mu.html#L37'>pair</a>:variant</span>
<span id="L117" class="LineNr">117 </span>  <span class="muControl">return-unless</span> pair?,<span class="Constant"> null</span>
<span id="L118" class="LineNr">118 </span>  result <span class="Special">&lt;-</span> get <a href='lambda-to-mu.mu.html#L37'>pair</a>, <span class="Constant">first:offset</span>
<span id="L119" class="LineNr">119 </span>]
<span id="L120" class="LineNr">120 </span>
<span id="L121" class="LineNr">121 </span><span class="muRecipe">def</span> rest x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a><span class="muRecipe"> -&gt; </span>result:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> [
<span id="L122" class="LineNr">122 </span>  <span class="Constant">local-scope</span>
<span id="L123" class="LineNr">123 </span>  <span class="Constant">load-inputs</span>
<span id="L124" class="LineNr">124 </span>  <a href='lambda-to-mu.mu.html#L37'>pair</a>:<a href='lambda-to-mu.mu.html#L37'>pair</a>, pair?:bool <span class="Special">&lt;-</span> maybe-convert *x, <span class="Constant"><a href='lambda-to-mu.mu.html#L37'>pair</a>:variant</span>
<span id="L125" class="LineNr">125 </span>  <span class="muControl">return-unless</span> pair?,<span class="Constant"> null</span>
<span id="L126" class="LineNr">126 </span>  result <span class="Special">&lt;-</span> get <a href='lambda-to-mu.mu.html#L37'>pair</a>, <span class="Constant">rest:offset</span>
<span id="L127" class="LineNr">127 </span>]
<span id="L128" class="LineNr">128 </span>
<span id="L129" class="LineNr">129 </span><span class="muRecipe">def</span> <a href='lambda-to-mu.mu.html#L129'>set-first</a> base:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>, new-first:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a><span class="muRecipe"> -&gt; </span>base:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> [
<span id="L130" class="LineNr">130 </span>  <span class="Constant">local-scope</span>
<span id="L131" class="LineNr">131 </span>  <span class="Constant">load-inputs</span>
<span id="L132" class="LineNr">132 </span>  <a href='lambda-to-mu.mu.html#L37'>pair</a>:<a href='lambda-to-mu.mu.html#L37'>pair</a>, <a href='lambda-to-mu.mu.html#L63'>is-pair?</a>:bool <span class="Special">&lt;-</span> maybe-convert *base, <span class="Constant"><a href='lambda-to-mu.mu.html#L37'>pair</a>:variant</span>
<span id="L133" class="LineNr">133 </span>  <span class="muControl">return-unless</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a>
<span id="L134" class="LineNr">134 </span>  <a href='lambda-to-mu.mu.html#L37'>pair</a> <span class="Special">&lt;-</span> put <a href='lambda-to-mu.mu.html#L37'>pair</a>, <span class="Constant">first:offset</span>, new-first
<span id="L135" class="LineNr">135 </span>  *base <span class="Special">&lt;-</span> merge <span class="Constant">1/pair</span>, <a href='lambda-to-mu.mu.html#L37'>pair</a>
<span id="L136" class="LineNr">136 </span>]
<span id="L137" class="LineNr">137 </span>
<span id="L138" class="LineNr">138 </span><span class="muRecipe">def</span> <a href='lambda-to-mu.mu.html#L138'>set-rest</a> base:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>, new-rest:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a><span class="muRecipe"> -&gt; </span>base:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> [
<span id="L139" class="LineNr">139 </span>  <span class="Constant">local-scope</span>
<span id="L140" class="LineNr">140 </span>  <span class="Constant">load-inputs</span>
<span id="L141" class="LineNr">141 </span>  <a href='lambda-to-mu.mu.html#L37'>pair</a>:<a href='lambda-to-mu.mu.html#L37'>pair</a>, <a href='lambda-to-mu.mu.html#L63'>is-pair?</a>:bool <span class="Special">&lt;-</span> maybe-convert *base, <span class="Constant"><a href='lambda-to-mu.mu.html#L37'>pair</a>:variant</span>
<span id="L142" class="LineNr">142 </span>  <span class="muControl">return-unless</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a>
<span id="L143" class="LineNr">143 </span>  <a href='lambda-to-mu.mu.html#L37'>pair</a> <span class="Special">&lt;-</span> put <a href='lambda-to-mu.mu.html#L37'>pair</a>, <span class="Constant">rest:offset</span>, new-rest
<span id="L144" class="LineNr">144 </span>  *base <span class="Special">&lt;-</span> merge <span class="Constant">1/pair</span>, <a href='lambda-to-mu.mu.html#L37'>pair</a>
<span id="L145" class="LineNr">145 </span>]
<span id="L146" class="LineNr">146 </span>
<span id="L147" class="LineNr">147 </span><span class="muScenario">scenario</span> cell-operations-on-atom [
<span id="L148" class="LineNr">148 </span>  <span class="Constant">local-scope</span>
<span id="L149" class="LineNr">149 </span>  s:text <span class="Special">&lt;-</span> new <span class="Constant">[a]</span>
<span id="L150" class="LineNr">150 </span>  x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L42'>new-atom</a> s
<span id="L151" class="LineNr">151 </span>  10:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>/<span class="Special">raw</span> <span class="Special">&lt;-</span> first x
<span id="L152" class="LineNr">152 </span>  11:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x
<span id="L153" class="LineNr">153 </span>  memory-should-contain [
<span id="L154" class="LineNr">154 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>  <span class="Comment"># first is nil</span>
<span id="L155" class="LineNr">155 </span>   <span class="Constant"> 11</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>  <span class="Comment"># rest is nil</span>
<span id="L156" class="LineNr">156 </span>  ]
<span id="L157" class="LineNr">157 </span>]
<span id="L158" class="LineNr">158 </span>
<span id="L159" class="LineNr">159 </span><span class="muScenario">scenario</span> cell-operations-on-pair [
<span id="L160" class="LineNr">160 </span>  <span class="Constant">local-scope</span>
<span id="L161" class="LineNr">161 </span>  <span class="Comment"># construct (a . nil)</span>
<span id="L162" class="LineNr">162 </span>  s:text <span class="Special">&lt;-</span> new <span class="Constant">[a]</span>
<span id="L163" class="LineNr">163 </span>  x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L42'>new-atom</a> s
<span id="L164" class="LineNr">164 </span>  y:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L49'>new-pair</a> x,<span class="Constant"> null</span>
<span id="L165" class="LineNr">165 </span>  x2:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first y
<span id="L166" class="LineNr">166 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> equal x, x2
<span id="L167" class="LineNr">167 </span>  11:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest y
<span id="L168" class="LineNr">168 </span>  memory-should-contain [
<span id="L169" class="LineNr">169 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># first is correct</span>
<span id="L170" class="LineNr">170 </span>   <span class="Constant"> 11</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>  <span class="Comment"># rest is nil</span>
<span id="L171" class="LineNr">171 </span>  ]
<span id="L172" class="LineNr">172 </span>]
<span id="L173" class="LineNr">173 </span>
<span id="L174" class="LineNr">174 </span><span class="SalientComment">## convert lambda text to a tree of cells</span>
<span id="L175" class="LineNr">175 </span>
<span id="L176" class="LineNr">176 </span><span class="muRecipe">def</span> parse in:text<span class="muRecipe"> -&gt; </span>out:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> [
<span id="L177" class="LineNr">177 </span>  <span class="Constant">local-scope</span>
<span id="L178" class="LineNr">178 </span>  <span class="Constant">load-inputs</span>
<span id="L179" class="LineNr">179 </span>  s:&amp;:<a href='066stream.mu.html#L2'>stream</a>:char <span class="Special">&lt;-</span> <a href='066stream.mu.html#L7'>new-stream</a> in
<span id="L180" class="LineNr">180 </span>  out, s <span class="Special">&lt;-</span> parse s
<span id="L181" class="LineNr">181 </span>  trace<span class="Constant"> 2</span>, <span class="Constant">[app/parse]</span>, out
<span id="L182" class="LineNr">182 </span>]
<span id="L183" class="LineNr">183 </span>
<span id="L184" class="LineNr">184 </span><span class="muRecipe">def</span> parse in:&amp;:<a href='066stream.mu.html#L2'>stream</a>:char<span class="muRecipe"> -&gt; </span>out:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>, in:&amp;:<a href='066stream.mu.html#L2'>stream</a>:char [
<span id="L185" class="LineNr">185 </span>  <span class="Constant">local-scope</span>
<span id="L186" class="LineNr">186 </span>  <span class="Constant">load-inputs</span>
<span id="L187" class="LineNr">187 </span>  <span class="Comment"># skip whitespace</span>
<span id="L188" class="LineNr">188 </span>  in <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L274'>skip-whitespace</a> in
<span id="L189" class="LineNr">189 </span>  c:char, eof?:bool <span class="Special">&lt;-</span> <a href='066stream.mu.html#L42'>peek</a> in
<span id="L190" class="LineNr">190 </span>  <span class="muControl">return-if</span> eof?,<span class="Constant"> null</span>
<span id="L191" class="LineNr">191 </span>  pair?:bool <span class="Special">&lt;-</span> equal c, <span class="Constant">40/open-paren</span>
<span id="L192" class="LineNr">192 </span>  <span class="Delimiter">{</span>
<span id="L193" class="LineNr">193 </span>    <span class="muControl">break-if</span> pair?
<span id="L194" class="LineNr">194 </span>    <span class="Comment"># atom</span>
<span id="L195" class="LineNr">195 </span>    buf:&amp;:<a href='061text.mu.html#L120'>buffer</a>:char <span class="Special">&lt;-</span> <a href='061text.mu.html#L125'>new-buffer</a><span class="Constant"> 30</span>
<span id="L196" class="LineNr">196 </span>    <span class="Delimiter">{</span>
<span id="L197" class="LineNr">197 </span>      done?:bool <span class="Special">&lt;-</span> <a href='066stream.mu.html#L72'>end-of-stream?</a> in
<span id="L198" class="LineNr">198 </span>      <span class="muControl">break-if</span> done?
<span id="L199" class="LineNr">199 </span>      <span class="Comment"># stop before close paren or space</span>
<span id="L200" class="LineNr">200 </span>      c:char <span class="Special">&lt;-</span> <a href='066stream.mu.html#L42'>peek</a> in
<span id="L201" class="LineNr">201 </span>      done? <span class="Special">&lt;-</span> equal c, <span class="Constant">41/close-paren</span>
<span id="L202" class="LineNr">202 </span>      <span class="muControl">break-if</span> done?
<span id="L203" class="LineNr">203 </span>      done? <span class="Special">&lt;-</span> <a href='061text.mu.html#L634'>space?</a> c
<span id="L204" class="LineNr">204 </span>      <span class="muControl">break-if</span> done?
<span id="L205" class="LineNr">205 </span>      c <span class="Special">&lt;-</span> read in
<span id="L206" class="LineNr">206 </span>      buf <span class="Special">&lt;-</span> append buf, c
<span id="L207" class="LineNr">207 </span>     <span class="muControl"> loop</span>
<span id="L208" class="LineNr">208 </span>    <span class="Delimiter">}</span>
<span id="L209" class="LineNr">209 </span>    s:text <span class="Special">&lt;-</span> <a href='061text.mu.html#L338'>buffer-to-array</a> buf
<span id="L210" class="LineNr">210 </span>    out <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L42'>new-atom</a> s
<span id="L211" class="LineNr">211 </span>  <span class="Delimiter">}</span>
<span id="L212" class="LineNr">212 </span>  <span class="Delimiter">{</span>
<span id="L213" class="LineNr">213 </span>    <span class="muControl">break-unless</span> pair?
<span id="L214" class="LineNr">214 </span>    <span class="Comment"># pair</span>
<span id="L215" class="LineNr">215 </span>    read in  <span class="Comment"># skip the open-paren</span>
<span id="L216" class="LineNr">216 </span>    out <span class="Special">&lt;-</span> new <span class="Constant"><a href='lambda-to-mu.mu.html#L31'>cell</a>:type</span>  <span class="Comment"># start out with nil</span>
<span id="L217" class="LineNr">217 </span>    <span class="Comment"># read in first element of pair</span>
<span id="L218" class="LineNr">218 </span>    <span class="Delimiter">{</span>
<span id="L219" class="LineNr">219 </span>      end?:bool <span class="Special">&lt;-</span> <a href='066stream.mu.html#L72'>end-of-stream?</a> in
<span id="L220" class="LineNr">220 </span>      not-end?:bool <span class="Special">&lt;-</span> not end?
<span id="L221" class="LineNr">221 </span>      assert not-end?, <span class="Constant">[unbalanced '(' in expression]</span>
<span id="L222" class="LineNr">222 </span>      c <span class="Special">&lt;-</span> <a href='066stream.mu.html#L42'>peek</a> in
<span id="L223" class="LineNr">223 </span>      close-paren?:bool <span class="Special">&lt;-</span> equal c, <span class="Constant">41/close-paren</span>
<span id="L224" class="LineNr">224 </span>      <span class="muControl">break-if</span> close-paren?
<span id="L225" class="LineNr">225 </span>      first:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>, in <span class="Special">&lt;-</span> parse in
<span id="L226" class="LineNr">226 </span>      *out <span class="Special">&lt;-</span> merge <span class="Constant">1/pair</span>, first,<span class="Constant"> null</span>
<span id="L227" class="LineNr">227 </span>    <span class="Delimiter">}</span>
<span id="L228" class="LineNr">228 </span>    <span class="Comment"># read in any remaining elements</span>
<span id="L229" class="LineNr">229 </span>    curr:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> copy out
<span id="L230" class="LineNr">230 </span>    <span class="Delimiter">{</span>
<span id="L231" class="LineNr">231 </span>      in <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L274'>skip-whitespace</a> in
<span id="L232" class="LineNr">232 </span>      end?:bool <span class="Special">&lt;-</span> <a href='066stream.mu.html#L72'>end-of-stream?</a> in
<span id="L233" class="LineNr">233 </span>      not-end?:bool <span class="Special">&lt;-</span> not end?
<span id="L234" class="LineNr">234 </span>      assert not-end?, <span class="Constant">[unbalanced '(' in expression]</span>
<span id="L235" class="LineNr">235 </span>      <span class="Comment"># termination check: ')'</span>
<span id="L236" class="LineNr">236 </span>      c <span class="Special">&lt;-</span> <a href='066stream.mu.html#L42'>peek</a> in
<span id="L237" class="LineNr">237 </span>      <span class="Delimiter">{</span>
<span id="L238" class="LineNr">238 </span>        close-paren?:bool <span class="Special">&lt;-</span> equal c, <span class="Constant">41/close-paren</span>
<span id="L239" class="LineNr">239 </span>        <span class="muControl">break-unless</span> close-paren?
<span id="L240" class="LineNr">240 </span>        read in  <span class="Comment"># skip ')'</span>
<span id="L241" class="LineNr">241 </span>       <span class="muControl"> break</span> <span class="Constant">+end-pair</span>
<span id="L242" class="LineNr">242 </span>      <span class="Delimiter">}</span>
<span id="L243" class="LineNr">243 </span>      <span class="Comment"># still here? read next element of pair</span>
<span id="L244" class="LineNr">244 </span>      <a href='065duplex_list.mu.html#L31'>next</a>:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>, in <span class="Special">&lt;-</span> parse in
<span id="L245" class="LineNr">245 </span>      is-dot?:bool <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L96'>atom-match?</a> <a href='065duplex_list.mu.html#L31'>next</a>, <span class="Constant">[.]</span>
<span id="L246" class="LineNr">246 </span>      <span class="Delimiter">{</span>
<span id="L247" class="LineNr">247 </span>        <span class="muControl">break-if</span> is-dot?
<span id="L248" class="LineNr">248 </span>        next-curr:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L49'>new-pair</a> <a href='065duplex_list.mu.html#L31'>next</a>,<span class="Constant"> null</span>
<span id="L249" class="LineNr">249 </span>        curr <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L138'>set-rest</a> curr, next-curr
<span id="L250" class="LineNr">250 </span>        curr <span class="Special">&lt;-</span> rest curr
<span id="L251" class="LineNr">251 </span>      <span class="Delimiter">}</span>
<span id="L252" class="LineNr">252 </span>      <span class="Delimiter">{</span>
<span id="L253" class="LineNr">253 </span>        <span class="muControl">break-unless</span> is-dot?
<span id="L254" class="LineNr">254 </span>        <span class="Comment"># deal with dotted pair</span>
<span id="L255" class="LineNr">255 </span>        in <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L274'>skip-whitespace</a> in
<span id="L256" class="LineNr">256 </span>        c <span class="Special">&lt;-</span> <a href='066stream.mu.html#L42'>peek</a> in
<span id="L257" class="LineNr">257 </span>        not-close-paren?:bool <span class="Special">&lt;-</span> not-equal c, <span class="Constant">41/close-paren</span>
<span id="L258" class="LineNr">258 </span>        assert not-close-paren?, <span class="Constant">[')' cannot immediately follow '.']</span>
<span id="L259" class="LineNr">259 </span>        final:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> parse in
<span id="L260" class="LineNr">260 </span>        curr <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L138'>set-rest</a> curr, final
<span id="L261" class="LineNr">261 </span>        <span class="Comment"># we're not gonna update curr, so better make sure the next iteration</span>
<span id="L262" class="LineNr">262 </span>        <span class="Comment"># is going to end the pair</span>
<span id="L263" class="LineNr">263 </span>        in <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L274'>skip-whitespace</a> in
<span id="L264" class="LineNr">264 </span>        c <span class="Special">&lt;-</span> <a href='066stream.mu.html#L42'>peek</a> in
<span id="L265" class="LineNr">265 </span>        close-paren?:bool <span class="Special">&lt;-</span> equal c, <span class="Constant">41/close-paren</span>
<span id="L266" class="LineNr">266 </span>        assert close-paren?, <span class="Constant">['.' must be followed by exactly one expression before ')']</span>
<span id="L267" class="LineNr">267 </span>      <span class="Delimiter">}</span>
<span id="L268" class="LineNr">268 </span>     <span class="muControl"> loop</span>
<span id="L269" class="LineNr">269 </span>    <span class="Delimiter">}</span>
<span id="L270" class="LineNr">270 </span><span class="Constant">    +end-pair</span>
<span id="L271" class="LineNr">271 </span>  <span class="Delimiter">}</span>
<span id="L272" class="LineNr">272 </span>]
<span id="L273" class="LineNr">273 </span>
<span id="L274" class="LineNr">274 </span><span class="muRecipe">def</span> <a href='lambda-to-mu.mu.html#L274'>skip-whitespace</a> in:&amp;:<a href='066stream.mu.html#L2'>stream</a>:char<span class="muRecipe"> -&gt; </span>in:&amp;:<a href='066stream.mu.html#L2'>stream</a>:char [
<span id="L275" class="LineNr">275 </span>  <span class="Constant">local-scope</span>
<span id="L276" class="LineNr">276 </span>  <span class="Constant">load-inputs</span>
<span id="L277" class="LineNr">277 </span>  <span class="Delimiter">{</span>
<span id="L278" class="LineNr">278 </span>    done?:bool <span class="Special">&lt;-</span> <a href='066stream.mu.html#L72'>end-of-stream?</a> in
<span id="L279" class="LineNr">279 </span>    <span class="muControl">return-if</span> done?,<span class="Constant"> null</span>
<span id="L280" class="LineNr">280 </span>    c:char <span class="Special">&lt;-</span> <a href='066stream.mu.html#L42'>peek</a> in
<span id="L281" class="LineNr">281 </span>    <a href='061text.mu.html#L634'>space?</a>:bool <span class="Special">&lt;-</span> <a href='061text.mu.html#L634'>space?</a> c
<span id="L282" class="LineNr">282 </span>    <span class="muControl">break-unless</span> <a href='061text.mu.html#L634'>space?</a>
<span id="L283" class="LineNr">283 </span>    read in  <span class="Comment"># skip</span>
<span id="L284" class="LineNr">284 </span>   <span class="muControl"> loop</span>
<span id="L285" class="LineNr">285 </span>  <span class="Delimiter">}</span>
<span id="L286" class="LineNr">286 </span>]
<span id="L287" class="LineNr">287 </span>
<span id="L288" class="LineNr">288 </span><span class="muRecipe">def</span> to-text x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a><span class="muRecipe"> -&gt; </span>out:text [
<span id="L289" class="LineNr">289 </span>  <span class="Constant">local-scope</span>
<span id="L290" class="LineNr">290 </span>  <span class="Constant">load-inputs</span>
<span id="L291" class="LineNr">291 </span>  buf:&amp;:<a href='061text.mu.html#L120'>buffer</a>:char <span class="Special">&lt;-</span> <a href='061text.mu.html#L125'>new-buffer</a><span class="Constant"> 30</span>
<span id="L292" class="LineNr">292 </span>  buf <span class="Special">&lt;-</span> to-buffer x, buf
<span id="L293" class="LineNr">293 </span>  out <span class="Special">&lt;-</span> <a href='061text.mu.html#L338'>buffer-to-array</a> buf
<span id="L294" class="LineNr">294 </span>]
<span id="L295" class="LineNr">295 </span>
<span id="L296" class="LineNr">296 </span><span class="muRecipe">def</span> to-buffer x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>, buf:&amp;:<a href='061text.mu.html#L120'>buffer</a>:char<span class="muRecipe"> -&gt; </span>buf:&amp;:<a href='061text.mu.html#L120'>buffer</a>:char [
<span id="L297" class="LineNr">297 </span>  <span class="Constant">local-scope</span>
<span id="L298" class="LineNr">298 </span>  <span class="Constant">load-inputs</span>
<span id="L299" class="LineNr">299 </span>  <span class="Comment"># base case: empty cell</span>
<span id="L300" class="LineNr">300 </span>  <span class="Delimiter">{</span>
<span id="L301" class="LineNr">301 </span>    <span class="muControl">break-if</span> x
<span id="L302" class="LineNr">302 </span>    buf <span class="Special">&lt;-</span> append buf, <span class="Constant">[&lt;&gt;]</span>
<span id="L303" class="LineNr">303 </span>   <span class="muControl"> return</span>
<span id="L304" class="LineNr">304 </span>  <span class="Delimiter">}</span>
<span id="L305" class="LineNr">305 </span>  <span class="Comment"># base case: atom</span>
<span id="L306" class="LineNr">306 </span>  <span class="Delimiter">{</span>
<span id="L307" class="LineNr">307 </span>    s:text, atom?:bool <span class="Special">&lt;-</span> maybe-convert *x, <span class="Constant">atom:variant</span>
<span id="L308" class="LineNr">308 </span>    <span class="muControl">break-unless</span> atom?
<span id="L309" class="LineNr">309 </span>    buf <span class="Special">&lt;-</span> append buf, s
<span id="L310" class="LineNr">310 </span>   <span class="muControl"> return</span>
<span id="L311" class="LineNr">311 </span>  <span class="Delimiter">}</span>
<span id="L312" class="LineNr">312 </span>  <span class="Comment"># recursive case: pair</span>
<span id="L313" class="LineNr">313 </span>  buf <span class="Special">&lt;-</span> append buf, <span class="Constant">[&lt; ]</span>
<span id="L314" class="LineNr">314 </span>  first:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x
<span id="L315" class="LineNr">315 </span>  buf <span class="Special">&lt;-</span> to-buffer first, buf
<span id="L316" class="LineNr">316 </span>  buf <span class="Special">&lt;-</span> append buf, <span class="Constant">[ | ]</span>
<span id="L317" class="LineNr">317 </span>  rest:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> rest x
<span id="L318" class="LineNr">318 </span>  buf <span class="Special">&lt;-</span> to-buffer rest, buf
<span id="L319" class="LineNr">319 </span>  buf <span class="Special">&lt;-</span> append buf, <span class="Constant">[ &gt;]</span>
<span id="L320" class="LineNr">320 </span>]
<span id="L321" class="LineNr">321 </span>
<span id="L322" class="LineNr">322 </span><span class="muScenario">scenario</span> parse-single-letter-atom [
<span id="L323" class="LineNr">323 </span>  <span class="Constant">local-scope</span>
<span id="L324" class="LineNr">324 </span>  s:text <span class="Special">&lt;-</span> new <span class="Constant">[a]</span>
<span id="L325" class="LineNr">325 </span>  x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> parse s
<span id="L326" class="LineNr">326 </span>  s2:text, 10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x, <span class="Constant">atom:variant</span>
<span id="L327" class="LineNr">327 </span>  11:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s2
<span id="L328" class="LineNr">328 </span>  memory-should-contain [
<span id="L329" class="LineNr">329 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># parse result is an atom</span>
<span id="L330" class="LineNr">330 </span>    11:array:character <span class="Special">&lt;-</span> <span class="Constant">[a]</span>
<span id="L331" class="LineNr">331 </span>  ]
<span id="L332" class="LineNr">332 </span>]
<span id="L333" class="LineNr">333 </span>
<span id="L334" class="LineNr">334 </span><span class="muScenario">scenario</span> parse-atom [
<span id="L335" class="LineNr">335 </span>  <span class="Constant">local-scope</span>
<span id="L336" class="LineNr">336 </span>  s:text <span class="Special">&lt;-</span> new <span class="Constant">[abc]</span>
<span id="L337" class="LineNr">337 </span>  x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> parse s
<span id="L338" class="LineNr">338 </span>  s2:text, 10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x, <span class="Constant">atom:variant</span>
<span id="L339" class="LineNr">339 </span>  11:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s2
<span id="L340" class="LineNr">340 </span>  memory-should-contain [
<span id="L341" class="LineNr">341 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># parse result is an atom</span>
<span id="L342" class="LineNr">342 </span>    11:array:character <span class="Special">&lt;-</span> <span class="Constant">[abc]</span>
<span id="L343" class="LineNr">343 </span>  ]
<span id="L344" class="LineNr">344 </span>]
<span id="L345" class="LineNr">345 </span>
<span id="L346" class="LineNr">346 </span><span class="muScenario">scenario</span> parse-list-of-two-atoms [
<span id="L347" class="LineNr">347 </span>  <span class="Constant">local-scope</span>
<span id="L348" class="LineNr">348 </span>  s:text <span class="Special">&lt;-</span> new <span class="Constant">[(abc def)]</span>
<span id="L349" class="LineNr">349 </span>  x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> parse s
<span id="L350" class="LineNr">350 </span>  trace-should-contain [
<span id="L351" class="LineNr">351 </span>    app/parse: <span class="Constant">&lt;</span> abc <span class="Constant">|</span> <span class="Constant">&lt;</span> def <span class="Constant">|</span> <span class="Constant">&lt;&gt;</span> <span class="Constant">&gt;</span> <span class="Constant">&gt;</span>
<span id="L352" class="LineNr">352 </span>  ]
<span id="L353" class="LineNr">353 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x
<span id="L354" class="LineNr">354 </span>  x1:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x
<span id="L355" class="LineNr">355 </span>  x2:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> rest x
<span id="L356" class="LineNr">356 </span>  s1:text, 11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x1, <span class="Constant">atom:variant</span>
<span id="L357" class="LineNr">357 </span>  12:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x2
<span id="L358" class="LineNr">358 </span>  x3:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x2
<span id="L359" class="LineNr">359 </span>  s2:text, 13:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x3, <span class="Constant">atom:variant</span>
<span id="L360" class="LineNr">360 </span>  14:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x2
<span id="L361" class="LineNr">361 </span>  20:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s1
<span id="L362" class="LineNr">362 </span>  30:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s2
<span id="L363" class="LineNr">363 </span>  memory-should-contain [
<span id="L364" class="LineNr">364 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># parse result is a pair</span>
<span id="L365" class="LineNr">365 </span>   <span class="Constant"> 11</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.first is an atom</span>
<span id="L366" class="LineNr">366 </span>   <span class="Constant"> 12</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.rest is a pair</span>
<span id="L367" class="LineNr">367 </span>   <span class="Constant"> 13</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.rest.first is an atom</span>
<span id="L368" class="LineNr">368 </span>   <span class="Constant"> 14</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>  <span class="Comment"># result.rest.rest is nil</span>
<span id="L369" class="LineNr">369 </span>    20:array:character <span class="Special">&lt;-</span> <span class="Constant">[abc]</span>  <span class="Comment"># result.first</span>
<span id="L370" class="LineNr">370 </span>    30:array:character <span class="Special">&lt;-</span> <span class="Constant">[def]</span>  <span class="Comment"># result.rest.first</span>
<span id="L371" class="LineNr">371 </span>  ]
<span id="L372" class="LineNr">372 </span>]
<span id="L373" class="LineNr">373 </span>
<span id="L374" class="LineNr">374 </span><span class="muScenario">scenario</span> parse-list-with-extra-spaces [
<span id="L375" class="LineNr">375 </span>  <span class="Constant">local-scope</span>
<span id="L376" class="LineNr">376 </span>  s:text <span class="Special">&lt;-</span> new <span class="Constant">[ ( abc  def ) ]</span>  <span class="Comment"># extra spaces</span>
<span id="L377" class="LineNr">377 </span>  x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> parse s
<span id="L378" class="LineNr">378 </span>  trace-should-contain [
<span id="L379" class="LineNr">379 </span>    app/parse: <span class="Constant">&lt;</span> abc <span class="Constant">|</span> <span class="Constant">&lt;</span> def <span class="Constant">|</span> <span class="Constant">&lt;&gt;</span> <span class="Constant">&gt;</span> <span class="Constant">&gt;</span>
<span id="L380" class="LineNr">380 </span>  ]
<span id="L381" class="LineNr">381 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x
<span id="L382" class="LineNr">382 </span>  x1:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x
<span id="L383" class="LineNr">383 </span>  x2:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> rest x
<span id="L384" class="LineNr">384 </span>  s1:text, 11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x1, <span class="Constant">atom:variant</span>
<span id="L385" class="LineNr">385 </span>  12:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x2
<span id="L386" class="LineNr">386 </span>  x3:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x2
<span id="L387" class="LineNr">387 </span>  s2:text, 13:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x3, <span class="Constant">atom:variant</span>
<span id="L388" class="LineNr">388 </span>  14:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x2
<span id="L389" class="LineNr">389 </span>  20:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s1
<span id="L390" class="LineNr">390 </span>  30:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s2
<span id="L391" class="LineNr">391 </span>  memory-should-contain [
<span id="L392" class="LineNr">392 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># parse result is a pair</span>
<span id="L393" class="LineNr">393 </span>   <span class="Constant"> 11</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.first is an atom</span>
<span id="L394" class="LineNr">394 </span>   <span class="Constant"> 12</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.rest is a pair</span>
<span id="L395" class="LineNr">395 </span>   <span class="Constant"> 13</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.rest.first is an atom</span>
<span id="L396" class="LineNr">396 </span>   <span class="Constant"> 14</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>  <span class="Comment"># result.rest.rest is nil</span>
<span id="L397" class="LineNr">397 </span>    20:array:character <span class="Special">&lt;-</span> <span class="Constant">[abc]</span>  <span class="Comment"># result.first</span>
<span id="L398" class="LineNr">398 </span>    30:array:character <span class="Special">&lt;-</span> <span class="Constant">[def]</span>  <span class="Comment"># result.rest.first</span>
<span id="L399" class="LineNr">399 </span>  ]
<span id="L400" class="LineNr">400 </span>]
<span id="L401" class="LineNr">401 </span>
<span id="L402" class="LineNr">402 </span><span class="muScenario">scenario</span> parse-list-of-more-than-two-atoms [
<span id="L403" class="LineNr">403 </span>  <span class="Constant">local-scope</span>
<span id="L404" class="LineNr">404 </span>  s:text <span class="Special">&lt;-</span> new <span class="Constant">[(abc def ghi)]</span>
<span id="L405" class="LineNr">405 </span>  x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> parse s
<span id="L406" class="LineNr">406 </span>  trace-should-contain [
<span id="L407" class="LineNr">407 </span>    app/parse: <span class="Constant">&lt;</span> abc <span class="Constant">|</span> <span class="Constant">&lt;</span> def <span class="Constant">|</span> <span class="Constant">&lt;</span> ghi <span class="Constant">|</span> <span class="Constant">&lt;&gt;</span> <span class="Constant">&gt;</span> <span class="Constant">&gt;</span> <span class="Constant">&gt;</span>
<span id="L408" class="LineNr">408 </span>  ]
<span id="L409" class="LineNr">409 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x
<span id="L410" class="LineNr">410 </span>  x1:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x
<span id="L411" class="LineNr">411 </span>  x2:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> rest x
<span id="L412" class="LineNr">412 </span>  s1:text, 11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x1, <span class="Constant">atom:variant</span>
<span id="L413" class="LineNr">413 </span>  12:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x2
<span id="L414" class="LineNr">414 </span>  x3:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x2
<span id="L415" class="LineNr">415 </span>  s2:text, 13:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x3, <span class="Constant">atom:variant</span>
<span id="L416" class="LineNr">416 </span>  x4:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> rest x2
<span id="L417" class="LineNr">417 </span>  14:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x4
<span id="L418" class="LineNr">418 </span>  x5:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x4
<span id="L419" class="LineNr">419 </span>  s3:text, 15:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x5, <span class="Constant">atom:variant</span>
<span id="L420" class="LineNr">420 </span>  16:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x4
<span id="L421" class="LineNr">421 </span>  20:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s1
<span id="L422" class="LineNr">422 </span>  30:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s2
<span id="L423" class="LineNr">423 </span>  40:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s3
<span id="L424" class="LineNr">424 </span>  memory-should-contain [
<span id="L425" class="LineNr">425 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># parse result is a pair</span>
<span id="L426" class="LineNr">426 </span>   <span class="Constant"> 11</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.first is an atom</span>
<span id="L427" class="LineNr">427 </span>   <span class="Constant"> 12</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.rest is a pair</span>
<span id="L428" class="LineNr">428 </span>   <span class="Constant"> 13</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.rest.first is an atom</span>
<span id="L429" class="LineNr">429 </span>   <span class="Constant"> 14</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.rest.rest is a pair</span>
<span id="L430" class="LineNr">430 </span>   <span class="Constant"> 15</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.rest.rest.first is an atom</span>
<span id="L431" class="LineNr">431 </span>   <span class="Constant"> 16</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>  <span class="Comment"># result.rest.rest.rest is nil</span>
<span id="L432" class="LineNr">432 </span>    20:array:character <span class="Special">&lt;-</span> <span class="Constant">[abc]</span>  <span class="Comment"># result.first</span>
<span id="L433" class="LineNr">433 </span>    30:array:character <span class="Special">&lt;-</span> <span class="Constant">[def]</span>  <span class="Comment"># result.rest.first</span>
<span id="L434" class="LineNr">434 </span>    40:array:character <span class="Special">&lt;-</span> <span class="Constant">[ghi]</span>  <span class="Comment"># result.rest.rest</span>
<span id="L435" class="LineNr">435 </span>  ]
<span id="L436" class="LineNr">436 </span>]
<span id="L437" class="LineNr">437 </span>
<span id="L438" class="LineNr">438 </span><span class="muScenario">scenario</span> parse-nested-list [
<span id="L439" class="LineNr">439 </span>  <span class="Constant">local-scope</span>
<span id="L440" class="LineNr">440 </span>  s:text <span class="Special">&lt;-</span> new <span class="Constant">[((abc))]</span>
<span id="L441" class="LineNr">441 </span>  x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> parse s
<span id="L442" class="LineNr">442 </span>  trace-should-contain [
<span id="L443" class="LineNr">443 </span>    app/parse: <span class="Constant">&lt;</span> <span class="Constant">&lt;</span> abc <span class="Constant">|</span> <span class="Constant">&lt;&gt;</span> <span class="Constant">&gt;</span> <span class="Constant">|</span> <span class="Constant">&lt;&gt;</span> <span class="Constant">&gt;</span>
<span id="L444" class="LineNr">444 </span>  ]
<span id="L445" class="LineNr">445 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x
<span id="L446" class="LineNr">446 </span>  x1:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x
<span id="L447" class="LineNr">447 </span>  11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x
<span id="L448" class="LineNr">448 </span>  x2:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x1
<span id="L449" class="LineNr">449 </span>  s1:text, 12:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x2, <span class="Constant">atom:variant</span>
<span id="L450" class="LineNr">450 </span>  13:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x1
<span id="L451" class="LineNr">451 </span>  14:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x
<span id="L452" class="LineNr">452 </span>  20:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s1
<span id="L453" class="LineNr">453 </span>  memory-should-contain [
<span id="L454" class="LineNr">454 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># parse result is a pair</span>
<span id="L455" class="LineNr">455 </span>   <span class="Constant"> 11</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.first is a pair</span>
<span id="L456" class="LineNr">456 </span>   <span class="Constant"> 12</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.first.first is an atom</span>
<span id="L457" class="LineNr">457 </span>   <span class="Constant"> 13</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>  <span class="Comment"># result.first.rest is nil</span>
<span id="L458" class="LineNr">458 </span>   <span class="Constant"> 14</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>  <span class="Comment"># result.rest is nil</span>
<span id="L459" class="LineNr">459 </span>    20:array:character <span class="Special">&lt;-</span> <span class="Constant">[abc]</span>  <span class="Comment"># result.first.first</span>
<span id="L460" class="LineNr">460 </span>  ]
<span id="L461" class="LineNr">461 </span>]
<span id="L462" class="LineNr">462 </span>
<span id="L463" class="LineNr">463 </span><span class="muScenario">scenario</span> parse-nested-list-2 [
<span id="L464" class="LineNr">464 </span>  <span class="Constant">local-scope</span>
<span id="L465" class="LineNr">465 </span>  s:text <span class="Special">&lt;-</span> new <span class="Constant">[((abc) def)]</span>
<span id="L466" class="LineNr">466 </span>  x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> parse s
<span id="L467" class="LineNr">467 </span>  trace-should-contain [
<span id="L468" class="LineNr">468 </span>    app/parse: <span class="Constant">&lt;</span> <span class="Constant">&lt;</span> abc <span class="Constant">|</span> <span class="Constant">&lt;&gt;</span> <span class="Constant">&gt;</span> <span class="Constant">|</span> <span class="Constant">&lt;</span> def <span class="Constant">|</span> <span class="Constant">&lt;&gt;</span> <span class="Constant">&gt;</span> <span class="Constant">&gt;</span>
<span id="L469" class="LineNr">469 </span>  ]
<span id="L470" class="LineNr">470 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x
<span id="L471" class="LineNr">471 </span>  x1:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x
<span id="L472" class="LineNr">472 </span>  11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x
<span id="L473" class="LineNr">473 </span>  x2:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x1
<span id="L474" class="LineNr">474 </span>  s1:text, 12:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x2, <span class="Constant">atom:variant</span>
<span id="L475" class="LineNr">475 </span>  13:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x1
<span id="L476" class="LineNr">476 </span>  x3:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> rest x
<span id="L477" class="LineNr">477 </span>  x4:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x3
<span id="L478" class="LineNr">478 </span>  s2:text, 14:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x4, <span class="Constant">atom:variant</span>
<span id="L479" class="LineNr">479 </span>  15:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>/<span class="Special">raw</span> <span class="Special">&lt;-</span> rest x3
<span id="L480" class="LineNr">480 </span>  20:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s1
<span id="L481" class="LineNr">481 </span>  30:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s2
<span id="L482" class="LineNr">482 </span>  memory-should-contain [
<span id="L483" class="LineNr">483 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># parse result is a pair</span>
<span id="L484" class="LineNr">484 </span>   <span class="Constant"> 11</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.first is a pair</span>
<span id="L485" class="LineNr">485 </span>   <span class="Constant"> 12</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.first.first is an atom</span>
<span id="L486" class="LineNr">486 </span>   <span class="Constant"> 13</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>  <span class="Comment"># result.first.rest is nil</span>
<span id="L487" class="LineNr">487 </span>   <span class="Constant"> 14</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.rest.first is an atom</span>
<span id="L488" class="LineNr">488 </span>   <span class="Constant"> 15</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>  <span class="Comment"># result.rest.rest is nil</span>
<span id="L489" class="LineNr">489 </span>    20:array:character <span class="Special">&lt;-</span> <span class="Constant">[abc]</span>  <span class="Comment"># result.first.first</span>
<span id="L490" class="LineNr">490 </span>    30:array:character <span class="Special">&lt;-</span> <span class="Constant">[def]</span>  <span class="Comment"># result.rest.first</span>
<span id="L491" class="LineNr">491 </span>  ]
<span id="L492" class="LineNr">492 </span>]
<span id="L493" class="LineNr">493 </span>
<span id="L494" class="LineNr">494 </span><span class="Comment"># todo: uncomment these tests after we figure out how to continue tests after</span>
<span id="L495" class="LineNr">495 </span><span class="Comment"># assertion failures</span>
<span id="L496" class="LineNr">496 </span><span class="CommentedCode">#? scenario parse-error [</span>
<span id="L497" class="LineNr">497 </span><span class="CommentedCode">#?   local-scope</span>
<span id="L498" class="LineNr">498 </span><span class="CommentedCode">#?   s:text &lt;- new [(]</span>
<span id="L499" class="LineNr">499 </span><span class="CommentedCode">#? #?   hide-errors</span>
<span id="L500" class="LineNr">500 </span><span class="CommentedCode">#?   x:&amp;:cell &lt;- parse s</span>
<span id="L501" class="LineNr">501 </span><span class="CommentedCode">#? #?   show-errors</span>
<span id="L502" class="LineNr">502 </span><span class="CommentedCode">#?   trace-should-contain [</span>
<span id="L503" class="LineNr">503 </span><span class="CommentedCode">#?     error: unbalanced '(' in expression</span>
<span id="L504" class="LineNr">504 </span><span class="CommentedCode">#?   ]</span>
<span id="L505" class="LineNr">505 </span><span class="CommentedCode">#? ]</span>
<span id="L506" class="LineNr">506 </span><span class="CommentedCode">#? </span>
<span id="L507" class="LineNr">507 </span><span class="CommentedCode">#? scenario parse-error-after-element [</span>
<span id="L508" class="LineNr">508 </span><span class="CommentedCode">#?   local-scope</span>
<span id="L509" class="LineNr">509 </span><span class="CommentedCode">#?   s:text &lt;- new [(abc]</span>
<span id="L510" class="LineNr">510 </span><span class="CommentedCode">#? #?   hide-errors</span>
<span id="L511" class="LineNr">511 </span><span class="CommentedCode">#?   x:&amp;:cell &lt;- parse s</span>
<span id="L512" class="LineNr">512 </span><span class="CommentedCode">#? #?   show-errors</span>
<span id="L513" class="LineNr">513 </span><span class="CommentedCode">#?   trace-should-contain [</span>
<span id="L514" class="LineNr">514 </span><span class="CommentedCode">#?     error: unbalanced '(' in expression</span>
<span id="L515" class="LineNr">515 </span><span class="CommentedCode">#?   ]</span>
<span id="L516" class="LineNr">516 </span><span class="CommentedCode">#? ]</span>
<span id="L517" class="LineNr">517 </span>
<span id="L518" class="LineNr">518 </span><span class="muScenario">scenario</span> parse-dotted-list-of-two-atoms [
<span id="L519" class="LineNr">519 </span>  <span class="Constant">local-scope</span>
<span id="L520" class="LineNr">520 </span>  s:text <span class="Special">&lt;-</span> new <span class="Constant">[(abc . def)]</span>
<span id="L521" class="LineNr">521 </span>  x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> parse s
<span id="L522" class="LineNr">522 </span>  trace-should-contain [
<span id="L523" class="LineNr">523 </span>    app/parse: <span class="Constant">&lt;</span> abc <span class="Constant">|</span> def <span class="Constant">&gt;</span>
<span id="L524" class="LineNr">524 </span>  ]
<span id="L525" class="LineNr">525 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x
<span id="L526" class="LineNr">526 </span>  x1:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x
<span id="L527" class="LineNr">527 </span>  x2:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> rest x
<span id="L528" class="LineNr">528 </span>  s1:text, 11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x1, <span class="Constant">atom:variant</span>
<span id="L529" class="LineNr">529 </span>  s2:text, 12:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x2, <span class="Constant">atom:variant</span>
<span id="L530" class="LineNr">530 </span>  20:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s1
<span id="L531" class="LineNr">531 </span>  30:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s2
<span id="L532" class="LineNr">532 </span>  memory-should-contain [
<span id="L533" class="LineNr">533 </span>    <span class="Comment"># parses to &lt; abc | def &gt;</span>
<span id="L534" class="LineNr">534 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># parse result is a pair</span>
<span id="L535" class="LineNr">535 </span>   <span class="Constant"> 11</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.first is an atom</span>
<span id="L536" class="LineNr">536 </span>   <span class="Constant"> 12</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.rest is an atom</span>
<span id="L537" class="LineNr">537 </span>    20:array:character <span class="Special">&lt;-</span> <span class="Constant">[abc]</span>  <span class="Comment"># result.first</span>
<span id="L538" class="LineNr">538 </span>    30:array:character <span class="Special">&lt;-</span> <span class="Constant">[def]</span>  <span class="Comment"># result.rest</span>
<span id="L539" class="LineNr">539 </span>  ]
<span id="L540" class="LineNr">540 </span>]
<span id="L541" class="LineNr">541 </span>
<span id="L542" class="LineNr">542 </span><span class="muScenario">scenario</span> parse-dotted-list-of-more-than-two-atoms [
<span id="L543" class="LineNr">543 </span>  <span class="Constant">local-scope</span>
<span id="L544" class="LineNr">544 </span>  s:text <span class="Special">&lt;-</span> new <span class="Constant">[(abc def . ghi)]</span>
<span id="L545" class="LineNr">545 </span>  x:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> parse s
<span id="L546" class="LineNr">546 </span>  trace-should-contain [
<span id="L547" class="LineNr">547 </span>    app/parse: <span class="Constant">&lt;</span> abc <span class="Constant">|</span> <span class="Constant">&lt;</span> def <span class="Constant">|</span> ghi <span class="Constant">&gt;</span> <span class="Constant">&gt;</span>
<span id="L548" class="LineNr">548 </span>  ]
<span id="L549" class="LineNr">549 </span>  10:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x
<span id="L550" class="LineNr">550 </span>  x1:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x
<span id="L551" class="LineNr">551 </span>  x2:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> rest x
<span id="L552" class="LineNr">552 </span>  s1:text, 11:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x1, <span class="Constant">atom:variant</span>
<span id="L553" class="LineNr">553 </span>  12:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> <a href='lambda-to-mu.mu.html#L63'>is-pair?</a> x2
<span id="L554" class="LineNr">554 </span>  x3:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> first x2
<span id="L555" class="LineNr">555 </span>  s2:text, 13:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x3, <span class="Constant">atom:variant</span>
<span id="L556" class="LineNr">556 </span>  x4:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a> <span class="Special">&lt;-</span> rest x2
<span id="L557" class="LineNr">557 </span>  s3:text, 14:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> maybe-convert *x4, <span class="Constant">atom:variant</span>
<span id="L558" class="LineNr">558 </span>  20:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s1
<span id="L559" class="LineNr">559 </span>  30:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s2
<span id="L560" class="LineNr">560 </span>  40:@:char/<span class="Special">raw</span> <span class="Special">&lt;-</span> copy *s3
<span id="L561" class="LineNr">561 </span>  memory-should-contain [
<span id="L562" class="LineNr">562 </span>   <span class="Constant"> 10</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># parse result is a pair</span>
<span id="L563" class="LineNr">563 </span>   <span class="Constant"> 11</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.first is an atom</span>
<span id="L564" class="LineNr">564 </span>   <span class="Constant"> 12</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.rest is a pair</span>
<span id="L565" class="LineNr">565 </span>   <span class="Constant"> 13</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.rest.first is an atom</span>
<span id="L566" class="LineNr">566 </span>   <span class="Constant"> 14</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># result.rest.rest is an atom</span>
<span id="L567" class="LineNr">567 </span>    20:array:character <span class="Special">&lt;-</span> <span class="Constant">[abc]</span>  <span class="Comment"># result.first</span>
<span id="L568" class="LineNr">568 </span>    30:array:character <span class="Special">&lt;-</span> <span class="Constant">[def]</span>  <span class="Comment"># result.rest.first</span>
<span id="L569" class="LineNr">569 </span>    40:array:character <span class="Special">&lt;-</span> <span class="Constant">[ghi]</span>  <span class="Comment"># result.rest.rest</span>
<span id="L570" class="LineNr">570 </span>  ]
<span id="L571" class="LineNr">571 </span>]
<span id="L572" class="LineNr">572 </span>
<span id="L573" class="LineNr">573 </span><span class="SalientComment">## convert tree of cells to Mu text</span>
<span id="L574" class="LineNr">574 </span>
<span id="L575" class="LineNr">575 </span><span class="muRecipe">def</span> to-mu in:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a><span class="muRecipe"> -&gt; </span>out:text [
<span id="L576" class="LineNr">576 </span>  <span class="Constant">local-scope</span>
<span id="L577" class="LineNr">577 </span>  <span class="Constant">load-inputs</span>
<span id="L578" class="LineNr">578 </span>  buf:&amp;:<a href='061text.mu.html#L120'>buffer</a>:char <span class="Special">&lt;-</span> <a href='061text.mu.html#L125'>new-buffer</a><span class="Constant"> 30</span>
<span id="L579" class="LineNr">579 </span>  buf <span class="Special">&lt;-</span> to-mu in, buf
<span id="L580" class="LineNr">580 </span>  out <span class="Special">&lt;-</span> <a href='061text.mu.html#L338'>buffer-to-array</a> buf
<span id="L581" class="LineNr">581 </span>]
<span id="L582" class="LineNr">582 </span>
<span id="L583" class="LineNr">583 </span><span class="muRecipe">def</span> to-mu in:&amp;:<a href='lambda-to-mu.mu.html#L31'>cell</a>, buf:&amp;:<a href='061text.mu.html#L120'>buffer</a>:char<span class="muRecipe"> -&gt; </span>buf:&amp;:<a href='061text.mu.html#L120'>buffer</a>:char, result-name:text [
<span id="L584" class="LineNr">584 </span>  <span class="Constant">local-scope</span>
<span id="L585" class="LineNr">585 </span>  <span class="Constant">load-inputs</span>
<span id="L586" class="LineNr">586 </span>  <span class="Comment"># null cell? no change.</span>
<span id="L587" class="LineNr">587 </span>  <span class="Comment"># pair with all atoms? gensym a new variable</span>
<span id="L588" class="LineNr">588 </span>  <span class="Comment"># pair containing other pairs? recurse</span>
<span id="L589" class="LineNr">589 </span>  result-name <span class="Special">&lt;-</span> copy<span class="Constant"> null</span>
<span id="L590" class="LineNr">590 </span>]
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->