content: COMPUNIT = module Main {
      sub MAIN {
          say 1;
      }
  }
  
  my $x ::= 1;
  
  data Value
      = VConstant  Unboxed     -- 1
      | VObject    Object      -- Foo.new(...)
      | VForeign   Foreign     -- perl5:DBI.connect()
      | VCode      Code        -- {...}
      | VType      Type        -- ::CGI
      | VCapture   Capture     -- \(...)
      | VSignature Signature   -- :(...)
  
  package Main;
  
  sub f (constant $x = 1) { ... }
  
  f(); # $x retains last value
  
  submethod BUILD (has $x) { ... }
  submethod BUILD ($.x) { ... }
  $Main::x
  
  
  positional named named_slurpy
  
  method f (Moose $self where {...}: ...)
  
  
  (@a [$x, $y, *@rest [*, *, *, $z]]  ) := [1,2,3]
  
  
  sub f (:v($verbose), :$verbose, :$v) {
      say $verbose;
  }
  
  f(v=>1);
  f(verbose=>1);
  
  
  
  Any $self (\)
  
  sub f ($x, $x, $x) { }
  
  method f ($x, $y) {}
  
  data Param = MkParam
      { paramVariable     :: Identifier
      , paramTypes        :: [Type]       -- Static pieces of inferencer-food
      , paramConstraints  :: [Code]       -- Dynamic pieces of runtime-mood
      , paramUnpacking    :: Maybe Signature
      , paramDefault      :: Maybe Expression
      , paramLabel        :: Identifier
      }
  
  data Variable
      = VarLexical
          { varName     :: Identifier
          , callerCount :: Int
          , outerCount  :: Int
          }
      | VarDynamic
          { varName     :: Identifier
          , packageName :: [Identifier]
          }
      | VarMagic Magic
  
  data Expression
      = ExpVariable Variable
      | ExpValue    Value
      | ExpDeref    Variable
      | ExpBind     Expression Expression
      | ExpAssign   Expression Expression
      | ExpControl  Control
  
  data Control
      = ContCall                           -- lookup a routine, call it
      | ContApply                          -- apply a Code immediately
      | ContCond                           -- statement_control:<if>
      | ContGoto                           -- statement_control:<goto>
      | ContWhile                          -- statement_control:<while>
      | ContForeign                        -- statement_control:<mycontrol>
  
  data Statement = MkStatment
      { label      :: Identifier
      , pragmas    :: Map Identifier Value
      , expression :: Expression
      }
  
  
  
  
  --if 1 { 2 } else { 3 }
  &statement_control:<if>.(1,2,3)
  
  %h<1>
  
  
  
      &statement_control<if>.wrap(...)
      &statement_control<if> <== ...
  
  
  data Magic
      = MagicOS            -- $?OS        Which os am I compiled for?
      | MagicOSVer         -- $?OSVER     Which os version am I compiled for?
      | MagicPerlVer       -- $?PERLVER   Which Perl version am I compiled for?
      | MagicFile          -- $?FILE      Which file am I in?
      | MagicLine          -- $?LINE      Which line am I at?
      | MagicScalarPackage -- $?PACKAGE   Which package am I in?
      | MagicArrayPackages -- @?PACKAGE   Which packages am I in?
      | MagicScalarModule  -- $?MODULE    Which module am I in?
      | MagicArrayModules  -- @?MODULE    Which modules am I in?
      | MagicScalarClass   -- $?CLASS     Which class am I in? (as variable)
      | MagicArrayClasses  -- @?CLASS     Which classes am I in?
      | MagicScalarRole    -- $?ROLE      Which role am I in? (as variable)
      | MagicArrayRoles    -- @?ROLE      Which roles am I in?
      | MagicScalarGrammar -- $?GRAMMAR   Which grammar am I in?
      | MagicArrayGrammars -- @?GRAMMAR   Which grammars am I in?
      | MagicParser        -- $?PARSER    Which Perl grammar was used to parse this statement?
      | MagicScalarRoutine -- &?ROUTINE   Which routine am I in?
      | MagicArrayRoutines -- @?ROUTINE   Which routines am I in?
      | MagicScalarBlock   -- &?BLOCK     Which block am I in?
      | MagicArrayBlocks   -- @?BLOCK     Which blocks am I in?
  
  
  data Signature
      = MkSignatureMethSingle
          { invocant                  :: Param
          , requiredPositionalCount   :: Int
          , requiredNames             :: Set Identifier
          , positionalList            :: [Param]
          , namedSet                  :: Map Identifier Param
          , slurpyScalarList          :: [Param]
          , slurpyArray               :: Maybe Param
          , slurpyHash                :: Maybe Param
          , slurpyCode                :: Maybe Param
          }
      | MkSignatureSubSingle
          { requiredPositionalCount   :: Int
          , requiredNames             :: Set Identifier
          , positionalList            :: [Param]
          , namedSet                  :: Map Identifier Param
          , slurpyScalarList          :: [Param]
          , slurpyArray               :: Maybe Param
          , slurpyHash                :: Maybe Param
          , slurpyCode                :: Maybe Param
          }
  
  data Code
      = MkSingle SingleCode
      | MkMulti (Set MultiVariant)
  
  data SingleCode = MkSingleCode
      { signature  :: Signature
      , body       :: [Statement]
      , pad        :: Map Identifier PadEntry
      , attributes :: Map Identifier Value
      }
      
  
  data MultiVariant = MkMultiVariant 
      { semicolonOffsets          :: IntSet
      , theThingYouActuallyCall   :: SingleCode
      }
  
  
  my multi g () { ... }
  {
      my multi f ($x) { ... }
      my multi f ($x, $y) { ... }
      &g.variants.push(&f);
  }
  
  (IntSet, Code)) -- Map from full long names to Code
                       -- {2,3,4}
                       -- ^ The cursors, think of the ncurses (n. slang)!
                       -- $pun, $gun; $way; $too; $far
  
  multi f (Int $x; Int $y) {...}
  multi f (Int $x) {...}
  
  data PadEntry
      = MkEntry StorageType (TVar Value)
  
  data Unboxed
      = UInt Int      -- 3
      | UNum Num      -- 4.2
      | UStr Str      -- 'aloha'
      | UBit Bit      -- True
  
  type ObjectId = Unboxed
  
  data Object = MkObject
      { objectId :: ObjectId
      , metaId   :: ObjectId
      , slots    :: Map Identifier Value
      }
  
  data Capture
      = MkCaptureMeth
          { invocant :: Expression
          , argstack :: [Arglist]
          }
      | MkCaptureSub
          { argstack :: [Arglist]
          }
  
  data Capture = MkCapture
      { invocant :: Maybe Expression
      , argstack :: [Arglist]
      }
  
  data Arglist = MkArglist
      { positional :: [Exp]
      , named      :: Map Str [Expression]
      }
  
  
  $x = 'moose';
  $x = $x ~ 'elk';
  
  class ClassyExample does Scalar {
      STORE
      FETCH
  }
  
      scalar_store(castMut(Object(meta=ClassyExample,slots={})), castV(Str('moose')))
  
  my $y is ClassyExample;
  $y = "moose"; # now with style!
  
  
  data Val
      = Pure VPure
      | Mut VMut
      | IO VIO
  
  
  data VIO
      = VISocket Socket
  
  data VMut
      = VMScalar (TVar Val)
  
  data VPure
      = VPInt Int
  
  instance ScalarClass a where
      doScalarFetch :: a -> Eval Val
      doScalarStore :: a -> Eval Val
  
  $x = @a;
  
  scalar_fetch :: Val -> Eval Val
  scalar_fetch v@Pure{} = return v
  scalar_fetch v@(Mut m) = case m of
      VMScalar s  -> doScalarFetch s
      VMArray{}   -> v
      _           -> fail ""
  
  instance ScalarClass (TVar Val) where
      -- vivify?
      doScalarFetch t = do
          lv <- asks envLValue
          case lv of
              RValue -> liftSTM (readTVar t)
              LValue typ -> do
                  rv <- readTVar t
                  case rv of
                      Pure VPUndef -> do
                          writeTVar t =<< fmap Mut (newLValue typ)
                      _ -> return rv
  
  # This is a mutable capture and totally offtopic
  my $x = Match(blah => 2);
  $x[1] = 2;
  
  