Re: Perl, etc has these "?"-prefix modifiers/codes/whatever. Precisely which does emacs have (and NOT have)?

[John Withers]

On Thu, 2010-02-18 at 12:46 +0100, Pascal J. Bourguignon wrote:
> dkcombs@panix.com (David Combs) writes:
> 
> > Subj:  Perl, etc has these "?"-prefix modifiers/codes/whatever.  
> >        Precisely which does emacs have (and NOT have)?
> >
> >
> > Please, someone, make an ascii or html table or even plain text 
> > list of all these neat "new" non-standard ops that perl and
> > even php and ruby etc seem to have now, comparing them
> > to what Emacs has or don't have.
> 
> emacs lisp has a lot of data types.  But in lisp, the types are not
> associated to the variables, but to the values.  Therefore names
> (symbols are used to name things in general in lisp) don't need to be
> marked in any special way.

No, what he wants is for someone to go through and make a list of all
the perl lookahead/behind assertions for regular expressions, even
though the data is very easily found with a single google search and
comes down to pretty much if it has a (?<symbol> then emacs doesn't have
it, because the regexes in emacs haven't been touched since the
neolithic.

And finally he is looking for a code patch or pointers to where to look
for something like this patch you can find with a simple google search:
http://emacsbugs.donarmstrong.com/cgi/bugreport.cgi?msg=1;bug=5393

And while I am more than happy to take digs at the lack of basic google
searches and lazyweb requests, I do get the sentiment. At this point the
entire rest of the world has moved on to perl-style regular expressions
a good decade ago, and unlike many things about the world moving in a
different direction than emacs, in this case they have more
functionality. Lookahead and lookbehind assertions are useful. 



> In lisps where there is both lexical bindings and dynamic bindings, such
> as Common Lisp, there's a convention to distinguish dynamic variable
> from lexical variables:
> 
>     - Dynamic variables are surrounded by stars:    *variable*
> 
>     - Lexical variables are surrounded by nothing:   variable
> 
> in addition:
> 
>     - Constant variables are surrounded by pluses:  +variable+
> 
> But in emacs lisp, there is only dynamic binding, so this convention is
> not applied by emacs lisp programmers in general (but Common Lisp
> programmers writing emacs lisp code tend to use it, so you may see it
> applied for *global-variables* vs. local-variables).
> 
> 
> Finally, in lisp, a name may have several meanings.  We distinguish
> often the variable and the function meanings, and call lisps that
> distinguish them "lisp-2", while lisps that don't (eg. scheme or LeLisp)
> are called "lisp-1".  But there are a lot of other meanings a name may
> take.  For example, in emacs lisp, a same name may be used to variable,
> a function, a tagbody tag, a catch tag (catch also takes other objects),
> a block name, etc. And moreover, as a programmer, you can add new
> meanings to a name by writing new functions and macros (so the
> classifications should really be "lisp-infinity+1" vs. "lisp-infinity").
> 
> Anyways, the distinction of meaning of a name in lisp is not done by the
> form of the name, but by the context in which it is found.
> 
> For example, in a function call, a name in first position is interpreted
> as a function name, while the same name in the other position would be
> interpreted as a variable name. In the case of a block name, the first
> argument (second position in the block form) is interpreted as a block
> name.
> 
> (defun f (f) (1+ f))
> (let ((f 41)) 
>    (block f
>      (return-from f (f f))))  ; On this line, first f is a block name, 
>             ; second f is a function name, third f is a variable name.
> --> 42
> 
> 
> 
> 
> Here is an non-exclusive example of the various meaning the name haha
> may be attached to in lisp:
> 
> (require 'cl)
>                    
> (defmacro show (&rest exprs)
>   `(progn
>      ,@(mapcar (lambda (expr) `(insert (format "%60s = %S\n" ',expr ,expr))) 
> exprs)))
> 
> 
> (defvar haha 0)
> (defun haha () 1)
> (progn
>   (let ((haha 3)) 
>     (flet ((haha () 4))
>       (block haha
>         (catch 'haha
>           (tagbody
>              (if (zerop haha) (go haha))
>              (print '(it was not zero))
>              (show haha (symbol-value 'haha) 
>                    (haha) (funcall (function haha)) (funcall 'haha))
>              (throw 'haha nil)
>            haha
>              (print '(it was  zero))
>              (show haha (symbol-value 'haha)
>                    (haha) (funcall (function haha)) (funcall 'haha))
>              (return-from haha t))))))
>   (show haha (symbol-value 'haha)
>         (haha) (funcall (function haha)) (funcall 'haha)))
> 
> (it was not zero)
>                                                         haha = 3
>                                  (symbol-value (quote haha)) = 3
>                                                       (haha) = 4
>                                    (funcall (function haha)) = 4
>                                       (funcall (quote haha)) = 4
>                                                         haha = 0
>                                  (symbol-value (quote haha)) = 0
>                                                       (haha) = 1
>                                    (funcall (function haha)) = 1
>                                       (funcall (quote haha)) = 1
> 
> 
> 
> (In Common Lisp, output would be different, because it as lexical
> bindings as an additionnal meaning for names:
> 
> (IT WAS NOT ZERO) 
>                                                         HAHA = 3
>                                         (SYMBOL-VALUE 'HAHA) = 3
>                                                       (HAHA) = 4
>                                             (FUNCALL #'HAHA) = 4
>                                              (FUNCALL 'HAHA) = 1
>                                                         HAHA = 0
>                                         (SYMBOL-VALUE 'HAHA) = 0
>                                                       (HAHA) = 1
>                                             (FUNCALL #'HAHA) = 1
>                                              (FUNCALL 'HAHA) = 1
> )
> 
>  
>