Pigeon Overview

"Python with Lisp macros"

"Scheme meets Smalltalk, with a C accent"

"The vocabulary of a pidgin comes mainly from one particular language (called the 'lexifier'). The early 'pre-pidgin' is quite restricted in use and variable in structure. But the later 'stable pidgin' develops its own grammatical rules which are quite different from those of the lexifier."

Features

• Designed for smart programmers who want to do powerful things. Rather than forcing you into a particular way of working, Pigeon aims to expose underlying mechanisms so you can do things the way you want.
• Designed to be extended. Almost all aspects of the language can be rewritten within Pigeon itself: in fact most of the standard syntax is implemented this way! Nothing is sacred: if it is there, you can make your own ones like it.
• Functional programming. Higher order functions, lexical closures, tail recursion, etc. Concise, non-scary lambda syntax. Many control constructs are merely functions that take other functions as parameters.
• Object oriented programming. Everything is an object, and user defined types look exactly like the built in types. You can overload operators, or define new operators from scratch. You can even define whole new object systems if you want to change fundamental things like the inheritance and message dispatch behaviour.
• As dynamic as possible. Not only are variables dynamically typed, but functions and classes can be redefined at any point. The call chain is visible to your code, so if you don't want to return directly to the caller function, you can go somewhere else instead. This makes it easy to implement non-local returns, generators, coroutines, and exceptions.
• The tokenizer and parser are written in Pigeon itself, and can be changed at will. The resulting parse tree can then be manipulated by macro functions before it is passed to the bytecode compiler. The effect can be as simple or complicated as you want to make it: anywhere from a simple substitution macro to a frontend implementing an entirely new language.
• Full garbage collection. Circular references are not a problem.
• Easy to embed. The interpreter runs as a self contained instance, and can be stripped down for use in constrained environments, so you only have to include the features you are actually using.

Influences

• Internally, Pigeon is an object oriented dialect of Lisp. The external syntax may look very different (infix expressions, fewer parentheses), but this is handled entirely by the parser. The underlying language, which is output by the parser, processed by the macro layer, and input to the bytecode compiler, is pure Lisp. If you like parentheses (or are writing the parser, in which case you have a bootstrapping problem because the parser is obviously not yet available to provide any alternative syntax), you can write s-expression code directly:

  (def (addn
    (lambda (n)
      (lambda (x) (add: x n)))))
  (def (inc (addn 1)))
  (print (inc 1))
  

• The object system and lambda (block) syntax are based on Smalltalk. You can write things like:

  data := [ 1 2 23 42 ]
  data.each { :n stdout.print n.tostring }
  

  Which parses into the s-expression:

  (def (data (list 1 2 23 42)))
  (each: data (lambda (n) (print: stdout (tostring: n))))
  

  These examples may seem quite alien if you don't know Lisp or Smalltalk, but don't worry! Tim toady and all that.
• I was brought up speaking C, so tend to lean that way unless there are specific reasons to the contrary. The underlying nature of Pigeon is very different to C or C++, but that is the cultural bias behind it.
• There are bits of Python, Lua, Perl, and Ruby lurking around, too.

Up: Homepage