generating functions, templates, and macros

1
generating functions, templates, and macros

• Yves Lespérance
• Adapted from Peter Roosen-Runge

2
midterm October 20

• bring photo ID
• closed book no access to cellphones, PDAs,
  laptops, etc.
• test will be based on the material in the
  textbook (Ch. 2-8, 10-12, 14), lectures, and
  readings

3
constructing a pumper

• Automating Ch. 11
• pumper will create a tail-recursive function and
  a main function to call it, with arguments
• function name, the initial result, and a
  'construction' function f
• f constructs a new (partial) result from a
  previous (partial) result,
• with the name of f HELP-name

4
pumper in action

• Example construct both
• tail-recursive rev (reverse)
• and its helper function
• (pumper 'rev
• NIL initial
• 'CONS used to construct result )
• recall in rev2
• result --gt (CONS (FIRST list) result)

5
numerical example

• sum of squares (sumsq list)
• slow version
• ( ( (FIRST list) (FIRST list))
• (sumsq (REST list))
• or define sumsq and Help-SUMSQ
• (pumper
• 'sumsq
• 0
• '(LAMBDA (x y) ( ( x x) y))
• )

6
the main function

• code to construct the main function
• (DEFUN makeMain (name helper initial)
• (EVAL (LIST 'DEFUN name '(arglist)
• (LIST helper 'arglist initial))
• )
• )

7
make the helper

• (DEFUN makeHelp (helper f)
• (EVAL (LIST 'DEFUN helper '(arglist result)
• (LIST 'IF '(ENDP arglist) 'result
• (LIST helper '(REST arglist)
• (LIST FUNCALL (LIST 'FUNCTION f)
• (LIST 'FIRST arglist)
• result)))))
• )

8
demo

• gt(makehelp 'helpfun 'CONS)
• (defun helpfun (arglist result)
• (if (endp arglist) result
• (helpfun (rest arglist)
• (FUNCALL (function CONS)
• (first arglist) result))))

9
assembling the pieces

• (DEFUN pumper (name initial f)
• (LET ((helper (INTERN (FORMAT nil
  "Help-a" name))))
• (makeMain name helper initial)
• (makeHelp helper f)
• )
• )

10
using templates

• use template for expressions involving
  substitutions of values for variables into a
  fixed structure
• Lisp's substitution operators
• backquote means dont evaluate unless
  specified
• comma , ,expr means evaluate
• see form-cons.html

11
template example

• (DEFUN makeMain (name helper initial)
• (EVAL (DEFUN ,name (arglist) (,helper arglist
  ,initial)))
• )

12
the complete pumper

• (DEFUN pumper (name initial f)
• (LET ((helper (INTERN (FORMAT nil "Help-a"
  name))))
• (EVAL (DEFUN ,name (arglist) (,helper arglist
  ,initial)))
• (EVAL (DEFUN ,helper (arglist result)
• (IF (ENDP arglist) result (,helper (REST
  arglist)
• (FUNCALL (FUNCTION ,f) (FIRST arglist)
• result))))
• )
• )

13
pumper demo

• tail-recursive reverse
• gt(pumper 'rev NIL 'CONS)
• Help-REV
• gt(rev '(a b c))
• (C B A)
• (symbol-function 'Help-REV)
• (LAMBDA-BLOCK Help-REV (ARGLIST RESULT)
• (IF (ENDP ARGLIST) RESULT
• (Help-REV (REST ARGLIST)
• (FUNCALL 'CONS (FIRST ARGLIST) RESULT))))

14
closures

• A function may be defined in one context and used
  in another. If it contains free variables, this
  may cause problems.
• Lisp avoids this by keeping a record of the
  environment where the function was defined in a
  closure.

15
closure e.g.

• (DEFUN gen_adder (n)
• (FUNCTION (LAMBDA (x) ( x n))))
• (DEFUN eg (n k)
• (FUNCALL (gen_adder k) n))
• gt(eg 5 7)
• 12

16

• macros

17
sort of like functions, but . .

• one of the most interesting but tricky aspects of
  Lisp.
• unlike functions, macros don't evaluate their
  arguments
• they compute on unevaluated expressions
• just uninterpreted data structures
• binary trees
• 'dot' at the root of every sub-tree
• atoms at the leaves
• macros can be expanded once when function that
  uses macros is defined or compiled

18
COND is an example

• gt(DESCRIBE COND)
• special operator with macro definition, has 1
  property SYSTEMMACRO.
• For more information, evaluate
• (SYMBOL-PLIST COND)
• gt(SYMBOL-PLIST COND)
• (SYSTEMMACRO ltCOMPILED-CLOSURE CONDgt)

19
2-step

• macro evaluation takes two steps

s-expression
value
expansion
evaluation
MACROEXPAND
EVAL
gt(MACROEXPAND '(COND ((NULL x) 1)
((NULL y) 2) (OTHERWISE 3))) (IF (NULL X) 1 (IF
(NULL Y) 2 (IF OTHERWISE 3 NIL)))
20
e.g. flambda

• often write (FUNCTION (LAMBDA )) define a
  macro flambda that abbreviates this.
• (DEFMACRO flambda (REST args)
• (LIST FUNCTION (CONS 'LAMBDA
• args))) args will be a list
• (MACROEXPAND (FLAMBDA (X Y) (CONS X Y)))
• (LAMBDA (X Y) (CONS X Y))

21
using a template

• (DEFMACRO flambda (REST args)
• (FUNCTION (LAMBDA ,args)))

22
e.g. 2

• (DEFMACRO 2 (ARG)
• (1 (1 ,arg)))
• gt(MACROEXPAND (2 x))
• (1 (1 x))
• T
• gt(2 ( 3 5))
• 10

23
destructuring

• Macros often destructure their arguments, i.e.
  extract some of their parts this is easier if we
  use structured parameters, lists with named parts
• gt(DEFMACRO cross ((a b) (c d))
• ((,a ,d) (,b ,c)))
• (MACROEXPAND '(cross (one two)
• (three four)))
• ((one four) (two three))

24
fancier example

• (DEFMACRO crossdot ((a . b) (c . d)) ((,a ,d)
  (,b ,c)))
• (MACROEXPAND '(crossdot (one two
• three) (four five six)))
• ((one (five six)) ((two three) four)
• what's happening? what are a, b, c d bound
  to?

25
use of macros

• support abstraction at little cost, e.g.
  get-state-field
• can add abbreviations that make programming
  easier, e.g. COND, AND for more than 2 arguments,
  loop constructs, etc.
• can define embedded languages within Lisp with
  little execution cost
• caveat user must learn the syntax expected by
  the macros

26
macros vs. functions

• a macro is treated internally as a function of
  one argument
• order of evaluation is different, outside-in
  rather than inside-out, e.g.
• gt(MACROEXPAND (2 (2 5))
• (1 (1 (2 5)))
• T
• gt(2 (2 5))
• 9

27
more examples

• see
• http//www.cs.yorku.ca/course/3401/MacroExamples.h
  tml