I'd suggest separating parsing from evaluation. The first argument to the action subroutines is a hash that you can use for any purpose. In this case, I'd store parts of the specification in there, then return that hash (which makes the convenient default ::= action => ::first work for the Dice_Expression rule). Also, I split modifier_r_comp from modifier_r action, but you could equally merge them and count the number of arguments.

use Marpa::R2;
use Data::Dump;

my $dsl = <<'END_OF_DSL';

:default ::= action => ::first
lexeme default = latm => 1

Dice_Expression ::= Dice_Expression1
                  | Dice_Expression1 add_modifier

Dice_Expression1 ::= Simple_Dice
                   | Simple_Dice x_modifier
                   | Simple_Dice r_modifier

Simple_Dice  ::= Rolls 'd' Sides                         action => sim
+ple_roll
add_modifier ::= '+' Die_Modifier_Val                    action => mod
+ifier_add
               | '-' Die_Modifier_Val                    action => mod
+ifier_add
x_modifier   ::= 'x' Die_Modifier_Val                    action => mod
+ifier_x
r_modifier   ::= 'r' Die_Modifier_Val                    action => mod
+ifier_r
               | 'r' Die_Modifier_Comp Die_Modifier_Val  action => mod
+ifier_r_comp


Die_Modifier_Val ~ digits
Die_Modifier_Comp ~ 'gt' | 'lt'

Rolls ~ digits
Sides ~ digits

digits ~ [\d]+

:discard ~ whitespace
whitespace ~ [\s]+
END_OF_DSL

my $grammar = Marpa::R2::Scanless::G->new( { source => \$dsl } );
my $input = $ARGV[0] // '6d4x1';
my $parsed = $grammar->parse( \$input, 'My_Actions' );
print "\n\nParsed result: ";dd $parsed;

# print "\n\nFinal result: ";dd evaluate_rolls($parsed);

sub evaluate_rolls {
    my $spec = shift;
    # TODO...
}

sub My_Actions::modifier_add {
    my ( $self, $sign, $val ) = @_;
    $$self{add} = 0 + "$sign$val";
    $self;
}

sub My_Actions::modifier_r {
    my ( $self, undef, $reroll ) = @_;
    $$self{r} = $reroll;
    return $self;
}

sub My_Actions::modifier_r_comp {
    my ( $self, undef, $comp, $reroll ) = @_;
    $$self{comp} = $comp;
    $$self{r} = $reroll;
    return $self;
}

sub My_Actions::simple_roll {
    my ( $self, $rolls, undef, $sides ) = @_;
    $$self{rolls} = $rolls;
    $$self{sides} = $sides;
    return $self;
}

sub My_Actions::modifier_x {
    my ( $self, $modifier, $modifier_val ) = @_;
    $$self{x} = $modifier_val;
    return $self;
}
[download]

Update: Added +/- modifiers

Thanks duelafn,

I really appreciate your code example as it seems to me a good starting point. I really like the use of $self you exploit to add optional terms to the expression. Now prehaps I understand it better.

I still do not fully understand your:

> which makes the convenient default ::= action => ::first work for the Dice_Expression rule

If you have the patience to expand this further it will help me in the understanding the ::first (see also below my answer to GrandFather).

Again about optional sub elements:

So the only way to specify somenthing optional is:

Dice_with_modifier_r ::= Simple_Dice 'r' Die_Modifier_Val action => mo
+difier_r
                        |Simple_Dice 'r' Die_Modifier_Comp Die_Modifie
+r_Val action => modifier_r
[download]

Right? there is no  <Optional> syntax to play with?

I tried a single rule like:

Dice_with_modifier_r ::= Simple_Dice 'r' <Die_Modifier_Comp>* Die_Modifier_Val action => modifier_r

as found at the end of this post but it throws the error:

Parse of BNF/Scanless source failed
Error in SLIF parse: No lexeme found at line 11, column 61
* String before error: modifier_r ::= Simple_Dice 'r' <Die_Modifier_Co
+mp>
* The error was at line 11, column 61, and at character 0x002a '*', ..
+.
* here: * Die_Modifier_Val action => modifier_r\n\n\nSimpl
Marpa::R2 exception at marpa07.pl line 41.
Marpa::R2 exception at marpa07.pl line 41.
[download]

Why on marpa-for-building-parsers there is: declaration ::= assignment* action => doResult

and I cannot do

Dice_with_modifier_r ::= Simple_Dice 'r' Die_Modifier_Comp* Die_Modifi
+er_Val action => modifier_r
Die_Modifier_Comp ~ 'gt' | 'lt'
[download]

L*

There are no rules, there are no thumbs..
Reinvent the wheel, then learn The Wheel; may be one day you reinvent one of THE WHEELS.

Late responding, so you may have some of this figured out, but...

default ::first: First is just a subroutine which returns the result of the first token. That is: sub ::first { return $_[1] }. Thus, Dice_Expression returns whatever Dice_Expression1 returns which returns whatever Simple_Dice returns which happens to be our "$self". After posting, I decided that if I were doing it, I would probably avoid using the default action and instead do something like:

root ::= Dice_Expression     action => finish
Dice_Expression ::= ...
... same as above ...

sub My_Actions::finish {
    my $self = shift;
    # ... additional cleanup or else change whole sub to just return $
+_[0]
    return $self
}
[download]

The advantage being that this is explicit and gives a nice hook for modifying the final result just before returning it.

Optionals For the most part, yes, I spell it out. The "*" syntax has a big limitation: The RHS alternative must consist of a single RHS primary. which means only "NAME ::= ITEM*" rules. You can't have multiple things on the right hand side. So, it would look like:

r_modifier        ::= 'r' Die_Modifier_Comp Die_Modifier_Val   action 
+=> modifier_r_comp
Die_Modifier_Comp ::= Die_Modifier_Comp_Toke*                  action 
+=> ::first
Die_Modifier_Comp_Toke ~ 'gt' | 'lt'
[download]

The star has to move to its own rule by itself (and then we renamed the token rule). Of course, that rule won't do what you want since it doesn't limit the number of "Die_Modifier_Comp_Toke". You could instead, use an empty rule to achieve a 0-or-1 match:

r_modifier        ::= 'r' Die_Modifier_Comp Die_Modifier_Val  action =
+> modifier_r_comp
Die_Modifier_Comp ::= Die_Modifier_Comp_Toke                  action =
+> ::first
                    | None
Die_Modifier_Comp_Toke ~ 'gt' | 'lt'
None ::=
[download]

That seems to work, but requires "None" to be a "::=" rule, a "~" rule throws an error. I'm not sure if that means it is an abuse of syntax to do that or not, but if it works and doesn't seem to slow down the parsing, I'd say go for it. It will leave an undef in the Die_Modifier_Comp slot.

Good Day,
    Dean

If it's regular, regular expressions should do just well. Using a context-free grammar is an overkill.

I don't know what combinations are possible, but I have a feeling there's no nesting involved which would mean you don't need to go context-free.

Dear choroba,

I consider you a friend, but your reply made my laugh :)

let's rephrase it:

> Q: Hey I need some help on the usage of my new electronic drill because its instruction contains too much theory..

> A: Go study quantum mechanics to see if you can use a hammer instead

I looked at the document you linked but I must confess I dont understand nothing of this. I'll bookmark it anyway and maybe one of my friends (a math professor) some day can explain me its meaning.

About overkill tecniques: I dont use a batch file to check hosts in my network because perl is an overkill for such a simple task. I'd use perl because I'm better at this and it is fun!

So I'd like to learn Marpa::R2 and BNF using this dice simultation as playground even if it can be accomplished with easy using simpler techniques (and wait: I have already done it ;) beacause the creativity is feeded by wider horizons if you know many different ways to approach the same problem.

That said thanks for the example you linked in the chat and that I have put at the top of my program as reminders.

L*

There are no rules, there are no thumbs..
Reinvent the wheel, then learn The Wheel; may be one day you reinvent one of THE WHEELS.

You seem to be at least at the level of this brief intro to Marpa, but may be able to find something of interest in it. Perhaps of more interest is Marpa debugging. Both these are articles I contributed to Gabor Szabo's Perl Maven website.

3 - Returned structures

First: sorry for the piecemeal replies. I'm playing with your code and refreshing my Marpa as I go - it's been a while since I played with it.

You are getting a "bogus" array because that is the default action and you haven't specified actions for Dice_Expression ::= .... You can fix it by:

Dice_Expression ::= Simple_Dice  action => ::first
                    |Dice_with_modifier_x  action => ::first
                    |Dice_with_modifier_r  action => ::first
[download]

which will cause just the hash ref to be returned from $grammar->parse(\$input, 'My_Actions'). See the semantics section in the Marpa::R2 documentation.

no sorry GrandFather but a big thanks

Anyway i dont understand your reply. I removed :default ::= action => [name,values] and is this the root cause of the "bogus" array (it makes sense to know which name is passing around but I consider it misleading in the sysnopsis).

I read in the doc you linked:

> The "::first" action indicates that the value of a rule is to be the value of its first child, that is, the value corresponding to the first symbol of the rule's RHS.

But I cannot see how your addition of action => ::first can fix it. Given I removed the :default ::= action I get the same results with or without ::first

Dice_Expression ::= Simple_Dice
            |Dice_with_modifier_x
            |Dice_with_modifier_r

do_simple_roll received: ({}, 4, "d", 6)
        Rolled : 4
        Rolled : 3
        Rolled : 6
        Rolled : 2
do_simple_roll returning: { die_type => "1d6", rolls => [4, 3, 6, 2] }
modifier_r received: ({}, { die_type => "1d6", rolls => [4, 3, 6, 2] }
+, "r", 1)



Dice_Expression ::= Simple_Dice action => ::first 
                    |Dice_with_modifier_x action => ::first
                    |Dice_with_modifier_r action => ::first 

do_simple_roll received: ({}, 4, "d", 6)
        Rolled : 3
        Rolled : 2
        Rolled : 5
        Rolled : 6
do_simple_roll returning: { die_type => "1d6", rolls => [3, 2, 5, 6] }
modifier_r received: ({}, { die_type => "1d6", rolls => [3, 2, 5, 6] }
+, "r", 1)
[download]

L*

There are no rules, there are no thumbs..
Reinvent the wheel, then learn The Wheel; may be one day you reinvent one of THE WHEELS.

Perhaps a full example will help:

use strict;
use warnings;
use Marpa::R2;

my $dsl = <<'END_OF_DSL';
lexeme default = latm => 1
 
Dice_Expression ::= Simple_Dice action => ::first
Simple_Dice ::= Rolls ('d') Sides action => do_simple_roll

Rolls ~ digits
Sides ~ digits
digits ~ [\d]+

:discard ~ whiteSpace
whiteSpace ~ [\s]+
END_OF_DSL
 
 
package Actions;

sub do_simple_roll {
    my (undef, $rolls, $sides) = @_;
    my @res = map {1 + int(rand($sides))} 1 .. $rolls;
    
    return \@res;
}

package main;

my $grammar = Marpa::R2::Scanless::G->new({ source => \$dsl});
my $input = '2d6';
my $rolls = $grammar->parse(\$input, 'Actions');
    
print "Result: @$$rolls\n";
[download]

Note the :default ::= action => ::first. Actually we can omit the default line altogether and then change the Dice_Expression line to:

Dice_Expression ::= Simple_Dice action => ::first
[download]

with the same result. The action determines what is passed up to the next level. If there is no action and no explicit default action undef is passed back up (although that isn't what the documentation seems to say). The default action is used where there is no explicit action. Perhaps the key thing to understand is that the called sub gets a parameter in its argument list for each RHS primary (see RHS alternatives) unless the primary is hidden. RHS values are either constant strings or the LHS for a G1 rule, or a L0 symbol.

Optimising for fewest key strokes only makes sense transmitting to Pluto or beyond

1 - Marpa uses regexes but..

Um, actually Marpa uses character classes, just character classes, or literal matches (with 'single quoted strings'). See Marpa's DSL documentation.