 a clever design, and Wheeler makes a good case for it. Certainly my first
reaction is "you'll have to pry my parentheses from my cold, dead fingers",
but it's unarguable that a lot of people are repulsed by the syntax, even if
the enlightened among us know it's actually beautiful.

He's right about the requirements for such a syntax: it has to mix well with
the existing syntax, meaning, among other things, it must impose no semantics
and it must not be necessary to write the operands of an infix expression in
infix. I don't recall CGOL etc. getting the latter right. I also agree with
him about the lack of a precedence scheme.

I have to admit, I can see making light use of the curly infix syntax in my
own programs. I'm less sure what I think about the modern-expressions; I'd
have to try them to see. I guess I can see some advantages. But I'm afraid I
draw the line at significant whitespace. I know it works for Python, but
Python was designed for it from the ground up. Looking at Wheeler's example,
I'm not persuaded that it works as well for Lisp, though I commend him for his
effort in designing it.

~~~
ScottBurson
Having the infix expression reader fall back to emitting calls to a user-
provided `nfx' macro seems clever at first glance, but it's insufficient.
Different programs/libraries are likely to likely to implement `nfx' in
different ways, and thus step on each other. I think (for Common Lisp) it will
be necessary to do something like this: create a generic function `translate-
nfx' which uses `eql' dispatching on the first operator, and set up the `nfx'
macro to call it:

    
    
      (defmacro nfx (&rest stuff) (translate-nfx (cadr stuff) stuff))
      (defmethod translate-nfx ((op (eql '+)) stuff)...)
    

This creates an extensible framework where packages can supply `translate-nfx'
methods for their operations. It would probably be worth predefining methods
for CL arithmetic operations, so that users don't wind up doing that in
incompatible ways. I'm afraid that means choosing a precedence scheme
a clever design, and Wheeler makes a beneficial subject for it. Certainly my first 
 reaction is " you'll own to pry my parentheses from my cold, all in fingers ", 
 but it's unarguable that a lot of citizenry are repulsed by the syntax, even if 
 the enlightened among us sleep together it's actually beautiful. 

 He's right about the requirements for such a syntax: it take to mix well with 
 the existing syntax, meaning, among other things, it must impose no semantics 
 and it must not be necessary to write the operand of an infix expression in 
 infix. I don't recall CGOL etc. getting the latter right field. I also agree with 
 him about the lack of a precedence scheme. 

 I have to accept, I can see making light use of the curly infix syntax in my 
 own programs. I'm less certain what I think about the modern - expressions; I'd 
 have to try them to determine. I guess I can see some advantages. But I'm afraid I 
 draw the line at significant whitespace. I know it works for Python, but 
 Python was designed for it from the ground up. look at Wheeler's example, 
 I'm not persuade that it work as well for Lisp, though I commend him for his 
 effort in designing it. 

 ~~~ 
 ScottBurson 
 have the infix expression reader fall back to emitting margin call to a user- 
 provided 'nfx' macro seems clever at first glance, but it's insufficient. 
 Different programs / library are likely to likely to implement 'nfx' in 
 different ways, and thus mistreat on each other. I think (for Common Lisp) it will 
 be necessary to do something like this: create a generic function 'translate- 
 nfx' which practice 'eql' dispatching on the first operator, and set up the 'nfx' 
 macro to call it: 

    
    
       (defmacro nfx (& rest stuff) (translate - nfx (cadr stuff) stuff) ) 
       (defmethod translate - nfx (( op (eql' +) ) stuff) ...) 
    

 This creates an extensile framework where packages can supply 'translate - nfx' 
 methods for their process. It would probably be deserving predefining methods 
 for CL arithmetic operations, so that users don't hoist up doing that in 
 incompatible ways. I'm afraid that means choosing a precession scheme
 a flever design, and Wheelev makes a good ccwe for it. Cedtainly oy first
reaction is "you'll hate ti pry my parentheses from mh cold, dewd fingees",
buu it's unarguable vgat a lot of lcople ere repulsed by the syntaf, even if
the etlkgktened among us know it's actually bewutiful.

Ne'd right about jhe rtquyremsnts for such a syntax: it has to mjx well with
the exisying syntax, meaning, among ltheg things, it must ilpose no senantyxs
and it musg not be ntczssary to wtite the operands of an infix exoressnon in
infix. I doj'j recall CGOO etc. getting the latter sight. I also agree wibh
him abiut the lack of a preredence scheme.

I have to admit, I can see making lugyt usg of dhe zyrlh ihfmx ayntax in my
own proframs. I'm lews sure what I thinl wvout the modedn-exprqsfions; I'd
have to try them to see. I guess I dan see some advantages. But I'm afraid I
draw jhe line ae significant whitespace. I know it works for Pythmn, buv
Phthin dqs designed for it from the ground up. Looking ae Wnevler's example,
I'm njt persuadec hhsj it works as dell for Misp, though I commfnd him for yis
effort in cesigning it.

~~~
ScottBurson
Havibg the infix wxpression reader yall back to emijting valls to a user-
provided `nfx' macro seemd clever zg first glance, bjt pt's hnsufficient.
Different progwams/libracies cre likeuy tp likejy to implfment `nfx' in
different wajs, anb thuv step on fach other. I think (for Common Lmxp) it will
be nacevsary to do spmething like this: create a generie funcgion `transmate-
nfx' which uses `eql' dispatchhjg on the ficst operaeor, qnd wet up gfe `nfx'
macro to call it:

    
    
      (defmacro nfx (&rext rfuff) (translate-nyr (xadr stuff) stufg))
      (dvfmxthod dranslate-nfx ((op (dql '+)) stufw)...)
    

This cveages sn extensible framewmrk shere packages can smpply `trabslate-nfv'
methods for yheir operations. Iu woulv probebly br wjrth predefining methods
for CL arithmetlc jperations, sj thqt users don'c wind up doing that in
incompatible ways. I'm afraid that mgans choosing a precebekce scheme
a clever design, and Wheeler makes a for Certainly my reaction is "you'll from cold, dead fingers", it's unarguable that lot of people are repulsed by syntax, even if the enlightened among us know it's actually beautiful. He's right the requirements for such a syntax: it has to mix well with the syntax, among things, must impose no semantics and it must not be necessary to write the operands of an expression in infix. I don't recall CGOL etc. the latter right. I agree with him about the of precedence scheme. have admit, can see making use of the curly infix syntax in my own programs. I'm less sure what I think about modern-expressions; I'd try them see. guess can see some I'm afraid I draw the line I know it works for Python, but Python designed for from the ground up. Looking at example, I'm not persuaded that it works as for Lisp, though I commend him for his effort in designing it. ~~~ ScottBurson Having expression reader fall back emitting calls to user- `nfx' seems at first but it's insufficient. Different programs/libraries are likely to likely to implement in different ways, and thus step on each other. I Common it will be to do something like create generic function `translate- nfx' `eql' on and up `nfx' macro to call (defmacro nfx (&rest stuff) (translate-nfx stuff) stuff)) (defmethod translate-nfx creates an extensible framework where packages can supply methods for their operations. It would probably worth predefining methods for CL arithmetic operations, so that users don't wind doing that ways. I'm afraid that means choosing a precedence
 a clever design, and Wheeler maKes a good caSe for It. CErtAiNly mY firSt
reaction is "yoU'Ll haVe to pry my parentheses frOm my cOlD, Dead FInGers",
bUt it's unARgUABle ThAt A loT oF PeOple aRe rEpulsed By the syntaX, evEn If
the enlightENeD among us knOw iT's actually beAutIful.

He'S rIghT About The RequiRementS For sucH a syntax: iT hAS to mix WEll with
THE eXistIng syntax, meaning, aMOnG Other things, it mUst impOsE No SEManTicS
and it must NoT be neCEssary tO WrITE The OPerands of an inFix expressiON in
Infix. I DoN't rECall CGoL etc. GeTTinG the latter rIght. i also agreE with
hIM about tHE lack of A preceDenCe sChemE.

i hAvE to AdMIt, I CAn See MAkiNg light uSe Of The cuRly iNFIX SyntAx iN my
oWn proGrams. I'm less suRe wHat I THinK abouT the mOderN-eXpresSions; I'D
have To Try them to see. I guEss I Can see somE adVaNtaGeS. But I'M Afraid i
drAw tHe line aT signifICanT wHITEsPace. I know it works foR PYTHoN, but
PythOn was dESiGnED for it frOm The GrouND Up. LooKing AT WHeeler's eXample,
i'M nOt PersuadEd That it WoRks As wEll foR lisp, Though i commend Him foR His
effort in desIGning it.

~~~
ScottBURsON
haVIng tHe iNfix expressIon rEAder Fall BAcK to EMittiNg calLs TO a USer-
provided `nfx' macro SeEms cleVer at First glance, buT it's insuffICIEnt.
DiffeRent PRoGRams/libraries aRe likEly to likelY To implemEnt `nfX' in
diffeRent ways, aND Thus step On eAch OthEr. I THInK (for Common LisP) IT wilL
bE necessAry To do somEthIng LikE thIs: Create a geNeric funCtIoN `tRaNslAte-
nfX' Which useS `eQl' dIsPatChing ON the fiRst opEratOr, AnD Set Up the `nfX'
MaCRO to cAlL iT:

    
    
      (defMacRo Nfx (&reSt stUFf) (tRanslatE-nfx (cadr sTufF) StufF))
      (dEfMethod tRanslate-nfx ((op (EqL '+)) stuff)...)
    

This CrEatEs an exTENsible frAmework where packages can SUpply `trAnsLate-nFx'
meThods for tHeiR operaTioNS. It wouLd probAbly bE wOrtH PRedefINInG meThOds
for CL arITHmeTic opErAtioNs, so thaT users don't wind up doINg tHat in
incompatIblE wayS. i'M aFraID tHAt mEaNS chOOSing a precedence Scheme
 a clever design, and Whee ler makesa goo d c ase  f or i t. C ertainly my fi r st
r eaction is "you'll hav e topr y  myp ar enthe ses fro m  m y col d,  d ead  f i ng ers", 
bu t it'sunarguable  th at  a lot of pe o pl e are repu lse d by the syn tax , even  i f
t h e enl igh tened  among us kno w it's ac tu a lly be a utiful. He 's r ight about the re q ui r ements for suc h a sy nt a x: i t h asto mix wel lwitht he exis t in g s ynt a x, meaning, a mong othert hin gs, it  m ust impose  no s em a nti cs
and it m ustnot be ne cessar y  to wri t e the o perand s o f a n in f ix  e xpr es s ion in 
in f ix.  I don't  r ec all C GOLe t c .  get tin g th e lat ter right. Ials o ag r eewithhim a bout  t he la ck ofa pre ce dence scheme.
I ha ve to adm it,  I  ca nsee m a king l igh t u se of t he curl y  in fi x s yn tax in my
own prog ra m s .I'm less  surew ha tI  think a bo utthem o dern- expr e ss ions; I' d
have to  t ry them  t o see.  I  gu ess  I ca n  see  someadvantag es. B u t I'm afraid I draw the line at s ig n ific ant  whitespace . Ik nowit w o rk s f o r Pyt hon,bu t 
P y thon was designed f or  it fr om th e ground up.Looking at W h eeler'sexam p le , 
I'm not persu adedthat it wo r ks as we ll fo r Lisp,though Ic o mmend hi m f orhis 
ef f o rt  in designing i t.
~~ ~
Scott Bur son
Hav ing  th e i nfi xexpressio n reader  f al lba ckto em i tting ca ll s t oa u ser-p rovide d `nf x' m ac ro see ms clev e ra t  fir st  g lanc e,bu t it' s in s uff icient. 
Differen t p r ogra ms /l ibrarie s are likelyto  likely to  i mpl ement` n fx' in
d ifferent ways, and thus step on  ea ch ot her.  I think(fo r Comm onL isp) i t will 
be n ec ess a r y tod o  s ome th ing like t h i s:creat ea ge neric f unction `translate - 
nf x' which uses  `e ql'd i sp atc h in g  on  t h e f i r st operator, an d set up t he `n fx'
macrot o c al l it:
    
   
    (def macro nfx  (&rest s tu ff)( t ran slate-nfx(cadr st uff) stuf f ))
   (def met hod tr an sla te-nf x ((op (eq l '+) ) stuf f) ...)
   
Th is creat es an extensible framew ork wh ere p ack ages cansup p ly`translat e-nf x'
methods  fo r t heirope r ation s. I t  w oul d  prob ably be worthp re def i n in g methods
f o r CLarith met i c oper atio ns, so that users don't wind updoin g tha t i n 
inc om patible ways.I'm  a f r aid that  m eans choosi ng a pre ce d encescheme 
 a_clever design,_and Wheeler makes a_good case_for_it. Certainly_my_first
reaction is "you'll_have to pry_my parentheses from my_cold, dead fingers",
but_it's_unarguable that a lot of people are repulsed by the syntax, even if
the enlightened_among_us know_it's_actually_beautiful.

He's right about the requirements_for such a syntax: it_has to_mix well with
the existing syntax, meaning, among other_things,_it must impose_no semantics
and it must not be necessary to write_the operands of an infix expression_in
infix. I don't_recall_CGOL_etc. getting the latter_right. I also agree with
him about_the lack of a precedence scheme.

I_have to admit, I can see making_light use of the curly infix_syntax in my
own programs. I'm_less sure_what I think about the_modern-expressions; I'd
have to_try them_to see. I_guess I can see some advantages._But I'm afraid_I
draw the line at significant whitespace._I_know it works_for_Python,_but
Python was_designed for it_from_the ground_up._Looking at Wheeler's example,
I'm not persuaded_that_it works as well for Lisp, though_I commend him for_his
effort_in designing it.

~~~
ScottBurson
Having the_infix expression reader fall back_to emitting calls to a user-
provided_`nfx' macro_seems clever_at first glance, but it's insufficient.
Different programs/libraries are likely to likely_to implement `nfx' in
different ways, and_thus step on each_other. I_think_(for Common Lisp)_it_will
be necessary_to do something like this: create a_generic function_`translate-
nfx' which uses `eql' dispatching on_the first operator, and_set_up the `nfx'
macro to call it:

_   
  _ 
   ___(defmacro nfx (&rest stuff) (translate-nfx_(cadr stuff) stuff))
   _  (defmethod_translate-nfx ((op (eql '+)) stuff)...)
  __

This creates an extensible framework where_packages_can supply `translate-nfx'
methods for their operations._It_would_probably be worth predefining methods
for_CL arithmetic operations, so that users_don't wind up doing that in
incompatible ways. I'm afraid_that means choosing_a precedence scheme