Solutions to the Exercises of Episode 8

1. We've shown how to implement keyed variable access for arrays, by implementing the action method for index. The same principle can be applied to keyed access for hashtables. Implement the action method for key.

method key($/) {
my $key := $( $<expression> );

make PAST::Var.new( $key, :scope('keyed'),
                         :vivibase('Hash'),
                         :viviself('Undef'),
                         :node($/) );
}

2. Implement the action methods for array_constructor and hash_constructor. Use a PAST::Op node and set the pasttype to 'call'. Use the "name" attribute to specify the names of the subs to be invoked (e.g., :name("!array") ). Note that all hash fields must be passed as named arguments. Check out PDD26 for doing this, and look for a "named " method.

method named_field($/) {
    my $past := $( $<expression> );
    my $name := $( $<string_constant> );
    ## the passed expression is in fact a named argument,
    ## use the named() accessor to set that name.
    $past.named($name);
    make $past;
}

method array_constructor($/) {
    ## use the parrot calling conventions to 
    ## create an array, 
    ## using the "anonymous" sub !array 
    ## (which is not a valid Squaak name)
    my $past := PAST::Op.new( :name('!array'), 
                              :pasttype('call'), 
                              :node($/) );
    for $<expression> {
        $past.push($($_));
    }
    make $past;
}

method hash_constructor($/) {
    ## use the parrot calling conventions to 
    ## create a hash, using the "anonymous" sub 
    ## !hash (which is not a valid Squaak name)
    my $past := PAST::Op.new( :name('!hash'), 
                              :pasttype('call'), 
                              :node($/) );
    for $<named_field> {
        $past.push($($_));
    }
    make $past;
}

3. We'd like to add a little bit of syntactic sugar for accessing hashtable keys. Instead of writing foo{"key"}, I'd like to write foo.key. Of course, this only works for keys that do not contain spaces and such. Add the appropriate grammar rule (call it "member") that enables this syntax, and write the associated action method. Make sure this member name is converted to a string.
Hint: use a PAST::Val node for the string conversion.

rule postfix_expression {
| <key> {*}         #= key
| <member> {*}      #= member
| <index> {*}       #= index
}

rule member {
'.' <identifier>
{*}
}

method member($/) {
my $member := $( $<identifier> );
## x.y is syntactic sugar for x{"y"},
## so stringify the identifier:
my $key    := PAST::Val.new( :returns('String'),
                            :value($member.name()),
                            :node($/) );

## the rest of this method is the same
## as method key() above.
make PAST::Var.new( $key, :scope('keyed'),
                         :vivibase('Hash'),
                         :viviself('Undef'),
                         :node($/) );
}