~ readme ~

           .ooo
            'OOOo
        ~ p ooOOOo tion ~
            .OOO
             oO      %% a little
               Oo    fast language.
              'O
               `
              (o)
          ___/ /          
         /`    \ 
        /v^  `  ,
       (...v/v^/
        \../::/
         \/::/ 


  p2 is a she. She is a perl5 and possible perl6/nqp backend, based
  on why the luck stiff's potion. See `README.potion` why potion is exciting.
  Homepage: https://perl11.org/p2/

    parrot example/fib.pir 28  0m1.746s
    perl   example/fib.pl  28  0m0.439s
    p2 -B  example/fib.p2  28  0m0.177s
    potion example/fib.pn  28  0m0.013s
    p2     example/fib.p2  28  0m0.013s
  
    parrot example/fib.pir 40  3m36.447s
    perl   example/fib.pl  40  2m19.752s
    p2 -B  example/fib.p2  40  0m54.560s
    potion example/fib.pn  40  0m3.512s
    p2     example/fib.p2  40  0m3.512s

  For most small examples comparable performance to lua and C.
  For bigger examples optimizable via static types/early binding.

  Its exciting points for perl folks are:

   * Radically simplified and functional core.

   * Should parse most of perl5, just some XS and B tricks not.

   * Signatures, fast mop, types, native threads, call-replacing
     macros for perl5.

   * No worries about pseudo-scientific discussions, project management,
     performance bugs and feature deadlocks. Leaving the slack behind.

   * A lightweight generational GC, based on Basile Starynkevitch's
     work on Qish, with ~4ms per GC on average with < 100MB heaps.
     <https://starynkevitch.net/Basile/qishintro.html>
     The compiler will add hooks for objects leaving scope and add
     DESTROY method calls if they are visible at
     compile-time. Run-time created DESTROY methods will not be
     automatically called.

   * Using most of Damian Conway's p5i recommendations:
     i.e. classes are immutable and final by default.
     See <https://web.archive.org/web/20040207072905/https://www.yetanother.org/damian/Perl5+i/>

   * libp2 is usable as a fast backend for nqp/perl6, but parsing and supporting
     p6 natively without going through nqp and the rakudo bootstrapping process
     should be easier and faster.
     Tokuhiro Matsuno already wrote a p6 parser, pvip.

   * Native and fast calling convention, no XS stack args on the heap.
     XS is replaced by extern (dynamic ffi), and/or shared libraries
     with normal function calls into the vm.

   * Just-in-time compilation for x86, x86-64 and ppc done. arm later.

   * Intermediate bytecode format and VM. Load and dump code.  Decent
     speed and cross-architecture. Heavily based on Lua's VM.

   * int, str, num are objects, you can optionally type all args and
     lexical variables.  In fact everything is an object as in parrot,
     even the parsed AST, the vm state.

   * Sized arrays are non-autovivifying and initialized with undef,
     resp. if typed 0, 0.0, "".

     my $a[3]; print $a[3] => compile-time error: array out of bounds
     my int $i[3]; print $a[2] => 0
     my num $n[3]; print $n[2] => 0.0
     my str $s[3]; print $a[2] => ""
  
   * A new pragma "no magic" applies to all visible objects in scope.
     {
       no magic;
       use Config;
       print $Config{'ccflags'};
     }
     => compile-time error: Invalid use of tie with no magic

     use
     {
       no magic;
       use Config ();
       print $Config::Config{'ccflags'};
     }
     instead.

   * p6model: via scoped mixins, :multi, roles. Like Moose, just better
     and roughly estimated 800x faster.
     No multiple inheritance yet, \@ISA == 1.
     Only one parent, depending on another parent, rather multiple
     mixin compositions.

   * ~~ match works because all data are typed objects.
     A destructuring-bind alike new match operator which matches
     structures (list, trees, hashes of hashes) against structures,
     values and types.

   * Bootstrapped "id" object model, based on Ian Piumarta's soda
     languages.  This means everything in the language, including
     object allocation, parser, compiler and interpreter state are
     part of the object model.  (See COPYING for citations.)
     In fact all objects and classes are closures, which simplifies
     scoping, and makes p2/potion a functional vm.

   * parsers are scoped and