Python syntax in Lisp and Scheme

Discussion in 'Python' started by mike420, Oct 3, 2003.

  1. mike420

    mike420 Guest

    I think everyone who used Python will agree that its syntax is
    the best thing going for it. It is very readable and easy
    for everyone to learn. But, Python does not a have very good
    macro capabilities, unfortunately. I'd like to know if it may
    be possible to add a powerful macro system to Python, while
    keeping its amazing syntax, and if it could be possible to
    add Pythonistic syntax to Lisp or Scheme, while keeping all
    of the functionality and convenience. If the answer is yes,
    would many Python programmers switch to Lisp or Scheme if
    they were offered identation-based syntax?
     
    mike420, Oct 3, 2003
    #1
    1. Advertisements

  2. mike420

    Paul Rubin Guest

    I don't think the syntax is that big a deal. But programming in lisp
    or scheme has a creaky feeling these days, because the traditional
    runtime libraries in those languages have fallen so far behind the
    times.
     
    Paul Rubin, Oct 3, 2003
    #2
    1. Advertisements

  3. mike420

    Dominic Guest

    Well, there's always a programming language which has
    more features than another. However documentation,
    libraries, software-engineering tools and developer
    community have also to be accounted for.

    So whenever a special features is deemed necessary
    but not available in the language I suggest to use
    code generators.

    E.g. you cannot express grammars in C/Java for
    parsing so usually you stick to yacc/bison/flex/cups etc.

    In C++ BOOST provides capabilites to express a parser
    by means of template metaprogramming but compile times
    are huge. In my opinion are old fashioned parser
    generators more transparent.
    So it's probably not worth the trouble.

    I have successfuly implemented a simple code generator
    for real-time control applications in Python
    which outputs C-source.
    http://www-user.rhrk.uni-kl.de/~hillbr/public/

    Today I'd suggest to use XML-files to describe
    the problem and generate source code from it.
    Source code needed for assembling the final
    result could also be embedded into the XML-files.

    Eclipse uses a kind of JSP to generate code
    from templates. (Examples exist
    for generating source code for enumerations
    which are not yet supported by Java)
    However it's still very primitive.
    At the rapid pace at which Eclipse
    is developed I am curious what way it is going to take.


    Ciao,
    Dominic
     
    Dominic, Oct 3, 2003
    #3
  4. mike420

    Oren Tirosh Guest

    Search the comp.lang.python archives for the word "macros" and you will
    find lots and lots of threads discussing this issue over the years. The
    concensus seems to be that macros are neither compatible with the Python
    Way nor necessary for the vast majority of everyday programming tasks.

    Implementing Python-like syntax in LISP or even a full Python
    implementation in LISP would be a worthwhile goal (LPython?). BTW, this
    kind of implementation is one of the relatively few programming tasks
    that can benefit greatly from macros. The Python semantics can be mostly
    done using macros and a preprocessor would translated Python syntax to
    s-expression code that uses those macros.

    Oren
     
    Oren Tirosh, Oct 3, 2003
    #4
  5. I've used Python. I don't agree.
    Yes, you would be able to add macros to Python. No, it isn't anywhere
    as easy as it is with Lisp.

    I imagine you could come up with a readtable hack for reading
    pythonesque syntax in lisp. *shudder*
     
    prunesquallor, Oct 3, 2003
    #5
  6. napisa³:
    Well, there is Haskell which also offers indentation-base syntax and one
    of it's compilers (GHC) recently added the Template Haskell extension.

    This is a statically typed, non-strict purely functional language with
    higher order and polymorphic functions, algebraic datatypes, etc. so
    it's a BIT different than Python, but it's worth trying :)

    PS. Haskell also allows to use {, } and ; instead of indentation. I
    wonder why Python doesn't.

    Best regards,
    Tom
     
    Tomasz Zielonka, Oct 3, 2003
    #6
  7. napisa³:
    Well, there is Haskell which also offers indentation-based syntax and one
    of its compilers (GHC) recently added the Template Haskell extension.

    This is a statically typed, non-strict, purely functional language with
    higher order and polymorphic functions, algebraic datatypes,
    type-classes base overloading, etc. so it's a BIT different than Python,
    but it's worth trying IMO.
    :)

    PS. Haskell also allows to use {, } and ; instead of indentation. I
    wonder why Python doesn't.

    Best regards,
    Tom
     
    Tomasz Zielonka, Oct 3, 2003
    #7
  8. napisa³:
    Well, there is Haskell which also offers indentation-based syntax and
    one
    of its compilers (GHC) recently added the Template Haskell extension.

    This is a statically typed, non-strict, purely functional language with
    higher order and polymorphic functions, algebraic datatypes,
    type-class based overloading, etc. so it's a BIT different than Python,
    but it's worth trying IMO :)

    PS. Haskell also allows to use {, } and ; instead of indentation. I
    wonder why Python doesn't.

    Best regards,
    Tom
     
    Tomasz Zielonka, Oct 3, 2003
    #8
  9. I've used Python rather a lot, and I don't agree with this, FWIW.
    http://groups.google.com/groups?as_umsgid=

    Jeremy.
     
    Jeremy Yallop, Oct 3, 2003
    #9
  10. A state of the art sophisticated parser? :)))

    You almost got me. I don't know very much about Python and I had to
    check that # is a beginning of a comment.

    Do you know the meaning of 'instead of' ?

    You still have to use indentation, right? You can't write:

    if 1: #{ print 2 #} else: #{ print 3 #}

    instead of

    if 1: #{
    print 2
    #}
    else: #{
    print 3
    #}

    because that would be read as

    if 1:
    Best regards,
    Tom
     
    Tomasz Zielonka, Oct 3, 2003
    #10
  11. mike420

    Mark Brady Guest

    This whole thread is a bad idea. If you like python then use python.
    Personally I find Scheme and Common Lisp easier to read but that's
    just me, I prefer S-exps and there seems to be a rebirth in the Scheme
    and Common Lisp communities at the moment. Ironically this seems to
    have been helped by python. I learned python then got interested in
    it's functional side and ended up learning Scheme and Common Lisp. A
    lot of new Scheme and Common Lisp developers I talk to followed the
    same route. Python is a great language and I still use it for some
    things.

    Paul Rubin's comments are just pure fud.

    Some great scheme implementations with large modern libraries (not yet
    a match for python but growing fast):
    http://www.plt-scheme.org/
    http://www-sop.inria.fr/mimosa/fp/Bigloo/
    http://www.wikipedia.org/wiki/Gauche
    http://sisc.sourceforge.net/
    http://www.scheme.com/

    Common Lisp has a fantastic wiki site (links to implementations and
    loads of libraries) with everything you need to get started at:
    http://www.cliki.net/index

    Also see:
    http://www.lisp.org/alu/home
    http://common-lisp.net
    http://www.cliki.net/YoungLispers

    Many of the latest Scheme and Lisp mailing lists can be browsed from:
    http://news.gmane.org/index.php?match=gmane.lisp

    Develop in the language that suits you but despite the fud you do have
    a choice,
    Python, Scheme and Common Lisp are all fine languages with good
    libraries and FFI capabilities.

    Regards,
    Mark.
     
    Mark Brady, Oct 3, 2003
    #11
  12. mike420

    Matthias Guest

    I think that's incorrect: The Common Lisp language has no FFI (foreign
    function call) capabilities. Each CL _implementation_ has one (which
    is usually compatible to itself). This is exactly the reason why
    there are way more libraries out there for Python, Perl, maybe Ruby
    than for any single CL implementation. The same probably holds for
    Scheme.
     
    Matthias, Oct 3, 2003
    #12
  13. It's be interesting to know where people got the idea of learning
    Scheme/LISP from (apart from compulsory university courses)? I think
    that for me, it was the LPC language used in LPmuds. It had a
    frightening feature called lambda closures, and useful functions such
    as map and filter. Then one day I just decided to bite the bullet and
    find out where the heck all that stuff came from (my background was
    strongly in C-like languages at that point. LPC is like C with some
    object-oriented and some FP features.)

    Yes, I know, there's nothing frightening in lambda closures. But the
    way they were implemented in LPC (actually just the syntax) was
    terrible :)
     
    Toni Nikkanen, Oct 3, 2003
    #13
  14. You can surely hack a "pre-processor" on top of the Python
    interpreter. With the Python 2.3 architecture of import
    hooks, it might even be quite feasible to experiment with
    this idea as a pure Python package and distribute it as such:
    just add a hook that scans incoming source files (modules)
    for definitions and/or occurrences of the 'macros' you want,
    and (respectively) squirrels away the definitions, and/or
    expands the macros. As for designing the syntax for macro
    definitions and expansions while remaining 'amazing', I'll
    pass -- but surely it's not beyond human possibilities;-).

    Anyway, see later in this post for a toy-level example.

    If you could make all of the existing Python extensions,
    libraries, frameworks, etc, instantly available from Lisp or
    Scheme, you'd gain a LOT of kudos in the Lisp or Scheme
    community, I suspect. That most existing Python coders
    would be happy to leave the semantic simplicity of their
    chosen language for the richness of Common Lisp, I very,
    very strongly doubt, but in any case until the whole array
    of existing extensions &c is available it's not an issue;-).


    So, anyway, here's the promised toy-level example of using
    custom importers with the new Python 2.3 mechanics to get
    macros. I'm cutting corners to the bone (just to mix a
    couple metaphors...) by using the C preprocessor (!) as my
    "macro expander", ignoring packages, _and_ only looking for
    "C-macro" definitions AND expansions in files with extension
    ".pyp" (all others, I'll leave alone...). Oh, also, I do
    not worry about saving bytecode for such files -- I'm gonna
    preprocess and recompile them on every run of the program
    (far too much trouble, when macros exist, to determine
    whether a bytecode file is up to date -- one should check
    it, not only with respect to the date of ONE source file,
    but rather of a hard-to-pin-down collection of macro and
    include files... so, in the spirit of cutting corners and
    keeping this a VERY toy-level example, I'm punting:). So,
    here's the gist...:


    import sys
    import os
    import imp

    prepro = 'cat %s | gcc -E -'

    class MacroImporter(object):

    def __init__(self, path):
    self.path = path

    def find_module(self, modname):
    look_for_file = os.path.join(self.path, modname+'.pyp')
    self.code = os.popen(prepro % look_for_file).read()
    if self.code: return self
    else: return None

    def load_module(self, modname):
    mod = imp.new_module(modname)
    sys.modules[modname] = mod
    mod.__file__ = "<Macro-Expanded %s>" % modname
    exec self.code in mod.__dict__
    return mod

    sys.path_hooks.append(MacroImporter)

    example = open('pippo.pyp', 'w')
    example.write('''
    #define unless(cond) if not(cond)
    def pippo(x):
    print 'x is', x
    unless(x>=2): print ' x is smaller than two'
    unless(x<=4): print ' x is bigger than four'
    ''')
    example.close()

    import pippo
    pippo.pippo(1)
    pippo.pippo(7)


    Removing the various oversimplifications, and, in particular, designing
    a better macro scheme than gcc -E supplies, is left as a trivial exercise
    for the reader (I have in fact devised a perfect scheme, of course, but,
    unfortunately, the margins of this post are too narrow for me to write it
    down...).


    Alex
     
    Alex Martelli, Oct 3, 2003
    #14
  15. mike420

    Paul Foley Guest

    Paul Foley, Oct 3, 2003
    #15
  16. mike420

    Kenny Tilton Guest

    <g> We wonder alike. That's why I started:

    http://alu.cliki.net/The Road to Lisp Survey

    That recently got repotted from another cliki and it's a little mangled,
    but until after ILC2003 I am a little too swamped to clean it up. But
    there is still a lot of good stuff in there. On this page I grouped
    folks according to different routes to Lisp (in the broadest sense of
    that term): http://alu.cliki.net/The RtLS by Road

    You will find some old-timers because I made the survey super-inclusive,
    but my real interest was the same as yours: where are the New Lispniks
    coming from?

    Speaking of which, Mark Brady cited Python as a stepping-stone, and I
    have been thinking that might happen, but the survey has yet to confirm.
    Here's one: http://alu.cliki.net/Robbie Sedgewick's Road to Lisp

    So Ping! Mark Brady, please hie ye (and all the others who followed the
    same road to Lisp) to the survey and correct the record.

    I think
    You could cut and paste that into the survey as well. :)

    kenny
     
    Kenny Tilton, Oct 3, 2003
    #16
  17. mike420

    Terry Reedy Guest

    I could agree that the OP's suggestion is a bad idea but do you
    actually think that discussion and more publicity here for Lisp/Scheme
    is bad? You make a pretty good pitch below for more Python=>Lisp
    converts.
    As I plan to do.
    Other Lispers posting here have gone to pains to state that Scheme is
    not a dialect of Lisp but a separate Lisp-like language. Could you
    give a short listing of the current main differences (S vs. CL)? If I
    were to decide to expand my knowledge be exploring the current
    versions of one(I've read the original SICP and LISP books), on what
    basis might I make a choice?

    Terry J. Reedy
     
    Terry Reedy, Oct 3, 2003
    #17
  18. It usually happens that when I google for some scheme/lisp-isms,
    I get lots of Python mailing list messages as results. There's
    something going on with that.
     
    Toni Nikkanen, Oct 3, 2003
    #18
  19. mike420

    Kenny Tilton Guest

    Me and my big mouth. Now that I have adevrtised the survey far and wide,
    and revisited it and seen up close the storm damage, sh*t, there goes
    the morning. :) Well, I needed a break from RoboCells:

    http://sourceforge.net/projects/robocells/

    I am going to do what I can to fix up at least the road categorization,
    and a quick glance revealed some great new entries, two that belong in
    my Top Ten (with apologies to those getting bumped).

    kenny
     
    Kenny Tilton, Oct 3, 2003
    #19
  20. Funny. Yesterday i downloaded the trial version of Franz Lisp (Allegro
    CL).
    I can'T say if the runtime libraries are out of date because there is
    absolute no documentation for the runtime libraries - of course they
    also bundle the ANSI-Common Lisp book.

    I found that they still want to sell every fucking line of code in an
    extra library raising the price to an unexceptable high value.
     
    Lothar Scholz, Oct 3, 2003
    #20
    1. Advertisements

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments (here). After that, you can post your question and our members will help you out.