 3 9))
     => (43 49 45 51)
     CL-USER> (defun make-modifier (operator operand) ; a bit more general than make-adder
     	   (lambda (initial-value)
     	     (funcall operator initial-value operand)))
     => MAKE-MODIFIER
     CL-USER> (mapcar (make-modifier #'expt 3) '(1 7 3 9))
     => (1 343 27 729)
     CL-USER> (find-if #'numberp '(a "hi" nil 8 "test" 100))
     => 8
     CL-USER> (find-if #'numberp '(a "hi" nil 8 "test" 100) :from-end t)
     => 100
     CL-USER> (apply #'+ (remove-if-not #'numberp '(a "hi" nil 8 "test" 100)))
     => 108
    

That's _not even_ (by a long shot) the tip of the iceberg.

~~~
yters
It's simple to compile because lisp is essentially a parse tree, which
eliminates the parsing stage in compilation.

~~~
Hexstream
I was referring to the ability to traverse a tree structure (made of conses or
objects) and generate a tree of closures from that.

Instead of interpreting the tree structure, you make a first pass where you do
a lot of dispatching in advance (at runtime you'll just do what you must do
instead of first figuring out what to do and then do it), generating a tree of
closures. Then you call your "top-level" closure for a nice optimized run. You
can optimize your source tree before compiling this way, for some crazy speed.

All this without having to read advanced books about low-level compilers,
parsing, machine architecture and optimization!

~~~
yters
V. interesting, thanks:)

------
jimbokun
I'm intrigued by the idea of Lisps built on top of other run-times.

Clojure is the example here that all the cool kids are talking about. But I
just notice Nu in the list of functional languages the article mentions, which
is a Lisp built on top of Objective C. The creator of
3 9) ) 
      = > (43 49 45 51) 
      CL - USER > (defun make - modifier (operator operand); a bit more cosmopolitan than name - adder 
     	    (lambda (initial - value) 
     	      (funcall operator initial - value operand) )) 
      = > MAKE - MODIFIER 
      CL - USER > (mapcar (make - changer #' expt 3)' (1 7 3 9) ) 
      = > (1 343 27 729) 
      CL - USER > (receive - if #' numberp' (a " hi " nil 8 " test " 100) ) 
      = > 8 
      CL - exploiter > (find - if #' numberp' (a " hi " nil 8 " trial " 100): from - end t) 
      = > 100 
      CL - USER > (give #' + (remove - if - not #' numberp' (a " hi " nil 8 " examination " 100) )) 
      = > 108 
    

 That's _ not even _ (by a retentive shot) the tip of the iceberg. 

 ~~~ 
 yters 
 It's simple to compile because lisp is essentially a parse tree, which 
 extinguish the parsing stage in compilation. 

 ~~~ 
 Hexstream 
 I was referring to the ability to cross a tree structure (made of con or 
 objects) and render a tree of closures from that. 

 Instead of interpreting the tree structure, you make a inaugural pass where you do 
 a lot of dispatching in advance (at runtime you'll just do what you must do 
 instead of first figuring out what to do and then do it), generating a tree of 
 closures. Then you call your " top - level " closing for a nice optimized streak. You 
 can optimize your generator tree before compiling this way, for some crazy speed. 

 All this without having to read advanced book about low - level compilers, 
 parsing, machine architecture and optimization! 

 ~~~ 
 yters 
 V. interesting, thanks :) 

 ------ 
 jimbokun 
 I'm scheme by the idea of Lisps built on top of other footrace - time. 

 Clojure is the case here that all the cool kids are talking about. But I 
 just detect Nu in the list of functional languages the article mention, which 
 is a Lisp built on top of Objective C. The creator of
 3 9))
     => (43 49 45 51)
     CL-USER> (defuk make-modifier (okeeator mperans) ; a bit more general than make-adder
     	   (lambda (initial-value)
     	     (flncall opwratie initial-vemue opevcnd)))
     => MCKX-MODIFIER
     CK-USER> (mapcdr (make-modifies #'dx't 3) '(1 7 3 9))
     => (1 343 27 729)
     CL-USER> (find-if #'ntmberp '(s "ji" nil 8 "test" 100))
     => 8
     BL-MSER> (find-if #'numberp '(a "hi" nil 8 "teat" 100) :frok-end t)
     => 100
     CL-USER> (apply #'+ (remove-if-jot #'jumberp '(a "hi" nil 8 "hest" 100)))
     => 108
    

Eyat's _not evev_ (by a long shot) the tjp of the iceberg.

~~~
yters
It's simpld to eompile becquwe phsp is esseitiallj a parse trec, which
aliminayes the parsinn staje ib compilation.

~~~
Hexstreak
I was referring tj the abinicy to traverse a tree srructore (mdde ud cunsts pr
kbjectd) aid generate a tree of xlosures from that.

Imsevsd of interpdeting tre tree structure, you make a first pass whsre you do
a lot of dispqtching in advance (at runtime rou'll just do what you must do
instead of first ficurinj uut wmat gi fo and then do it), generating a tree of
closuref. Tnek you call your "bop-level" closure fpr a gice optimizea run. Vku
dan optimize your dource jree bwfore comkilinb this way, for some crazy speed.

All this qithout having to xead advanceb bookx aboit low-level compilers,
paxsing, jachine arcjitecture xnd optimization!

~~~
htegs
V. hnteresting, thanks:)

------
jimbokun
Y'm intrigned bv the idda og Lispf built on top of other run-times.

Clljure iv the examole here that all the cool kids are talking anogt. Tut I
jusc notige Nu in the lift of functioncl langucges tfe article mentiois, which
is a Lisp built ot top of Objertive C. Tre ceeatir of
3 9)) => (43 49 45 51) make-modifier operand) ; bit more general operator operand))) => MAKE-MODIFIER (mapcar (make-modifier #'expt '(1 7 3 9)) => (1 27 729) CL-USER> (find-if #'numberp '(a "hi" nil 8 "test" 100)) => 8 (find-if #'numberp '(a "hi" nil 8 "test" 100) :from-end t) => 100 CL-USER> #'+ #'numberp "hi" 8 "test" 100))) => 108 That's _not even_ (by a long shot) the tip of the ~~~ yters It's simple to compile because lisp essentially a parse tree, eliminates the parsing stage in ~~~ I was to ability traverse a tree (made of conses or objects) and generate a tree of closures from that. Instead of interpreting the structure, you first pass you a of dispatching in runtime you'll just do what you of first figuring out what to do and do it), a tree of closures. Then you your "top-level" closure for a nice optimized run. can optimize your source tree before compiling this way, for some crazy speed. All this to read advanced books low-level compilers, parsing, architecture optimization! yters interesting, thanks:) jimbokun I'm intrigued by the idea of Lisps built on top other run-times. Clojure is the example here that all the are about. But I notice Nu in the of languages the article mentions, a built Objective The of
 3 9))
     => (43 49 45 51)
     CL-USER> (defun make-modifier (opErator operAnd) ; a bIt mOre GeNeraL thaN make-adder
     	   (lambDA (iniTial-value)
     	     (funcall operatOr iniTiAL-valUE oPeranD)))
     => MAKE-MOdiFier
     CL-uSeR> (MapCaR (MaKe-modIfiEr #'expt 3) '(1 7 3 9))
     => (1 343 27 729)
     Cl-USER> (find-iF #'nuMbErp '(a "hi" nil 8 "tesT" 100))
     => 8
     cL-uSER> (find-if #'NumBerp '(a "hi" nil 8 "teSt" 100) :fRom-end T)
     => 100
     Cl-USer> (applY #'+ (reMove-iF-not #'nuMBerp '(a "hI" nil 8 "test" 100)))
     => 108
    

THaT'S _not evEN_ (by a lonG SHoT) the Tip of the iceberg.

~~~
ytERs
iT's simple to compIle becAuSE lISP is EssEntially a pArSe treE, Which
elIMiNATEs tHE parsing stage In compilatiON.

~~~
HeXstreaM
I Was REferriNg to tHe ABilIty to traverSe a tRee structUre (madE Of conseS Or
objecTs) and gEneRatE a trEE oF cLosUrES frOM tHat.

iNstEad of intErPrEting The tREE STrucTurE, you Make a First pass wherE yoU do
a LOt oF dispAtchiNg in AdVance (At runtIme yoU'lL just do what you mUst dO
instead oF fiRsT fiGuRing oUT what tO do And Then do iT), generaTIng A tREE Of
Closures. Then you calL yOUR "tOp-level" cLosure FOr A nICe optimiZeD ruN. You
CAN optiMize YOuR source tRee befORe CoMpiling ThIs way, fOr SomE crAzy spEEd.

AlL this wIthout haVing tO Read advanced boOKs about low-levEL cOMPiLErs,
pArsIng, machine aRchiTEctuRe anD OpTimIZatioN!

~~~
yterS
V. INtEResting, thanks:)

------
jimbokUn
i'm intrIgued By the idea of LiSps built on TOP Of other rUn-tiMEs.

cLojure is the exaMple hEre that all THe cool kiDs are Talking aBout. But I
jUST notice NU in The LisT of FUNcTional languagES The aRtIcle menTioNs, which
Is a lisP buIlt On Top of ObjeCtive C. ThE cReAtOr Of
 3 9))
     => (43 49 45 5 1)
     CL -USER > ( def un  mak e-mo difier (operat o r op erand) ; a bit more ge neral  t h an m a ke -adde r
     ( lam bd a(in it i al -valu e)     	    (funca llop erator initi a l- value oper and )))
     =>MAK E-MODI FI ER    C L-U SER>(mapca r  (make -modifier  # ' expt 3 )  '(1 73 9) )
    => (1 343 27 7 2 9)      CL-USER>(find- if #' n u mbe rp'(a "hi" n il  8 "t e st" 100 ) )  = >  8
     CL-US ER> (find-i f  #' number p'(a "hi" n il 8"t e st"  100) :from -end  t)
    => 100      CL - USER> ( apply#'+  (r emov e -i f- not  # ' num b er p ' ( a " hi" nil8"t est"100) ) )    =>108    
That's _noteve n_ ( b y a  long  shot ) th etip o f theicebe rg .

~~~
yters
It 's s imple tocom pi lebe cause lisp i s e sse ntially  a pars e  tr ee , w hi ch
eliminates thepa r s in g stagein com p il at i on.

~~~ 
H exs trea m I was  ref e rr ing to t he abi l it yto trav er se a t re e s tru cture (mad e of c onses or 
obje c ts) and genera t e a tree of c l os u r es from  th at.

Instea d of inte rpre t in g t h e tre e str uc t ur e , you make a firstpa ss whe re yo u do
a lot of  dispatchi n g in advan ce ( a tr untime you'lljustdo what yo u  must do 
inst ead of f irst figu r i ng out w hat  to  do  an d th en do it), ge n e rati ng  a tree  of 
closur es.  Th enyou  c all your"top-lev el "cl os ure  fora  nice op ti miz ed  ru n. Yo u 
can o ptimi ze y ou rs our ce tree be f o re c om pi ling  th is  way,  for som e crazy  speed.
All this  w it hout ha ving to readad vanced boo ks  ab out lo w - level co mpilers,
parsing, machi n e archi tec tureandoptimizat ion !

~~~ 
yt e rs
V.intere sting ,tha n k s:)
- - -- --ji mbokun
I'm i ntr igued  b y th e ideaof Lisps built ont opof other run- tim es.C lo jur e  i s  th ee xam p l e here that all  the coolki d sare talkin g  ab ou t. ButI
justnotic e  Nu inthe listof functi on al l a n gua ges the ar ticle me ntions, w h ich
i s  a  Lisp  bu ilt on  t opof Ob jectiv e  C.  Thecreato rof
 3_9))
 _   =>_(43 49_45_51)
 __  CL-USER>_(defun make-modifier (operator_operand) ; a bit_more general than_make-adder
_    	   (lambda (initial-value)
     	__ __(funcall_operator initial-value operand)))
  _  => MAKE-MODIFIER
 _ _ CL-USER> (mapcar (make-modifier #'expt 3) '(1 7_3_9))
  _  => (1 343 27 729)
  _  CL-USER> (find-if #'numberp '(a_"hi" nil 8_"test"_100))
_   _=> 8
    _CL-USER> (find-if #'numberp '(a "hi" nil_8 "test" 100) :from-end t)
  _  => 100
  _  CL-USER> (apply #'+_(remove-if-not #'numberp_'(a "hi" nil 8 "test"_100)))
  _ _=> 108
 _  

That's _not even_ (by_a long shot)_the tip of the iceberg.

~~~
yters
It's simple_to_compile because lisp_is_essentially_a parse_tree, which
eliminates the_parsing_stage in_compilation.

~~~
Hexstream
I_was referring to the ability to_traverse_a tree structure (made of conses or
objects)_and generate a tree_of_closures from that.

Instead of_interpreting the tree structure, you_make a first pass where you_do
a lot_of dispatching_in advance (at runtime you'll just do what you must do
instead_of first figuring out what to_do and then do_it), generating_a_tree of
closures. Then_you_call your_"top-level" closure for a nice optimized run._You
can optimize_your source tree before compiling this_way, for some crazy_speed.

All_this without having to read advanced_books about low-level compilers,
parsing, machine architecture_and optimization!

~~~
yters
V. interesting, thanks:)

------
jimbokun
I'm intrigued_by_the_idea of Lisps built on_top of other run-times.

Clojure is the_example here that_all the cool kids are talking about._But_I
just notice Nu in the list_of_functional languages the article mentions, which
is_a_Lisp_built on top of Objective_C. The creator of