5

I want to parse some grammar like the following

OUTPUT data
GROUPBY key
TO location
USING object

the order of the GROUPBY TO USING clauses is allowed to vary, but each clause can occur at most once.

Is there a convenient or built-in way to parse this in FParsec? I read some questions and answers that mentions Haskell Parsec permute. There doesn't seem to be a permute in FParsec. If this is the way to go, what would I go about building a permute in FParsec?

KFL
  • 17,162
  • 17
  • 65
  • 89

1 Answers1

3

I don't think there's a permutation parser in FParsec. I see a few directions you could take it though.

  • In general, what @FuleSnabel suggests is pretty sound, and probably simplest to implement. Don't make the parser responsible for asserting the property that each clause appears at most once. Instead parse each clause separately, allowing for duplicates, then inspect the resulting AST and error out if your property doesn't hold.

  • You could generate all permutations of your parsers and combine them with choice. Obviously this approach doesn't scale, but for three parsers I'd say it's fair game.

  • You could write your own primitive for parsing using a collection of parsers applied in any order. This would be a variant of many where in each step you make a choice of a parser, then discard that parser. So in each step you choose from a shrinking list of parsers until you can't parse anymore, finally returning the results collected along the way.

  • You could use user state to keep track of parsers already used and fail if a parser would be used twice within the same context. Not sure if this would yield a particularly nice solution - haven't really tried it before.

scrwtp
  • 13,437
  • 2
  • 26
  • 30
  • thanks I worked out a solution using the user state to remember if a specific clause has been seen for parsing the current OUTPUT statement. After seen the comment and answer, I started to play with validating this on the AST. I feel it not as easy as I thought to "validate" this on the AST. Specifically, now there is a OUTPUT union type `type OutputStatement = OUTPUT of .. | TO of ..`. The parser returns a `OutputStatement list`. My job is now to validate the list to see if there's dups. How to do this idiomatically? – KFL Aug 30 '16 at 20:33
  • More specifically, how do I determine duplicated union cases in a DU list? `[TO "foo"; TO "bar"; USING "aaa"; USING "bbb"; ...]` – KFL Aug 30 '16 at 20:42
  • There's no "one true way", but a straightforward one would be to map the DUs into tags (TO -> 0, USING -> 1, etc.), take a set of that list, and check if the length of the input list is the same as the count of the output set. – scrwtp Aug 31 '16 at 00:41
  • I think you're reading too much into my comment. Just write a function like this: `function TO _ -> 0 | USING _ -> 1 | ...` – scrwtp Sep 02 '16 at 17:19