.ooo
          'OOOo
      ~ p ooOOOo tion ~
          .OOO
           oO      %% a little
             Oo    fast language.
            'O
             `
            (o)
        ___/ /          
       /`    \ 
      /v^  `  ,
     (...v/v^/
      \../::/
       \/::/ 
  ~ potion ~
  Potion is an object- and mixin-oriented (traits)
  language.
  Its exciting points are:
   * Just-in-time compilation to x86 and x86-64
     machine code function pointers. This means
     she's a speedy one. Who integrates very
     well with C extensions.
     The JIT is turned on by default and is
     considered the primary mode of operation.
   * Intermediate bytecode format and VM. Load
     and dump code. Decent speed and cross-
     architecture. Heavily based on Lua's VM.
   * Bootstrapped "id" object model, based on
     Ian Piumarta's soda languages. This means
     everything in the language, including
     object allocation and interpreter state
     are part of the object model.
     (See COPYING for citations.)
   * Scoped mixins. Basically, you can modify
     object behavior within a scope. So changes
     to core classes can be localized.
     ++ INCOMPLETE ++
   * Interpreter is thread-safe and reentrant.
     I hope this will facilitate coroutines,
     parallel interpreters and sandboxing.
   * Small. Under 10kloc. Right now we're like
     4,000 or something. Install sloccount
     and run: make sloc.
   * Reified AST and bytecode structures. This
     is very important to me. By giving access
     to the parser and compiler, it allows people
     to target other platforms, write code analysis
     tools and even fully bootstrapped VMs. I'm
     not as concerned about the Potion VM being
     fully bootstrapped, especially as it is tied
     into the JIT so closely.
  However, some warnings:
   * Strings are immutable (like Lua) and byte
     arrays are used for I/O buffers.
   * No floating point support yet.
   * No error handling. I'm wary of just tossing
     in exceptions and feeling rather uninspired
     on the matter. Let's hear from you.
   * GC is reference counting. I know, I know,
     but I put my eggs in other baskets. At
     least it's quick.
  ~ a whiff of potion ~
    add = (x, y): x + y.
    add(2, 4) string print
  Or,
    "hello world" print
  Or,
    hello =
      "(x): ('hello ', x) print." eval
    hello ('world')
  ~ building and installing ~
    $ make
  Look inside the file called INSTALL for options.
  ~ how it transpired ~
  This isn't supposed to happen!
  I started playing with Lua's internals and reading
  stuff by Ian Piumarta and Nicolas Cannasse. And I,
  well... I don't know how this happened!
  Turns out making a language is a lovely old time,
  you should try it. If you keep it small, fit the
  VM and the parser and the stdlib all into 10k
  lines, then it's no sweat.
  To be fair, I'd been tinkering with the parser
  for years, though.
  ~ the potion pledge ~
  EVERYTHING IS AN OBJECT.
  However, OBJECTS AREN'T EVERYTHING.
  ~ items to understand ~
  1. A traditional object is a tuple of data
     and methods: (D, M).
     
     D is kept in the object itself.
     M is kept in classes.
  2. In Potion, objects are just D.
  
  3. Every object has an M.
  4. But M can be altered, swapped,
     added to, removed from, whatever.
  5. Objects do not have classes.
     The M is a mixin, a collection
     of methods.
  Example: all strings have a "length"
  method. This method comes with Potion.
  It's in the String mixin.
  6. You can swap out mixins for the span
     of a single source file.
  Example: you could give all strings a
  "backwards" method. But just for the
  code inside your test.pn script.
  7. You can re-mix for the span of a
     single closure.
  To sum up:
  EVERYTHING IS AN OBJECT.
  EVEN MIXINS ARE OBJECTS.
  AND, OF COURSE, CLOSURES ARE OBJECTS.
  However, OBJECTS AREN'T EVERYTHING.
  THEY ARE USELESS WITHOUT MIXINS.
  ~ unique ideas (to be implemented) ~
  Potion does have a few unique features
  underway.
  * It is two languages in one.
    The language itself is objects and closures.
      Number add = (x): self + x.
    But it also includes a data language.
     ### EXAMPLE REMOVED
     ... the data format is being redesigned
      
    The code and data languages can be interleaved
    over and over again. In a way, I'm trying to find
    a middle ground between s-expressions and stuff like
    E4X. I like that s-expressions are a very light data
    syntax, but I like that E4X clearly looks like data.
    When s-expressions appear in Lisp code, they look
    like code. I think it is nice to distinguish the two.
  * Deeply nested blocks can be closed quickly.
    I don't like significant whitespace, personally.
    But I don't like end end end end.
      say = (phrase):
        10 times (i):
          20 times (j):
            phrase print
      _say
    The closing "_ say" ends the block saved to "say" var.
    Normally, blocks are closed with a period. In this case
    we'd need three periods, which looks strange.
      say = ():
        10 times:
          20 times:
            "Odelay!" print
      ...
    If you prefer, you can give it some space. Or you can
    use a variable name introduced by the block,
      say = (phrase):
        10 times (i):
          20 times (j):
            phrase print
      _ phrase
      say = (phrase):
        10 times (i):
          20 times (j):
            phrase print
        _ i
      .
    Maybe it all looks strange. I don't know. I'm just trying
    things out, okay?
  * Elimination of line noise.
    I avoid @, #, $, %, {}.
    Stick with ., |, (), [], =, !, ?. Easier on the eyes.
    These are common punctuations in English.
  * I try to defer to English when it comes to punctuation rules.
    Period means "end". (In other langs it means "method call".)
    Comma breaks up statements.
    Space between messages gives a noun-verb feeling.
      window open (width=400, height=500)
  * Named block args.
      (1, 2, 3) map (item=x, index=i): i display, x + 1.
  ~ license ~
  See COPYING for legal information. It's an MIT license,
  which lets you do anything you want with this. I'm hoping
  that makes it very nice for folks who want to embed a little
  Potion in their app!