94 94 # Both prints "original". Macro respects the neutral layer's "let y=" 95 95 # and "fun(y)". It does not alter the inner scope y 96 96 @macro test1(y) { fun(y){y}("original") }; 97 97 @macro test2(y) { let y = "original" in y }; 98 98 print( test1("replaced?") ); 99 99 print( test2("replaced?") ); 100 100 101 -######################################## 102 -print("----------"); 103 - 104 -# Macro expansion is done only at the first call. 105 -# So by using @macro parameter, it can remember the argument 106 -# of the first call. 107 -def remember1( x @macro, y ) { if x == y then "yes" else "no" }; 108 -print( remember1(1, 1) ); # yes 1 == 1 109 -print( remember1(2,1) ); # yes "1" == 1 110 -print( remember1(2,2) ); # no "1" != 2 111 - 112 -# exactly the same function, but called in different order 113 -def remember2( x @macro, y ) { if x == y then "yes" else "no" }; 114 -print( remember2(2, 2) ); # yes "2" == 2 115 -print( remember2(2, 1) ); # no "2" != 1 116 -print( remember2(1, 1) ); # no "2" != 1 117 - 118 -# Is this a good thing or a bad thing?? 119 - 120 101 ######################################## 121 102 print("----------"); 122 103 123 104 # Trick to extract the AST of a function 124 105 def foo(x) { x + x }; 125 106 print( @macro(@value(foo)(arg1)) ); # prints AST for "arg1 + arg1" 126 107 127 108 # If we wrote @macro(foo(arg1)), it is the AST of "foo(arg1)" 128 109 # Here, by @value(foo) we obtain the "usual" behavior of foo, 129 110 # not the macro-like bahavior to construct AST "foo(??)". 130 111 # But still, by @macro( ... ) layer, the "usual" function is run in 131 112 # macro mode.