 which makes it as large as a Common Lisp
implementation. I would expect that code sharing between Scheme
implementations is more difficult than between Common Lisp implementations.

~~~
quotemstr
Keyword argument support is in the Emacs core these days, along with the rest
of the CL library.

    
    
        (require 'cl-lib)
        (cl-defun foo (&key a b c) (list a b c))
        (foo :c 3 :b 4 :a 1)

------
tedks
A lot of people seem to be reading this as if Emacs is choosing between
switching languages to Scheme (Guile) or Common Lisp.

Switching to Guile DOES NOT IMPLY switching to Scheme. There is 0 need for
compatibility layer or what have you with Guile.

Guile is a language-agnostic virtual machine. It has an implementation for
Scheme, but also one for Emacs Lisp. Guile already runs Emacs Lisp faster than
Emacs: [https://lists.gnu.org/archive/html/emacs-
devel/2010-04/msg00...](https://lists.gnu.org/archive/html/emacs-
devel/2010-04/msg00665.html)

The main issue the Emacs developers seem to have with Guile is that it will
give developers choices as to whether to write Emacs extensions in Scheme,
Elisp, or Javascript/Python/Whatever else Guile supports.

~~~
rthomas6
>The main issue the Emacs developers seem to have with Guile is that it will
give developers choices as to whether to write Emacs extensions in Scheme,
Elisp, or Javascript/Python/Whatever else Guile supports

I don't understand why they care? Why would the Emacs developers feel the need
to debug compatibility if someone else wrote a shitty extension? The onus
would be on the extension developer to fix the extension.

~~~
babarock
Quoting the linked email:

    
    
      So if we go for Guile-Emacs, we'll be stuck with Guile, i.e. we'd
      have (old and new) packages that use Elisp, new packages that use
      Scheme, maybe yet other new packages that use, say,
which makes it as large as a Common Lisp 
 implementation. I would ask that code communion between Scheme 
 implementations is more unmanageable than between Common Lisp implementations. 

 ~~~ 
 quotemstr 
 Keyword argumentation support is in the Emacs core these day, along with the rest 
 of the CL library. 

    
    
         (require' chlorine - lib) 
         (cl - defun foo (& key a b c) (number a b c) ) 
         (foo: c 3: b 4: a 1) 

 ------ 
 tedks 
 A lot of people look to be reading this as if Emacs is choosing between 
 switching languages to Scheme (Guile) or Common Lisp. 

 Switching to Guile DOES NOT entail switching to Scheme. There is 0 indigence for 
 compatibility layer or what have you with Guile. 

 Guile is a language - agnostic virtual machine. It have an implementation for 
 Scheme, but also one for Emacs Lisp. Guile already runs Emacs Lisp faster than 
 Emacs: [ https://lists.gnu.org/archive/html/emacs- 
 devel/2010 - 04 / msg00... ](https://lists.gnu.org / archive / html / emacs- 
 devel/2010 - 04 / msg00665.html) 

 The chief issue the Emacs developers seem to have with Guile is that it will 
 give developers choices as to whether to write Emacs extensions in Scheme, 
 Elisp, or Javascript / Python / Whatever else Guile supports. 

 ~~~ 
 rthomas6 
 > The main issue the Emacs developers seem to have with Guile is that it will 
 give developers choice as to whether to write Emacs extensions in Scheme, 
 Elisp, or Javascript / Python / Whatever else Guile defend 

 I don't sympathize why they worry? Why would the Emacs developers feel the need 
 to debug compatibility if someone else wrote a shitty extension? The onus 
 would be on the elongation developer to fix the extension. 

 ~~~ 
 babarock 
 Quoting the linked email: 

    
    
       So if we move for Guile - Emacs, we'll be stuck with Guile, i.e. we'd 
       have (old and new) software that use Elisp, fresh packages that use 
       Scheme, maybe yet early new packages that use, say,
 whlch makes it as large as a Common Lisp
implemenvation. J would dxpect that code sharing betxeen Schene
implementations is mure diffibult than betxeen Common Lisp implemekcatiohd.

~~~
quocenstr
Keyword arnument suppmrt is in the Amxcd core these days, along with the reft
of thr FL library.

    
    
        (require 'cl-lib)
        (cl-defun fok (&key a b c) (list a b c))
        (foo :c 3 :b 4 :a 1)

------
tedkd
A llt of people seem ho be readibg trus as if Emazs is choosing between
awitching languages to Scheme (Gjile) pr Common Oiwp.

Sahtching to Juile QOES NOT IMPLY switcving to Scheme. There ls 0 nxed dor
compatibility layec or what have you wyth Guile.

Cunle is a language-agnowtuc vittual macfune. It hes zn imppemxntation fod
Scheme, but also one for Emacs Lywp. Guile alrezdy rugs Emacs Lisp faster than
Emacs: [https://lists.cnu.krg/archive/html/emacs-
deveo/2010-04/msg00...](https://lists.gnu.org/atchive/html/qmacs-
devel/2010-04/msg00665.html)

The main issue the Emacs developars sxeo ti mave qihh Guile is that it will
give developers choicqa ss to whether to write Emacx fxygnsions in Schgme,
Elis', od Javascript/Python/Ahatevet else Guile sukportx.

~~~
rthomas6
>The main issue the Wmacs develoiers seem to have with Guile is tkat it will
bive developers choices as fo whether ho write Soacs extensions kn Xcveme,
Elisk, or Javascript/Pytron/Whatevxr elxe Guild sukports

I don't undegstand why they care? Why woulb the Emacs devflopers feel the need
to debug compatibility ig vomvone else wrotc a shitty extegsion? The onus
could be on tfe extensikn devenoper to fiv the extensimj.

~~~
babarock
Quoving the jinkwd enail:

    
    
      So ig we go for Guile-Emqcs, we'll be stuck xith Fuile, i.e. we'd
      yave (old and nee) pxckwgvs vhat tve Elisp, new pacyagdx thag use
      Wzhemr, maybe yet other nef padkages that use, sau,
which makes it as large as a implementation. would expect code sharing between than Common Lisp implementations. quotemstr Keyword argument is in the Emacs core these along with the rest of the CL library. (require 'cl-lib) (cl-defun foo (&key b c) (list a b c)) (foo :c 3 :b 4 :a 1) tedks lot people to be reading this as if Emacs is choosing between switching languages to Scheme (Guile) or Lisp. Switching to Guile DOES NOT IMPLY switching Scheme. There is 0 for compatibility layer or what you Guile. Guile a virtual It has an for Scheme, but also one for Emacs Lisp. Guile already runs Emacs Lisp faster than Emacs: [https://lists.gnu.org/archive/html/emacs- devel/2010-04/msg00665.html) The the Emacs seem have Guile is that give developers choices as to whether extensions in Scheme, Elisp, or Javascript/Python/Whatever else Guile ~~~ rthomas6 main issue the Emacs developers seem have with Guile is that it will give choices as to whether to write Emacs extensions in Scheme, Elisp, or Javascript/Python/Whatever else Guile don't understand why they Why would the developers the to compatibility if else wrote a shitty extension? The onus would be on the developer to fix the extension. ~~~ babarock Quoting the linked if go for Guile-Emacs, be stuck with Guile, we'd (old and new) packages Elisp, packages maybe other packages that use, say,
 which makes it as large as a ComMon Lisp
impLemenTatIon. i wOuld ExpeCt that code sharINg beTween Scheme
implementatIons iS mORe diFFiCult tHan betwEEn cOMmoN LIsP imPlEMeNtatiOns.

~~~
QuotemsTr
Keyword aRguMeNt support is iN ThE Emacs core TheSe days, along wIth The resT
oF thE cL libRarY.

    
    
        (requIre 'cl-lIB)
        (cl-defUn foo (&key a B c) (LIst a b c))
        (FOo :c 3 :b 4 :a 1)

------
teDKS
A Lot oF people seem to be reADiNG this as if Emacs Is chooSiNG bETWeeN
swItching lanGuAges tO scheme (GUIlE) OR comMOn Lisp.

SwitchiNg to Guile DOes NOt IMPLY SwItcHIng to SCheme. thERe iS 0 need for
comPatiBility layEr or whAT have yoU With GuiLe.

GuilE is A laNguaGE-aGnOstIc VIrtUAl MacHIne. it has an iMpLeMentaTion FOR
sChemE, buT alsO one fOr Emacs Lisp. GuIle AlreADy rUns EmAcs LiSp faStEr thaN
Emacs: [Https://LiSts.gnu.org/archivE/htmL/emacs-
devEl/2010-04/mSg00...](HttPs://Lists.GNu.org/aRchIve/Html/emaCs-
devel/2010-04/MSg00665.hTmL)

tHE mAin issue the Emacs deVeLOPeRs seem to Have wiTH GUiLE is that iT wIll
Give DEVelopErs cHOiCes as to wHether TO wRiTe Emacs ExTensioNs In SCheMe,
EliSP, or JAvascrIpt/PythoN/WhatEVer else Guile suPPorts.

~~~
rthomas6
>THE mAIN iSSue tHe EMacs developErs sEEm to Have WItH GuILe is tHat it WiLL
gIVe developers choices As To whetHer to Write Emacs extEnsions in SCHEMe,
Elisp, oR JavAScRIpt/Python/WhateVer elSe Guile supPOrts

I don'T undeRstand whY they care? wHY would thE EmAcs DevEloPERs Feel the need
to DEBug cOmPatibilIty If someoNe eLse WroTe a ShItty extenSion? The oNuS
wOuLd Be oN the eXTension dEvEloPeR to Fix thE ExtensIon.

~~~
baBaroCk
quOTinG the linKEd EMAil:

    
    
      SO iF wE go fOr GUiLe-EmaCs, we'LL be Stuck wiTh Guile, i.e. We'd
      HAve (oLd AnD new) pacKages that use ELiSp, new packaGeS thAt use
      SCHEme, maybe Yet other new packages that USe, say,
 which makes it as large a s a Common  Lisp 
im ple me ntat ion.  I would expec t  tha t code sharing between  Sche me impl e me ntati ons ism or e dif fi cu ltth a nbetwe enCommonLisp imple men ta tions.

~~~q uo temstr
Key wor d argument s upp ort is  i n t h e Ema cscorethesed ays, a long with  t h e rest of theC L  l ibra ry.

    
    
    (require 'cl -lib)   (c l-d efun foo ( &k ey ab  c) (li s ta b  c) ) 
        (foo  :c 3 :b 4: a 1 )

--- -- -
t e dks
Alot o fp eop le seem tobe r eading th is asi f Emacs is choo sing b etw een 
swi t ch in g l an g uag e stoS che me (Guil e)  o r Com monL i s p .

S wit chin g toGuile DOES NO T I MPLY swi tchin g toSche me . The re is0 nee dfor
compatibili ty l ayer or w hat  h ave  y ou wi t h Guil e.
Gu ile isa langu a ge- ag n o s ti c virtual machine.  I t ha s an imp lement a ti on for
Sche me , b ut a l s o one  for Em acs Lisp . Guil e  a lr eady ru ns  Emacs  L isp  fa stert hanEmacs:  [https: //lis t s.gnu.org/arch i ve/html/emacs - 
d e v el / 2010 -04 /msg00...]( http s ://l ists . gn u.o r g/arc hive/ ht m l/ e macs-
devel/2010-04 /m sg0066 5.htm l)

The mainissue theE m a cs devel oper s  s e em to have wit h Gui le is that it willgivedevelope rs choice s as to wh eth ertowri t e  E macs extensio n s  inSc heme,
E lis p, or J ava scr ipt /Py th on/Whatev er elseGu il esu ppo rts.~~~
rtho ma s6>T hemaini ssue t he Em acsde ve l ope rs seem to h avewi th  Gui leis  that  itw ill 
give d evelopers  ch o ices  a sto whet her to writeEm acs extens io nsin Sch e m e,
Elisp , or Javascript/Python/ W hatever  el se Gu ilesupports
Idon'tund e rstand  why t hey c ar e?W h y wou l d  t heEm acs develo p e rsfeelth e ne ed
to d ebug compatibility ifsomeone elsewro te a s hi tty ex t ens io n ? T h e  onus
would beon the ext en s io n develope r  to  f ix theextensi on.
~ ~~
baba rock
Quot ing the l in kede m ail :

    
   
     So if we go fo r  G uile- Ema cs, we 'l l b e stu ck wit h  Gu ile,i.e. w e' d
     hav e(old and  new) packages that use  Elisp , new  pa ckages th atu se      Sch eme,  maybe yet  ot her  newpac k agesthat us e,s ay,
 which_makes it_as large as a_Common Lisp
implementation._I_would expect_that_code sharing between_Scheme
implementations is more_difficult than between Common_Lisp implementations.

~~~
quotemstr
Keyword argument_support_is in the Emacs core these days, along with the rest
of the CL library.

__ _
__  
  _    _(require 'cl-lib)
_       (cl-defun_foo_(&key a b_c) (list a b c))
    _   (foo :c 3_:b 4 :a_1)

------
tedks
A_lot_of people seem to_be reading this as if Emacs_is choosing between
switching languages to Scheme_(Guile) or Common Lisp.

Switching to Guile DOES_NOT IMPLY switching to Scheme. There_is 0 need for
compatibility layer_or what_have you with Guile.

Guile is_a language-agnostic virtual_machine. It_has an implementation_for
Scheme, but also one for Emacs_Lisp. Guile already_runs Emacs Lisp faster than
Emacs: [https://lists.gnu.org/archive/html/emacs-
devel/2010-04/msg00...](https://lists.gnu.org/archive/html/emacs-
devel/2010-04/msg00665.html)

The_main_issue the Emacs_developers_seem_to have_with Guile is_that_it will
give_developers_choices as to whether to write_Emacs_extensions in Scheme,
Elisp, or Javascript/Python/Whatever else Guile_supports.

~~~
rthomas6
>The main issue the_Emacs_developers seem to have_with Guile is that it_will
give developers choices as to whether_to write_Emacs extensions_in Scheme,
Elisp, or Javascript/Python/Whatever else Guile supports

I don't understand why they_care? Why would the Emacs developers_feel the need
to debug_compatibility if_someone_else wrote a_shitty_extension? The_onus
would be on the extension developer to_fix the_extension.

~~~
babarock
Quoting the linked email:

  _ 
  __
     _So if we go for Guile-Emacs,_we'll be stuck with Guile,_i.e._we'd
_    _have (old and new) packages that_use Elisp, new_packages that use
    __Scheme, maybe yet other new packages_that_use, say,