Help getting rule parameters right

[Ohad31415]

I am trying to have a query parser allowing strings with single/double/triple quotes.
I thought to do it with a rule delim_string getting the delimiter as a parameter and then using it but there something with it I seem to not get right...
I'd mention I'm still new to rust and looking at peg just lately.

I tried several things looking into the examples trying to use ##parse_string_literal(delim) or delim() or different code blocks but didn't help.
The following compiles but doesn't work as expected -

peg::parser! {
    grammer mystring() for str {
        pub rule delim_string(delim: &str) -> String
            = ({ delim )} s:$( (!({ delim }) [_] / "\\" ({ delim }) )* ) ({ delim }) { s.to_owned() }
    }
}

// Getting - 
// Err(ParseError { location: LineCol { line: 1, column: 1, offset: 0 }, expected: ExpectedSet { expected: {"\"\\\\\"", "EOF"} } })
mystring::delim_string("'hello'", "'");

Help will be very much appreciated thanks!

[kevinmehall]

({ delim )} doesn't do what you think it does. It matches nothing and returns delim. The {} in it is the same as the block at the end of a rule, but with nothing to match before it within the parentheses.

##parse_string_literal(delim) does match the string passed, but the ## syntax is deprecated because it won't work in Rust edition 2024. You can get that behavior with the replacement #{|input, pos| ...} syntax like this:

rust-peg/tests/run-pass/custom_expr.rs

Lines 9 to 17 in 4317fbd

	rule custom_literal(literal: &str) = #{|input, pos| {
	let l = literal.len();
	if input.len() >= pos + l && &input.as_bytes()[pos..pos + l] == literal.as_bytes() {
	RuleResult::Matched(pos + l, ())
	} else {
	RuleResult::Failed
	}
	}}
	pub rule test2() = custom_literal("foo") "_" custom_literal("bar")

But, I'd suggest writing three separate rules, especially if they'll handle escaping differently.
Here is an example for double-quoted strings with \u{FFFF} escapes:
https://github.com/signalspec/signalspec/blob/6793c6b5647d2a2b1180b3164a55bf9b7e302df1/src/syntax/grammar.rs#L242-L249

If you really want to take the delimiter as a parameter, I'd suggest taking a delim: rule<()> argument rather than &str. This is like passing in a PEG rule as a closure that can be called within the rule:

rule delim_string(delim: rule<()>) -> String
    = delim() chars:(!delim() [c] { c } / escape_char())* delim() { chars.into_iter().collect() }

rule use_it() = delim_string(<"\"">)

[Ohad31415]

Thanks a lot! it works and making it getting a rule with the delimiter also works even better

[Ohad31415]

Another small question that troubled me and couldn't get how to do it - in conditional blocks how to return a custom "dynamic" error.
I guess possibly it goes 100% into a rust question.

I want to have an "interpreted string".
The following gives me a rust issue as format! returns a String and the Result should have the err as &str and there I didn't find a way how to return a &str here without getting into lifetime issue - is there a way I can pull it off?

peg::parser! {
    rule delim_interp_string(delim: rule<()>) -> String
        = "$" s:delim_string(delim) { ?
                json_serde::from_str::<String>(&format!(r#""{}""#, s))
                    .map_err(|err| format!("Invalid interpreted string: {}", err))
            }
}

[kevinmehall]

The Err can only be a &'static str, normally a compiled-in string literal, which means you can't use a String from format!(). It should be a short name like "interpreted string" indicating what was expected at that location, not a full error message. Multiple failures at the same position may be merged by rust-peg into something like Expected interpreted string, number, or "{" at 123:45.

There's not a good way to use another parser like json_serde inside of rust-peg and integrate its more complex errors with rust-peg's own error handling. What you can do instead is have the rule succeed but put a Result<String, SomeOtherError> in your AST that you pull out later. This also allows error recovery and returning multiple errors.

[Ohad31415]

How can I do that?

[kevinmehall]

    rule delim_interp_string(delim: rule<()>) -> Result<String, serde_json::Error>
        = "$" s:delim_string(delim) {
                json_serde::from_str::<String>(&format!(r#""{}""#, s))
            }

May also want to capture start:position!() end:position!() and include those in the return type so you can show the location if it's an error.

[Ohad31415]

Hope I don't bother too much.
If I have the rule returning Result<String, serde_json::Error> or other custom one, how to I then integrate it with other rule that should return String?
I see that if I do it so I can call the parser on this specific rule getting Result<Result<...>, _>