HaloO,

Larry Wall wrote:
Yes.  The only thing I don't like about it is that any() isn't an Any.
Maybe we should rename Any to Atom.  Then maybe swap Item with Atom,
since in colloquial English you can say "that pair of people are
an item."


Since we are in type hierachies these days, here's my from ::Any
towards ::All version. The "bottom" part where everything finds
together is missing for this installment.

                 ::Any
...............     |     ..........................
       _______:_____|_____:________    static type :
      |       :     |     :  |     |     = context :
   Package    :     |     : Void  Bool             :
      |       :     |     :.........................
    Module    :     |
   ___|___    :     |
  |       |   :     |
Class Grammar :     |
  |_______|   :     |
      |       :     |
     Role     :   Object
              :     |____________________________
              :     |         |        |         |
              :   &Code     @Array   %Hash     $Item
              :     |         /        /         |
  with        :     |       Tuple    Record      |
  invocant(s) :     |                            |
          ____:____/ \______   __________________|_________________
         |    :  |     |    \ /          |    |     |      |       |
      .Method : Sub  Block   |           |   Inf  Undef  Match  Junction
        /|    :  |\          |           |
       / |    :  | \        Ref[Code]    |
   Rule  |    :  |  Macro                |
         |____:_/|            __________/|\____
         |    :  |           |     |     |     |
       Multi  :  |         ~Str  +Num  \Ref  :Pair
..............:  |           |     |     |\    |
                 |           |    Int    | \   |
     ___________/|           | ____|____ |  Entry[::T where T.does(Hash)]
    |     |      |           |/    |    \|
  *List  Pipe =Iterator     Enum ?Bit  Pos[::T where T.does(Str|Array)]
    |\___________
    |      |     |
 **Eager  Lazy  Ref[Array|Hash]


any() == lub( all ---> any ) == glb( any --> all )   lesser --> greater
all() == glb( all ---> any ) == lub( any --> all )

Some operators and prefixes are added in to show their
relation to the corresponding type. I hope it looks familiar.

Here is some pseudo code that describes a bare minimum data layout
required to support the respective types.

type Item[::T]
{
  has $.value of T;
}

type Pair[::T]
{
  has $.key;
  has $.value of T;
}

type Tuple[::T where T does lub( @.values )]  # lub = least upper bound
{
  has @.values of T;
  has $.value ::= @.values; # auto-enreference for Item subtyping
  has T $.head ::= @.values[0];
  has T $.tail ::= @.values[-1];
}

type Record[::T where T does lub( @.values )]
{
  has @.keys;
  has @.values of Pair[T];
  has @.pairs ::= { zip @.keys, @.values };
  has $.value ::= @.pairs;
}

type Code
{
  has %.MY;    # lexical scratchpad
  has &.block;
  has $.value ::= { use %.MY; &.block() }; # coderef literal
}

type Junction[::T where enum <any all one none>]
{
  has @.values;
  has Junction $.value ::= { @.values as Junction[T] };
  has &.evaluate ::= &::JUNCTION_MAGIC; # what's the exact type of this?
}
--
$TSa.greeting := "HaloO"; # mind the echo!

Reply via email to