Differences

This shows you the differences between two versions of the page.

--- at:tutorial:metaprogramming [2007/05/04 02:26]
stimberm
+++ at:tutorial:metaprogramming [2008/08/01 14:31]
tvcutsem *
@@ Line 1: / Line 1: @@
-<note>This tutorial is under heavy construction!</note>
 ===== Metaprogramming =====
@@ Line 14: / Line 12: @@
 >>7
 </code>
-However, these constructs are all **syntactic sugar**. Behind the scenes, they all perform message sends. The following code shows the equivalents of the previous code, but with the actual message sends:
+However, these constructs are all **syntactic sugar** that enable a more natural syntax for performing these operations. Behind the scenes, they all perform message sends. The following code shows the equivalents of the previous code, but with the actual message sends:
 <code>
 >[5, 6, 7].at(2)
@@ Line 24: / Line 22: @@
 </code>
-Another special AmbientTalk construct is the literal closure. A literal closure is just an object with a special //apply// method that will execute the body of the literal closure.
+In the first example above the message //at// is sent to the table **[5,6,7]**.  The second example sends the keyword message //ifTrue:ifFalse:// to the boolean value returned after evaluating the expression **(1 == 2)**. Notice the usage of the curly braces.  These wrap the expressions in a literal closure object.  A literal closure is just an object with a special //apply// method that will execute the body of the literal closure.  The usage of these closures ensures lazy evaluation of the actual arguments of //ifTrue:ifFalse:// similar to the use of blocks in Smalltalk or Self.  Finally, in the third example, mathematical expressions are converted to method invocations on numbers.
 ==== Quasiquoting and splicing ====
+Quasiquoting and splicing are an advanced and powerful metaprogramming techniques that control the evaluation process and allow one to manipulate the evaluation process of the abstract syntax tree.
-=== Qouting ===
+=== Quoting ===
 Any valid AmbientTalk expression can be quoted. This prevents the expression from being evaluated. Instead, it is returned literally.
@@ Line 61: / Line 60: @@
 </code>
-Note that in ''`foo.text'', the quoted expression is ''foo'' and //not// ''foo.text''. The selection is performed on the result of the quotation, in this case a symbol.
+Note that in ''`foo.text'', the quoted expression is ''foo'' and //not// ''foo.text''. The selection of the field //text// is performed on the result of the quotation, in this case a symbol.
 == Expressions ==
-To quote a complete expression, it has to be wrapped in parantheses:
+To quote a complete expression, it has to be wrapped in parentheses:
 <code>
@@ Line 80: / Line 79: @@
 == Statements ==
-Statements (definitions, assignments, ...) can also be quoted, but only inside a quoted statement list. Trying to quote a statement in the same way as an expression will cause a parse error.
+Statements (definitions, assignments, ...) can also be quoted, but only inside a quoted statement list. Trying to quote a statement in the same way as an expression will cause a parse error.  Instead it is necessary to wrap the statements in a closure using ``{'' and ``}''.
 <code>
@@ Line 103: / Line 102: @@
 With this construct, all the elements of the literal table are evaluated. By quoting a literal table, all the elements are quoted instead of evaluated:
 <code>
->def tab := `[ 1+2, 3+4, 5+6 ]
+>def anotherTab := `[ 1+2, 3+4, 5+6 ]
 >>[1.+(2), 3.+(4), 5.+(6)]
 </code>
@@ Line 129: / Line 128: @@
 >[ 7, 8, 9, @upTo(4) ]
 >>[7, 8, 9, 1, 2, 3, 4]
+>[ 7, 8, 9, upTo(4) ]
+>>[7, 8, 9, [1, 2, 3, 4]]
 </code>
+In the example above the elements of the table returned by invoking **upTo(4)** are added in place to the table in which the expression was spliced.  Evaluating the same expression without the splice operator adds the table rather than the elements of the table.  Hence, the use of the splice operator removes a level of nesting and adds the elements //in place// to the table.
 Splicing can also be used in combination with quoting and unquoting. AmbientTalk provides the //unquote-splice// operator ''#@'' that can be used to splice the value of an unquotation into a quoted expression.
@@ Line 156: / Line 158: @@
 >application.new(`g, [4, 5, 6])
 >>g(4, 5, 6)
+</code>
+The following example uses meta-programming and reflection to generate a proxy for an object that provides a given interface. The interface's method list is examined and for each method specified in the interface, a method is generated that delegated to the actual object.
+<note>
+TODO: Update code
+</note>
+<code>
+def isMethodDefinition: statement { true };
+def policyOf: object with: interface {
+	def policyDefinition := interface.method.bodyExpression.statements;
+	policyDefinition.each: { | statement |
+		if: (isMethodDefinition: statement) then: {
+			def methodBody := statement.bodyExpression.statements;
+			if: ((methodBody.length == 1).and: { methodBody[1] == `nil }) then: {
+				def bodyExpression := `{ #(object) ^ #(statement.selector) ( #@(statement.arguments) ) };
+				statement.bodyExpression := bodyExpression;
+			}
+		}
+	};
+	object: interface;
+};
+</code>
+==== Read / Eval / Print ====
+AmbientTalk reifies the read, eval and print operations. This means that you can read any string and get the responding syntax tree for it, evaluate any syntax tree and get a value for it, and print any value and get a string representation of the value.
+<code>
+>read: "1+2"
+>>1.+(2)
+>def result := eval: `(1+2) in: self
+>>3
+>print: result
+>>"3"
+</code>
+Eval is a keyworded message that takes another parameter, namely the object in whose scope the expression must be evaluated.
+<code>
+>def o := object: { def x := 4 }
+>><obj:{super,super:=,x,x:=}>
+>eval: `x in: o
+>>4
 </code>

Ambient-Oriented Programming

User Tools

Site Tools

Differences

Page Tools