File Annotation
Not logged in
423f308350 2010-11-07        kinaba: -----------------------------------------------------------------------------
423f308350 2010-11-07        kinaba:   Polemy 0.1.0
423f308350 2010-11-07        kinaba:                                                  by k.inaba (www.kmonos.net)
515502e8d1 2010-11-20        kinaba:                                                                Nov 20, 2010
423f308350 2010-11-07        kinaba: -----------------------------------------------------------------------------
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba: <<How to Build>>
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba:   - Install DMD
423f308350 2010-11-07        kinaba:       http://www.digitalmars.com/d/2.0/changelog.html
515502e8d1 2010-11-20        kinaba:     Version 2.050 is recommended. Older or newer version may not work.
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba:   - Build
423f308350 2010-11-07        kinaba:       (for Windows) Run build.bat
423f308350 2010-11-07        kinaba:       (for Unix) Run build.sh
423f308350 2010-11-07        kinaba:       or use your favorite build tools upon main.d and polemy/*.d.
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba:   Then you will get the executable "polemy" in the "bin" directory.
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba: <<License>>
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba:   d2stacktrace/*
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba:     is written by Benjamin Thaut and licensed under 2-clause BSD License.
423f308350 2010-11-07        kinaba:     See http://3d.benjamin-thaut.de/?p=15 for the detail.
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba:     (this package is used only for enabling stack-traces during printing exceptions;
c48ba67854 2010-11-08        kinaba:      it is not used for release builds.)
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba:   polemy/*
423f308350 2010-11-07        kinaba:   main.d
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba:     All the other parts are written by Kazuhiro Inaba and
423f308350 2010-11-07        kinaba:     licensed under NYSL 0.9982 ( http://www.kmonos.net/nysl/ ).
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba: 
423f308350 2010-11-07        kinaba: <<How to Use>>
423f308350 2010-11-07        kinaba: 
9eec42eba1 2010-11-09        kinaba:   > polemy
9eec42eba1 2010-11-09        kinaba:       starts REPL
9eec42eba1 2010-11-09        kinaba: 
9eec42eba1 2010-11-09        kinaba:   > polemy foo.pmy
9eec42eba1 2010-11-09        kinaba:       executes foo.pmy
9eec42eba1 2010-11-09        kinaba: 
515502e8d1 2010-11-20        kinaba:   > polemy -l foo.pmy
515502e8d1 2010-11-20        kinaba:       after executing foo.pmy, starts REPL
515502e8d1 2010-11-20        kinaba: 
3464a035ec 2010-11-20        kinaba:   > polemy -l foo.pmy -l bar.pmy buz.pmy
3464a035ec 2010-11-20        kinaba:       executes foo.pmy, bar.bmy, and then buz.pmy
3464a035ec 2010-11-20        kinaba: 
9eec42eba1 2010-11-09        kinaba: 
9eec42eba1 2010-11-09        kinaba: 
515502e8d1 2010-11-20        kinaba: <<Syntax>>
9eec42eba1 2010-11-09        kinaba: 
515502e8d1 2010-11-20        kinaba:  Comment is "# ... \n"
9eec42eba1 2010-11-09        kinaba: 
515502e8d1 2010-11-20        kinaba:  E ::=
515502e8d1 2010-11-20        kinaba:    // declaration
515502e8d1 2010-11-20        kinaba:      | ("var"|"let"|"def"|LAYER) ID "=" E (";"|"in") E
515502e8d1 2010-11-20        kinaba:      | ("var"|"let"|"def"|LAYER) ID "(" PARAMS ")" "{" E "}" (";"|"in") E
515502e8d1 2010-11-20        kinaba:      | ("var"|"let"|"def"|LAYER) ID "=" E
515502e8d1 2010-11-20        kinaba:      | ("var"|"let"|"def"|LAYER) ID "(" PARAMS ")" "{" E "}"
515502e8d1 2010-11-20        kinaba:    // literal
515502e8d1 2010-11-20        kinaba:      | INTEGER
515502e8d1 2010-11-20        kinaba: 	 | STRING
435fa085ec 2010-11-21        kinaba: 	 | "{" ENTRYS "}"                   // table
435fa085ec 2010-11-21        kinaba:      | "fun" "(" PARAMS ")" "{" E "}"   // anonymous function
515502e8d1 2010-11-20        kinaba:    // function call
515502e8d1 2010-11-20        kinaba:      | E "(" ARGS")"
515502e8d1 2010-11-20        kinaba: 	     where ARGS ::= E "," ... "," E
515502e8d1 2010-11-20        kinaba: 	         PARAMS ::= ID LAYER* "," ... "," ID LAYER*
515502e8d1 2010-11-20        kinaba: 			 ENTRYS ::= ID ":" E  "," ... "," ID ":" E
515502e8d1 2010-11-20        kinaba:                  ID ::= 'a-zA-Z0-9_...'+
515502e8d1 2010-11-20        kinaba:               LAYER ::= "@" ID
515502e8d1 2010-11-20        kinaba:    // operators
9eec42eba1 2010-11-09        kinaba:      | "(" E ")"
435fa085ec 2010-11-21        kinaba: 	 | E "." ID           // table field access
435fa085ec 2010-11-21        kinaba: 	 | E ".?" ID          // table field existence check
435fa085ec 2010-11-21        kinaba:      | E "{" ENTRYS "}"   // table extend (pure functionally)
9eec42eba1 2010-11-09        kinaba:      | E BINOP E
9eec42eba1 2010-11-09        kinaba:      | "if" "(" E ")" "{" E "}"
9eec42eba1 2010-11-09        kinaba:      | "if" "(" E ")" "{" E "}" "else "{" E "}"
515502e8d1 2010-11-20        kinaba:    // layered exec
515502e8d1 2010-11-20        kinaba:      | LAYER "(" E ")"
515502e8d1 2010-11-20        kinaba: 
515502e8d1 2010-11-20        kinaba: The following are actually rewritten to function calls:
515502e8d1 2010-11-20        kinaba: 
515502e8d1 2010-11-20        kinaba:   - if (E) then{E} else{E} ==> if( E, fun(){E}, fun(){E} )
515502e8d1 2010-11-20        kinaba:   - E BINOP E              ==> BINOP(E, E)
515502e8d1 2010-11-20        kinaba:   - E.ID                   ==> . (E, ID)
515502e8d1 2010-11-20        kinaba:   - E.?ID                  ==> .?(E, ID)
515502e8d1 2010-11-20        kinaba:   - {}                     ==> {}()
435fa085ec 2010-11-21        kinaba:   - { ENTRIES }            ==> {}{ ENTRIES }
435fa085ec 2010-11-21        kinaba:   - E {ID:E, ...}          ==> (.=(E, ID, E)) { ... }
515502e8d1 2010-11-20        kinaba: 
515502e8d1 2010-11-20        kinaba: Several styles of variable declaration can be used:
515502e8d1 2010-11-20        kinaba: 
515502e8d1 2010-11-20        kinaba:   - fun(x){ fun(y){x} }               # K-combinator
515502e8d1 2010-11-20        kinaba:   - fun(x){ let f = fun(y){x} in f }  # let-in style
515502e8d1 2010-11-20        kinaba:   - fun(x){ var f = fun(y){x}; f }    # var-;  style
515502e8d1 2010-11-20        kinaba:   - fun(x){ def f = fun(y){x} in f }  # you can use any combination of (let|var|def)-(;|in)
515502e8d1 2010-11-20        kinaba:   - fun(x){ def f(y){x} in f } # syntax sugar for function declaration
515502e8d1 2010-11-20        kinaba:   - fun(x){ let f(y){x}; f }   # this is also ok
515502e8d1 2010-11-20        kinaba:   - fun(x){ var f(y){x} }      # omitting (;|in) returns the last declared object directly
515502e8d1 2010-11-20        kinaba:   - fun(x,y){x} #< this is not equal to the above ones. functions are no curried.
515502e8d1 2010-11-20        kinaba: 
515502e8d1 2010-11-20        kinaba: NOTE: Theres no "let rec" syntax, but still recursive definition works
515502e8d1 2010-11-20        kinaba:     def f(x) { if(x==0){1}else{x*f(x-1)} } in f(10)  #=> 3628800
515502e8d1 2010-11-20        kinaba:   yet still the code below also works
515502e8d1 2010-11-20        kinaba:     def x=21 in def x=x+x in x  #=> 42.
515502e8d1 2010-11-20        kinaba:   The internal scoping mechanism is a little tricky (this is for coping with
515502e8d1 2010-11-20        kinaba:   the "layer" feature explained below), but I hope that it works as everyone
515502e8d1 2010-11-20        kinaba:   expects in most cases, as long as you don't use the same-name-variables heavily :).
515502e8d1 2010-11-20        kinaba: 
c1f2717799 2010-11-21        kinaba: (Experimental) pattern matching is also available. Here is an example.
c1f2717799 2010-11-21        kinaba: 
c1f2717799 2010-11-21        kinaba:   def adjSum(lst)
c1f2717799 2010-11-21        kinaba:   {
c1f2717799 2010-11-21        kinaba:     case( lst )
c1f2717799 2010-11-21        kinaba:       when( {car:x, cdr:{car: y, cdr:z}} ) { {car: x+y, cdr: adjSum(z)} }
c1f2717799 2010-11-21        kinaba:       when( {car:x, cdr:{}} ) { {car: x, cdr: {}} }
c1f2717799 2010-11-21        kinaba:       when( {} ) { {} }
c1f2717799 2010-11-21        kinaba:   };
c1f2717799 2010-11-21        kinaba: 
c1f2717799 2010-11-21        kinaba: It is expanded to a sequence of if-then-elses prefering the first-match.
c1f2717799 2010-11-21        kinaba: Note that {a: _} pattern matches all the tables that have the .a field.
c1f2717799 2010-11-21        kinaba: It also matches to {a: 123, b: 456} having extra .b field. So, changing the
c1f2717799 2010-11-21        kinaba: order of "when"s in the above code changes the behavior.
c1f2717799 2010-11-21        kinaba: 
c1f2717799 2010-11-21        kinaba: 
515502e8d1 2010-11-20        kinaba: 
515502e8d1 2010-11-20        kinaba: 
515502e8d1 2010-11-20        kinaba: <<Basic Features>>
515502e8d1 2010-11-20        kinaba: 
515502e8d1 2010-11-20        kinaba:   Polemy is an untyped functional programming language that has
515502e8d1 2010-11-20        kinaba:    - integers:   0, 123, 456666666666666666666666666666666666666789, ...
515502e8d1 2010-11-20        kinaba:    - strings:    "hello, world!\n", ...
515502e8d1 2010-11-20        kinaba:    - tables:     {car: 1, cdr: {car: 2, cdr: {}}}
515502e8d1 2010-11-20        kinaba:    - functions:  fun(x){x+1}
515502e8d1 2010-11-20        kinaba:   as primitive datatypes. Functions capture lexical closures.
515502e8d1 2010-11-20        kinaba:   It is almost 'pure' (except the primitve function "print" and some
515502e8d1 2010-11-20        kinaba:   trick inside scoping mechanisms).
515502e8d1 2010-11-20        kinaba: 
515502e8d1 2010-11-20        kinaba: 
435fa085ec 2010-11-21        kinaba: <<Layers :: Overview>>
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   Polemy's runtime environment has many "layer"s.
435fa085ec 2010-11-21        kinaba:   Usual execution run in the @value layer.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> 1 + 2
435fa085ec 2010-11-21        kinaba:     3
435fa085ec 2010-11-21        kinaba:     >> @value( 1 + 2 )
435fa085ec 2010-11-21        kinaba:     3
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   Here you can see that @LayerName( Expression ) executes the inner Expression in
435fa085ec 2010-11-21        kinaba:   the @LayerName layer. Other than @value, one other predefined layer exists: @macro.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> @macro( 1+2 )
435fa085ec 2010-11-21        kinaba:     {pos@value:{lineno@value:3, column@value:9, filename@value:<REPL>},
435fa085ec 2010-11-21        kinaba:       is@value:app,
c1f2717799 2010-11-21        kinaba:     args@value:{car@value:{pos@value:{lineno@value:3, column@value:9, filename@value:<REPL>},
435fa085ec 2010-11-21        kinaba:                             is@value:int,
435fa085ec 2010-11-21        kinaba:                           data@value:1},
435fa085ec 2010-11-21        kinaba:                 cdr@value:{
435fa085ec 2010-11-21        kinaba:                   car@value:{pos@value:{lineno@value:3, column@value:11, filename@value:<REPL>},
435fa085ec 2010-11-21        kinaba:                               is@value:int,
435fa085ec 2010-11-21        kinaba:                             data@value:2},
435fa085ec 2010-11-21        kinaba:                   cdr@value:{}}},
435fa085ec 2010-11-21        kinaba:      fun@value:{pos@value:{lineno@value:3, column@value:10, filename@value:<REPL>},
435fa085ec 2010-11-21        kinaba:                  is@value:var,
435fa085ec 2010-11-21        kinaba:                name@value:+}}
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   (Sorry, this pretty printing is not available on the actual interpreter...)
435fa085ec 2010-11-21        kinaba:   This evaluates the expression 1+2 in the @macro layer. In this layer, the meaning of
435fa085ec 2010-11-21        kinaba:   the program is its abstract syntax tree.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   You can interleave layers.
435fa085ec 2010-11-21        kinaba:   The root node of the abstract syntax tree is function "app"lication.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> @value(@macro( 1+2 ).is)
435fa085ec 2010-11-21        kinaba:     app
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: <<Layers :: Defining a new layer>>
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   To define a new layer, you should first tell how to "lift" existing values two the new layer.
435fa085ec 2010-11-21        kinaba:   Let us define the "@type" layer, where the meaning of programs is their static type.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> @@type = fun(x) {
435fa085ec 2010-11-21        kinaba:     >>   if( _isint(x) ) { "int" } else {
435fa085ec 2010-11-21        kinaba:     >>   if( _isfun(x) ) { x } else { "unknown" } }
435fa085ec 2010-11-21        kinaba:     >> }
435fa085ec 2010-11-21        kinaba:     (Note: polemy REPL may warn some exception here but please ignore)
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   For simplicity, I here deal only with integers.
435fa085ec 2010-11-21        kinaba:   _isint is a primitive function of Polemy that checks the dynamic type of a value.
435fa085ec 2010-11-21        kinaba:   For function, leaving it untouched works well for almost all layers.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> @type( 1 )
435fa085ec 2010-11-21        kinaba:     int
435fa085ec 2010-11-21        kinaba:     >> @type( 2 )
435fa085ec 2010-11-21        kinaba:     int
435fa085ec 2010-11-21        kinaba:     >> @type( "foo" )
435fa085ec 2010-11-21        kinaba:     unknown
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   Fine! Let's try to type 1+2.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> @type( 1 + 2 )
435fa085ec 2010-11-21        kinaba:     ...\value.d(119): [<REPL>:6:8] only @value layer can call native function
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   Note that the behavior of this program is
435fa085ec 2010-11-21        kinaba:     - run 1+2 in the @type layer
435fa085ec 2010-11-21        kinaba:   and NOT
435fa085ec 2010-11-21        kinaba:     - run 1+2 in @value and obtain 3 and run 3 in the @type.
435fa085ec 2010-11-21        kinaba:   The problem is, the variable "+" is defined only in the @value layer.
435fa085ec 2010-11-21        kinaba:   To carry out computation in the @type layer. We need to define it also
435fa085ec 2010-11-21        kinaba:   in the @type layer.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   To define some variable in a specific layer, use @LayerName in place of
435fa085ec 2010-11-21        kinaba:   (let|var|def)s.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> let x = 2
435fa085ec 2010-11-21        kinaba:     >> @value x = 2
435fa085ec 2010-11-21        kinaba:     >> @type x = "int"
435fa085ec 2010-11-21        kinaba:     >> @hoge x = "fuga"
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   For "+", do it like this.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> @type "+" = fun(x,y) {@value(
435fa085ec 2010-11-21        kinaba:     >>   if( @type(x)=="int" && @type(y)=="int" ) { "int" } else { "typeerror" }
435fa085ec 2010-11-21        kinaba:     >> )}
435fa085ec 2010-11-21        kinaba:     polemy.value.native!(IntValue,IntValue,IntValue).native.__anonclass24
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   It is just computing the return type from the input type.
435fa085ec 2010-11-21        kinaba:   Not here that the intended "meaning" of if-then-else is the runtime-branching,
435fa085ec 2010-11-21        kinaba:   and the meaning of "==" is the value-comparison. These are the @value layer
435fa085ec 2010-11-21        kinaba:   behavior. So we have defined the function body inside @value layer.
435fa085ec 2010-11-21        kinaba:   But when we refer the variables x and y, we need its @type layer meaning.
435fa085ec 2010-11-21        kinaba:   Hence we use @type() there.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   Now we get it.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> @type( 1 + 2 )
435fa085ec 2010-11-21        kinaba:     int
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   Well, but do we have to define the @type layer meaning for every variables???
435fa085ec 2010-11-21        kinaba:   No. After you defined @type "+", you'll automatically get the following:
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> def double(x) { x + x }
435fa085ec 2010-11-21        kinaba:     (function:17e4740:1789720)
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> @type( double(123) )
435fa085ec 2010-11-21        kinaba:     int
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   Every user-defined functions are automatically "lift"ed to the appropriate layer.
435fa085ec 2010-11-21        kinaba:   Only primitive functions like "+" requires @yourNewLayer annotation.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: <<Layers :: neutral-layer>>
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   let|var|def is to define a variable in the "current" layer.
435fa085ec 2010-11-21        kinaba:   Not necessary to the @value layer.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> @value( let x = 1 in @value(x) )
435fa085ec 2010-11-21        kinaba:     1
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> @macro( let x = 1 in @value(x) )
435fa085ec 2010-11-21        kinaba:     polemy.failure.RuntimeException: [<REPL>:14:29] variable x not found
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> @macro( let x = 1 in @macro(x) )
435fa085ec 2010-11-21        kinaba:     {pos@value:{lineno@value:15, ...
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: <<Layers :: Layered-Parameters>>
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> def foo(x @macro @value) { {fst: x, snd: @macro(x)} }
435fa085ec 2010-11-21        kinaba:     (function:1730360:1789720)
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   If you annotate function parameters by @LayerNames, when you invoke the function...
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:     >> foo(1+2)
435fa085ec 2010-11-21        kinaba:     {snd@value: {pos@value:{lineno@value:17, column@value:5, filename@value:<REPL>},
435fa085ec 2010-11-21        kinaba:                   is@value:app, arg@value:{...
435fa085ec 2010-11-21        kinaba:     /fst@value:3
435fa085ec 2010-11-21        kinaba:     /}
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:   its corresponding arguments are evaluated in the layer and passed to it.
435fa085ec 2010-11-21        kinaba:   If you specify multiple layers, the argument expression is run multiple times.
435fa085ec 2010-11-21        kinaba:   If you do not specify any layer for a parameter, it works in the neutral layer.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: <<@macro layer>>
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:    When function is invoked, it first run in the @macro layer, and after that,
435fa085ec 2010-11-21        kinaba:    it run in the neutral layer. Here is an example.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:      >> @macro twice(x) { x; x }
435fa085ec 2010-11-21        kinaba:      >> def f() { twice(print("Hello")); 999 }
435fa085ec 2010-11-21        kinaba:      (function:173b6a0:1789720)
435fa085ec 2010-11-21        kinaba:      >> f()
435fa085ec 2010-11-21        kinaba:      Hello
435fa085ec 2010-11-21        kinaba:      Hello
435fa085ec 2010-11-21        kinaba:      999
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:    When the interpreter evaluates f(), it first executes
435fa085ec 2010-11-21        kinaba:      "twice(print("Hello")); 999"
435fa085ec 2010-11-21        kinaba:    in the @macro layer. Basically what it does is to just construct its syntax tree.
435fa085ec 2010-11-21        kinaba:    But, since we have defined the "twice" function in the @macro layer, it is
435fa085ec 2010-11-21        kinaba:    execute as a function. Resulting syntax tree is
435fa085ec 2010-11-21        kinaba:      "print("Hello"); print("Hello"); 999"
435fa085ec 2010-11-21        kinaba:    and this is executed on the neutral (in this example, @value) layer.
435fa085ec 2010-11-21        kinaba:    This is the reason why you see two "Hello"s.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:       [[limitations]]
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:    This @macro layer is a very primitive one, and not a perfect macro language.
435fa085ec 2010-11-21        kinaba:    Two major limitations are seen in the following "it" example.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:      >> @macro LetItBe(x, y) { let it = x in y };
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:    The variable name is not hygenic, and so without any effort, the syntax tree "y"
435fa085ec 2010-11-21        kinaba:    can access the outer variable "it".
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:      >> def foo() { LetItBe( 1+2+3, it*it ) }
435fa085ec 2010-11-21        kinaba:      >> foo()
435fa085ec 2010-11-21        kinaba:      36
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:    Of course, this is not just a limitation; it can sometimes allow us to write
435fa085ec 2010-11-21        kinaba:    many interesting macros.
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:    The other problem is that the macro expansion is only done at function startup.
435fa085ec 2010-11-21        kinaba:    So
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:      >> LetItBe( 1+2+3, it*it )
435fa085ec 2010-11-21        kinaba:      ...\value.d(173): [<REPL>:24:1] variable LetItBe is not set in layer @value
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:    you cannot directly use the macro in the same scope as the definition.
435fa085ec 2010-11-21        kinaba:    You need to wrap it up in a function (like the foo() in the above example).
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:       [[quote and unquote]]
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:    Here is more involved example of code genration.
435fa085ec 2010-11-21        kinaba:    From "x", it generates "x*x*x*x*x*x*x*x*x*x".
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:      @macro pow10(x) {
435fa085ec 2010-11-21        kinaba:        @value(
435fa085ec 2010-11-21        kinaba:          def pow(x, n) {
435fa085ec 2010-11-21        kinaba:            if( n == 1 ) { x }
435fa085ec 2010-11-21        kinaba:            else {
435fa085ec 2010-11-21        kinaba:              @macro( @value(x) * @value(pow(x,n-1)) )
435fa085ec 2010-11-21        kinaba:            }
435fa085ec 2010-11-21        kinaba:          }
435fa085ec 2010-11-21        kinaba:          in
435fa085ec 2010-11-21        kinaba:            pow(@macro(x),10)
435fa085ec 2010-11-21        kinaba:        )
435fa085ec 2010-11-21        kinaba:      };
435fa085ec 2010-11-21        kinaba: 
435fa085ec 2010-11-21        kinaba:    Here, x is a syntax tree but n is an actual integer. If you read carefully,
435fa085ec 2010-11-21        kinaba:    you should get what is going on. Basically, @macro can be considered like
435fa085ec 2010-11-21        kinaba:    quasiquoting and @value to be an escape from it.
c1f2717799 2010-11-21        kinaba: 
c1f2717799 2010-11-21        kinaba: 
c1f2717799 2010-11-21        kinaba: 
c1f2717799 2010-11-21        kinaba: <<Primitives>>
c1f2717799 2010-11-21        kinaba: 
c1f2717799 2010-11-21        kinaba:   {}  0-ary  create-empty-table
c1f2717799 2010-11-21        kinaba:   .   2-ary  table-get
c1f2717799 2010-11-21        kinaba:   .?  2-ary  table-has?
c1f2717799 2010-11-21        kinaba:   .=  3-ary  table-set
c1f2717799 2010-11-21        kinaba: 
c1f2717799 2010-11-21        kinaba:   if  3-ary  if-then-else
c1f2717799 2010-11-21        kinaba: 
c1f2717799 2010-11-21        kinaba:   + - * / % || &&    2-ary  integer-operations (no short-circuit!)
c1f2717799 2010-11-21        kinaba:   < > <= >= == !=    2-ary  generic comparison
c1f2717799 2010-11-21        kinaba: 
c1f2717799 2010-11-21        kinaba:   print 1-ary print-to-stdout
c1f2717799 2010-11-21        kinaba: 
c1f2717799 2010-11-21        kinaba:   _isint _isstr _isfun _isundefined _istable  1-ary  dynamic-type-test
c1f2717799 2010-11-21        kinaba: