lisp (vs ruby) metaprogramming

Lisp Metaprogramming
The programmable programming language

Friday, February 19, 2010

I’d rather play COD


“So, Ruby was a Lisp originally, in theory.
Let's call it MatzLisp from now on. ;-)”

-Matz

"Lisp isn't a language, it's a building material."

"the greatest single programming language ever
designed"

“OOP to me means only messaging, local
retention and protection and hiding of state-
process, and extreme late-binding of all things.
It can be done in Smalltalk and in Lisp. There
are possibly other systems in which this is
possible, but I'm not aware of them.”

-Alan Kay

As seen in Lisp since 1958
late binding
garbage collection
dynamic typing
if-then-else construct
function type
recursion
symbol type
Interactive development
Lisp Machines
...

As seen in Lisp since 1958
late binding
garbage collection
dynamic typing Scheme
if-then-else construct Common Lisp
function type Clojure
recursion Arc
symbol type NewLISP
Interactive development (JavaScript)
Lisp Machines
...

Lisp in 6 slides


Data structure: Linked lists


Data structure: Linked lists

((1 2) (3 4) (5 6))


Syntax: Linked lists (again)

(deﬁne y-combinator
(lambda (f)
((lambda (x) (f (x x)))
(lambda (x) (f (x x))))))

(homoiconicity)

Semantics: λ - Calculus

λxy.x



λxy.x
(lambda (x y) x)



λxy.x
(lambda (x y) x)

(λxy.x 2 4) -β> 2



λxy.x
(lambda (x y) x)

(λxy.x 2 4) -β> 2
((lambda (x y) x) 2 4) -> 2

Semantics: evaluation rule

Read-Eval-Print-Loop

(+ 3 (- 2 1))
(+ 3 1)
4

Semantics: special forms

backquote/unquote
(backquote (+ 2 3)) -> (+ 2 3)
`(+ 2 3) -> (+ 2 3)


Semantics: special forms

backquote/unquote
(backquote (+ 2 3)) -> (+ 2 3)
`(+ 2 3) -> (+ 2 3)
`(unquote (+ 2 3)) -> 5
`,(+ 2 3) -> 5

(Common) Lisp Macros


Why macros?
“Pascal is for building pyramids -- imposing,
breathtaking, static structures built by armies
pushing heavy blocks into place. Lisp is for building
organisms -- imposing, breathtaking, dynamic
structures built by squads fitting fluctuating myriads
of simpler organisms into place.
[...]
Invent and fit; have fits and reinvent!”

-from SICP foreword

Russian dolls

Lisp
user forms
special forms
kernel language


Russian dolls

language extensions
Lisp
user forms
special forms
kernel language


Functions vs Macros

Function

S-Expressions (f x) Values

Macro

S-Expressions (f x) S-Expressions


Functions vs Macros
S-Expressions
Macro
expansion (f x)
time
S-Expressions’
Compile /
execution (f’ x)
time
Values

The my-unless function
(defun my-unless (c ef et)
(if c et ef))


(if c et ef))

(my-unless t 1 2) -> 2
(my-unless nil 1 2) -> 1


(if c et ef))

(my-unless t 1 2) -> 2
(my-unless nil 1 2) -> 1

(my-unless t (print “test”) 1)
->”test”
1

The my-unless macro
(defmacro my-unless (c ef et)
(if c et ef))


The my-unless macro
(if c et ef))

->1


The my-unless macro
(if c et ef))

->1

(deﬁne *c* t)
(my-unless *c* (print “test”) 1)


The my-unless macro
`(if ,c ,et ,ef))

(deﬁne *c* t)


The my-unless macro
`(if ,c ,et ,ef))

(deﬁne *c* t)

(deﬁne *c* t)
(if *c* 1 (print “test”))

The my-unless macro
`(if ,c ,et ,ef))

(deﬁne *c* t)

(deﬁne *c* t)
1
(if *c* 1 (print “test”))

Macros taxonomy

flow modification
“with” macros -> abstracting pattens (with-file) (with-
gearman-request)
Object Oriented Lisp (CLOS) and Meta Object Protocol
Compilers, pasers, etc.
Functional lisp: monads, comonads, Tarski arrows,
currying, lazy evaluation


The Macro Club

The ﬁrst rule of the Macro Club is Don’t Write Macros
The second rule of Macro Club is Write Macros If That
Is The Only Way to Encapsulate a Pattern

-from Programming Clojure

Ruby metaprogramming?


Ruby metaprogramming is
broken and cannot be ﬁxed
(imho)


(Lisp) [Ruby]

Simple regular sintax Complex sintax

Complex undeﬁned
Simple deﬁned semantics
semantics

Code = lists Code = strings

Code manipulation = list Code manipulation = string
manipulation funs. manipulation funs.

Macro expansion time Eval at run time

Alternatives: RubyAST, Ruby
parser

Code = AST objects
Code Manipulation = Objects Manipulation


No magic please


References


The Seasoned
On Lisp,
Schemer,
Paul Graham
Friedman

Programming
SICP,
Clojure,
Abelson et alt.
Stuart Halloway


lisp (vs ruby) metaprogramming

Recommended

Recommended

More Related Content

Recently uploaded

Recently uploaded (20)

Featured

Featured (20)

lisp (vs ruby) metaprogramming