I'm writing a parser for ruby, as an experiment in D, and was considering Pry as an option for parsing due to my preference for in-language DSLs.

Ruby has an interesting rule for string literals, essentially, you can define a string literal according to the following grammar, where char is any printable non-alphanumeric ASCII character - STRING2 : %(Q|q|x|r|S|s) char {any_char} char. For example, "a string", %{a string} and %q{a string} are equivalent for our intents.

Declaring each variant separately and explicitly would result in a huge number of rules to write, and then maintain.

Pry's lack of documentation, outside of the examples, has currently led me to believe that there is no Pry-idiomatic expression to match all of these variants as well as ensure they are terminated with the same delimiter.

I'm left with a few options, assuming that what I what is not expressible within the framework of Pry:

• Use CTFE to generate a sequence for every possible variant

• Find a way to write a custom parser which is compatible with Pry

I'm writing a parser for a case-insensitive language. Though I could just enumerate all possible permutations of keywords, this seems like it'd create code smell more than anything else. (I could also just do .map(x => ...), but again, this seems like unnecessary bloat.) Please add case-insensitive versions of tk/stk/literal.

So, simply by adding pry as a dependency on a virgin project, and using features that are present in the documentation and examples, dub indicates that these features are non-existent. I have identified the following combinators that were not recognized: delimited, optional, skipWs, slice, utfString and also the stk atom. There may be others.

Searching in the code and in the different versions, it seems that the combinators I quoted are not part of the old versions (under 0.3.2), but it is indeed this version that I included in the blank project...

Here is a simple example (by the way, the examples in the "example" folder don't work for me either):

import pry;
import std.stdio;

void main()
{
    alias S = SimpleStream!string;
    with(parsers!S)
    {
        auto p = delimited(range!('0', '9').rep, tk!',');
        auto s = "1,2,3".stream;
        string[] values;
        S.Error err;
        auto r = p.parse(s, values, err);
        writeln(r);
    }
}

With the following dub.sdl :

name "test"
dependency "pry" version="~>0.3.2"

By building, I get:

$ dub build
pry 0.3.2: target for configuration "library" is up to date.
test ~master: building configuration "application"...
source\app.d(9,12): Error: undefined identifier delimited

What's wrong with all this? How come I'm using the "newest" version of pry, but an older version of the library seems to be used instead? Perhaps a new version should be updated?

At line 35 of pry/grammar/parser.d, unicode.parseSet is called.

This does not appear to exist in phobos, nor is it defined in Pry.

auto makeParser(){
  with(parsers!S) {
    auto expr = dynamic!int;
    auto primary = any(
      range!('0', '9').rep.map!(x => x.to!int),
      seq(tk!'(', expr, tk!')').map!(x => x[1])
    );
    auto term = dynamic!int;
    term = any(
      seq(primary, tk!'*', term).map!(x => x[0] * x[2]),
      seq(primary, tk!'/', term).map!(x => x[0] / x[2]),
      primary
    );
    //expr = any(
    //  seq(term, tk!'+', expr).map!(x => x[0] + x[2]),
    //  seq(term, tk!'-', expr).map!(x => x[0] - x[2]),
    //  term
    //);
    return expr;
  }
}

running modified calc example as above yields a SEGFAULT ; could we improve error msg in this case?

Any diffirence from pegged? Speedup, Less overhead?