macros are sort of like c macros but more powerful. they are the
manafestation of treating code like data. lisp code is just a textual
representation of a data structure that is the list. this means that
you can manipulate code to emulate structured controll constructs and
elemanate boilerplate code. to show you the power of a macro heer is a
while loop
<code>
(defmacro while (test &body body)
`(do ()
((not ,test))
,@body)
</code>
Another one would be untill
<code>
(defmacro untill (test &body body)
`(while (not ,test) ,@body))
</code>
wich is defined on top of while
another test to wead out programers would be lisp stile macros because
of variable capture
and other perls of the macro world. but higenic macros can not have the
power of true macros
i also hear you talk about introspection. in lisp you use eval list
lets define a sum function to show you
<code>
(defun sum (lst)
(eval (append '(+) lst)))
</code>
another example would be this
<code>
(loop (print (eval (read))))
</code>
this is an interactive top level in 1 line
another use is for calling of functions
<code>
(defvar cmds `('foo ,(lambda () (format t "hello world")))
(funcall (getf cmds (read-from-string (read-line))))
</code>
of corse no error checking for comas and other things that could crash
the program
On Sat, 4 Aug 2006, ·········@aol.com wrote:
> macros are sort of like c macros but more powerful. they are the
> manafestation of treating code like data. lisp code is just a textual
> representation of a data structure that is the list. this means that
> you can manipulate code to emulate structured controll constructs and
> elemanate boilerplate code.
Yes, we know.
> to show you the power of a macro heer is a
> while loop
>
> <code>
> (defmacro while (test &body body)
> `(do ()
> ((not ,test))
> ,@body)
> </code>
>
> Another one would be untill
>
> <code>
> (defmacro untill (test &body body)
> `(while (not ,test) ,@body))
> </code>
>
> wich is defined on top of while
>
> another test to wead out programers would be lisp stile macros because
> of variable capture
> and other perls of the macro world. but higenic macros can not have the
> power of true macros
>
> i also hear you talk about introspection. in lisp you use eval list
Only if you're a masochist...
> lets define a sum function to show you
>
> <code>
> (defun sum (lst)
> (eval (append '(+) lst)))
> </code>
I think you mean
(defun sum (lst)
(apply #'+ lst))
> another example would be this
>
> <code>
> (loop (print (eval (read))))
> </code>
> this is an interactive top level in 1 line
>
> another use is for calling of functions
>
> <code>
> (defvar cmds `('foo ,(lambda () (format t "hello world")))
> (funcall (getf cmds (read-from-string (read-line))))
> </code>
> of corse no error checking for comas and other things that could crash
> the program
Schemers the code below is common lisp because thats what i know, and
when i say lisp i mean the famoly not common lisp
brain glich i just forgot about apply while i was posting
(defun squares (x)
(mapcar #'* x x))
this lists the pirfect squares by the numbers of the list
antother one is this
i am just an noob at lisp, but already i can see its power. lisp is
more powerful than any other languige even thogh the current
implementations are horable. lisp has the power of macros witch are not
just an efishancy hack as in C/C++ they are manifistations of the power
of the power of treating code as data. but all this power comes with a
tiny price you must be able to controll it. most mainstream languiges
(java,Dflat,the basic languiges.) on the other hand are digsined for
dolts, who would even strugle with mit's comp-sci curiculums first
class 6.001 or six double Oh 1. because they are stupid ignorant twits
that dont know a damn about abstraction, factoring, pointers, recursive
algorithums, and have an IDE To teach them the languige (but sadly
there languiges seem to require it), we lispers can handle lisp reader
macros that look worst than most perl, can use the first introspective
languige (the only one that is introspective by takeing things out than
putting things in). this means that lisp code is just an textual
representation of lists. this is the basis of lisp. lisp has the power
of the abilaty of treating code as data wich alouse you to create
vhll's or lisp is a VHLL. lisp is a 5th gen languige, because of the
stile of programing called bottom up wich alows you to create your own
5th gen languige. wich is the primary stile of lisp developers.
When you have a powerful languige pepol will not tolerate anything less
than there used to so when you got lisp hackers they are easyer to get
because of the fact that you canot use anything less than lisp
English can also be a powerful language when used (and spelt)
correctly.
Just saying.
·········@aol.com wrote:
> i am giveing you arguments for prostilizing lisp/scheme. i know you
> know, but most pepole do not know about the power of lisp.