diff options
Diffstat (limited to 'src/__OLD_parcom')
26 files changed, 866 insertions, 0 deletions
diff --git a/src/__OLD_parcom/alt.cr b/src/__OLD_parcom/alt.cr new file mode 100644 index 0000000..dedd41d --- /dev/null +++ b/src/__OLD_parcom/alt.cr @@ -0,0 +1,28 @@ +require "./parser.cr" + +module Parcom + # `Alt` is a `Parser` that accepts two other parsers and tries + # to parse with one of them. + # If the first (left) parser succeeds, its result is returned. + # If the first parser fails, it will try the second (right) parser. + class Alt(T, V) < Parser(T, V) + # Accepts the two parsers to try to parse with. + def initialize(@p1 : Parser(T, V), @p2 : Parser(T, V)) + end + + # Tries to parse using both parsers. + # + # It will initially try to parse with the first parser. + # If it fails, it will try to parse with the second parser. + def parse(tokens : Tokens(T)) : Result(T, V) + @p1.parse(tokens) + rescue ex1 : ParserFail + begin + @p2.parse(tokens) + rescue ex2 : ParserFail + raise ParserFail.new("Alt (#{ex1.message}), (#{ex2.message})") + end + end + end +end + diff --git a/src/__OLD_parcom/any_token.cr b/src/__OLD_parcom/any_token.cr new file mode 100644 index 0000000..1f65bfc --- /dev/null +++ b/src/__OLD_parcom/any_token.cr @@ -0,0 +1,18 @@ +require "./parser.cr" + +module Parcom + # `AnyToken` is a `Parser` that consumes exactly one token from + # the input stream and returns it. + # It fails if the input stream is empty. + class AnyToken(T) < Parser(T, T) + # Parses the first token in the input, fails if the input is empty. + def parse(tokens : Tokens(T)) : Result(T, T) + if tokens.empty? + raise ParserFail.new("AnyToken: input was empty") + else + Result.new(tokens[1..], tokens[0]) + end + end + end +end + diff --git a/src/__OLD_parcom/assert.cr b/src/__OLD_parcom/assert.cr new file mode 100644 index 0000000..5a3e621 --- /dev/null +++ b/src/__OLD_parcom/assert.cr @@ -0,0 +1,45 @@ +require "./parser.cr" + +module Parcom + # `Assert` is a `Parser` that runs another `Parser` and then + # performs a test on its result. The parser will then either fail if + # the result does not pass the test, or forward it on if it does. + # + # Example: + # ``` + # letter = Assert.new(AnyToken(Char).new) { |x| x.letter? } + # non_letter = Assert.new(AnyToken(Char).new) { |x| !x.letter? } + # input = Tokens.from_string("hi") + # letter.parse(input) # this succeeds + # non_letter.parse(input) # this fails + # ``` + # + # `Assert` instance can also be created by calling + # `Parser#assert` on any parser: + # ``` + # # This parser is identical to the above example. + # letter = AnyToken.new(Char).assert { |x| x.letter? } + # ``` + class Assert(T, V) < Parser(T, V) + # Accepts the parser to run and a `Bool`-retuning block + # containing the test to perform on the other parser's result. + def initialize(@p : Parser(T, V), &block : V -> Bool) + @f = block + end + + # Runs the parser it was initialized with, and returns that parser's + # result if it passes the provided test. Raises `ParserFail` otherwise. + def parse(tokens : Tokens(T)) : Result(T, V) + result = @p.parse(tokens) + rescue ex : ParserFail + raise ParserFail.new("Assert (pre-assertion): #{ex.message}") + else + unless @f.call(result.value) + raise ParserFail.new("Assert: predicate failed for <#{result.value}>") + end + + return result + end + end +end + diff --git a/src/__OLD_parcom/at_least.cr b/src/__OLD_parcom/at_least.cr new file mode 100644 index 0000000..2fb8dcf --- /dev/null +++ b/src/__OLD_parcom/at_least.cr @@ -0,0 +1,29 @@ +require "./parser.cr" +require "./map.cr" +require "./exactly.cr" + +module Parcom + # `AtLeast` is a `Parser` that tries to parser with another parser + # a specific number of times. The results of each successful parse + # are returned in an array. If the number of successes is less than + # the specified number, the parser fails. + class AtLeast(T, V) < Parser(T, Array(V)) + @p : Map(T, {Array(V), Array(V)}, Array(V)) + + # Accepts the number of parsing attempts, and the parser to use. + # If a negative int is given, it is treated as if it were 0. + def initialize(i : Int, p : Parser(T, V)) + @p = (Exactly.new(i, p) + Many.new(p)).map do |tup| + tup[0] + tup[1] + end + end + + # Tries to parse the given number of times, or more. + def parse(tokens : Tokens(T)) : Result(T, Array(V)) + @p.parse(tokens) + rescue ex : ParserFail + raise ParserFail.new("AtLeast: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/at_most.cr b/src/__OLD_parcom/at_most.cr new file mode 100644 index 0000000..b70164f --- /dev/null +++ b/src/__OLD_parcom/at_most.cr @@ -0,0 +1,29 @@ +require "./parser.cr" +require "./map.cr" +require "./exactly.cr" +require "./optional.cr" + +module Parcom + # `AtMost` is a `Parser` that tries to parse with another parser a specific + # number of times. The results of each successful parse are returned in an + # array. If the specific number of parses succeed, the parsing stops, even + # if it is possible to keep parsing. If the parser is never successful, it + # succeeds with an empty array. + class AtMost(T, V) < Parser(T, Array(V)) + @p : Map(T, Array(V?), Array(V)) + + # Accepts the number of parsing attempts, and the parser to use. + def initialize(i : Int, p : Parser(T, V)) + @p = Exactly.new(i, Optional.new(p)).map(&.compact) + end + + # Tries to parse up to the given number of times. + # If the parser never succeeds, returns an empty array. + def parse(tokens : Tokens(T)) : Result(T, Array(V)) + @p.parse(tokens) + rescue ex : ParserFail + raise ParserFail.new("AtMost: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/between.cr b/src/__OLD_parcom/between.cr new file mode 100644 index 0000000..05519e4 --- /dev/null +++ b/src/__OLD_parcom/between.cr @@ -0,0 +1,37 @@ +require "./parser.cr" +require "./map.cr" +require "./exactly.cr" +require "./at_most.cr" + +module Parcom + # `Between` is a `Parser` that tries to parse with another parser a number + # of times within a specified range. The results of each successful parse + # are returned in an array. If the number of successful parses is out of + # the lower bound of the range, the parser fails. If the number of successful + # parses reaches thhe upper bound of the range, the parsing stops, even if it + # is possible to keep parsing. + class Between(T, V) < Parser(T, Array(V)) + @p : Map(T, {Array(V), Array(V)}, Array(V)) + + # Accepts the lower and upper bounds for the number of parsing attempts, + # as well as the parser to use. This method works the same way whether or + # not the larger value is passed first or second. If a negative int value + # is given for either parameter, it is treated as `0`. + # TODO: Overload to allow for Range objects. + def initialize(i : Int, j : Int, p : Parser(T, V)) + lower = i < j ? i : j + upper = (i - j).abs + @p = (Exactly.new(lower, p) + AtMost.new(upper, p)).map do |tup| + tup[0] + tup[1] + end + end + + # Tries to parse a numebr of times within the given range. + def parse(tokens : Tokens(T)) : Result(T, Array(V)) + @p.parse(tokens) + rescue ex : ParserFail + raise ParserFail.new("Between: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/eof.cr b/src/__OLD_parcom/eof.cr new file mode 100644 index 0000000..650da56 --- /dev/null +++ b/src/__OLD_parcom/eof.cr @@ -0,0 +1,23 @@ +require "./parser.cr" + +module Parcom + # `EOF` is a `Parser` succeeds if the input stream is empty. + # + # This parser retuns `nil` when successful because there is no + # other meaningful value to return. + # + # This parser is also one of the few cases where it is ideal to not + # modify or take from the input stream, as it should be empty anyway. + class EOF(T) < Parser(T, Nil) + # Succeeds is the input stream is empty and returns `nil`. + # Raises a `ParserFail` exception when the input is not empty. + def parse(tokens : Tokens(T)) : Result(T, Nil) + if tokens.empty? + Result.new(tokens, nil) + else + raise ParserFail.new("Eof: input was not empty") + end + end + end +end + diff --git a/src/__OLD_parcom/exactly.cr b/src/__OLD_parcom/exactly.cr new file mode 100644 index 0000000..a34fd0d --- /dev/null +++ b/src/__OLD_parcom/exactly.cr @@ -0,0 +1,28 @@ +require "./parser.cr" + +module Parcom + # `Exactly` is a `Parser` that tries to parse with another parser + # a specific number of times. The results of each successful parse + # are returned in an array. If the number of successes is less than + # OR greater than the specified number, the parser fails. + class Exactly(T, V) < Parser(T, Array(V)) + @p : Sequence(T, V) + + # Accepts the number of parsing attempts, and the parser to use. + # If a negative int is given, it is treated as if it were `0`. + def initialize(i : Int, p : Parser(T, V)) + i = i.negative? ? 0 : i + # put `i` copies of `p` into an array + ps = ([p] of Parser(T, V)) * i + @p = Sequence.new(ps) + end + + # Tries to parse the given number of times. + def parse(tokens : Tokens(T)) : Result(T, Array(V)) + @p.parse(tokens) + rescue ex : ParserFail + raise ParserFail.new("Exactly: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/first_of.cr b/src/__OLD_parcom/first_of.cr new file mode 100644 index 0000000..c4077eb --- /dev/null +++ b/src/__OLD_parcom/first_of.cr @@ -0,0 +1,40 @@ +require "./parser.cr" + +module Parcom + # `FirstOf` is a `Parser` that accepts multiple parsers, and tries to parse + # with all of them, in order. As soon as one of the parsers succeeds, + # that parser's result is returned. If none of the parsers are successful, + # the parsing fails. + class FirstOf(T, V) < Parser(T, V) + @p : Parser(T, V) + + # Accepts the parsers to use. Raises an `ArgumentError` if + # no parsers are provided. + def initialize(ps : Iterable(Parser(T, V))) + ps_iter = ps.each + p = ps_iter.next + + if p.is_a?(Iterator::Stop) + raise ArgumentError.new("FirstOf requires atleast one parser, got none") + end + + # Combine all the parsers into one by wrapping them with `Alt`. + @p = p + + loop do + p = ps_iter.next + break if p.is_a?(Iterator::Stop) + @p = @p | p + end + end + + # Tries to parse with each of the given parsers. Either returns the first + # successful result or fails if no parsers succeed. + def parse(tokens : Tokens(T)) : Result(T, V) + @p.parse(tokens) + rescue ex : ParserFail + raise ParserFail.new("FirstOf: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/flunk.cr b/src/__OLD_parcom/flunk.cr new file mode 100644 index 0000000..00a0bd6 --- /dev/null +++ b/src/__OLD_parcom/flunk.cr @@ -0,0 +1,12 @@ +require "./parser.cr" + +module Parcom + # `Flunk` is a `Parser` that always fails. + class Flunk(T, V) < Parser(T, V) + # Always raises `ParserFail` + def parse(tokens) : Result(T, V) + raise ParserFail.new("Flunk: parsing failed") + end + end +end + diff --git a/src/__OLD_parcom/left.cr b/src/__OLD_parcom/left.cr new file mode 100644 index 0000000..201f497 --- /dev/null +++ b/src/__OLD_parcom/left.cr @@ -0,0 +1,26 @@ +require "./parser.cr" +require "./map.cr" + +module Parcom + # `Left` is a `Parser` that tries to parse with two different + # parsers in succession and fails if either of the two parsers fails. + # This parser behaves the same as `Plus`, but only returns the result + # of the first parser. + class Left(T, V, U) < Parser(T, V) + @p : Map(T, {V, U}, V) + + # Accepts the two parsers to use, in order. + def initialize(p1 : Parser(T, V), p2 : Parser(T, U)) + @p = (p1 + p2).map(&.first) + end + + # Tries to parse with the two given parsers, and returns the + # result of the first parser if they both succeed. + def parse(tokens : Tokens(T)) : Result(T, V) + @p.parse(tokens) + rescue ex : ParserFail + raise ParserFail.new("Left: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/many.cr b/src/__OLD_parcom/many.cr new file mode 100644 index 0000000..a734c63 --- /dev/null +++ b/src/__OLD_parcom/many.cr @@ -0,0 +1,36 @@ +require "./parser.cr" + +module Parcom + # `Many` is a `Parser` that repeatedly tries to parse with another parser. + # The `Many` object will collect all success values in an array, and return + # them with the final state of the input stream. If the wrapped parser ever + # fails or succeeds without parsing any input, the `Many` object will stop + # attempting to parse will will return the array of prrevious successes. + # + # `Many` will return an empty array if the parser never succeeds or consumes + # input. For cases where at least one parserr success is needed, use `Some`. + class Many(T, V) < Parser(T, Array(V)) + # Accepts the parser to use. + def initialize(@p : Parser(T, V)) + end + + # Continuously parses with the wrapped parser, returns all successes. + # Parsing stops when the parser fails, or succeeds without consuming input. + def parse(tokens : Tokens(T)) : Result(T, Array(V)) + parsed = [] of V + + loop do + result = @p.parse?(tokens) + break unless !result.nil? && result.tokens != tokens + + parsed << result.value + tokens = result.tokens + end + + Result.new(tokens, parsed) + rescue ex : ParserFail + raise ParserFail.new("Many: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/map.cr b/src/__OLD_parcom/map.cr new file mode 100644 index 0000000..34961b5 --- /dev/null +++ b/src/__OLD_parcom/map.cr @@ -0,0 +1,30 @@ +require "./parser.cr" + +module Parcom + # `Map` is a `Parser` that tries to parse using another parser, + # and then changing the result of that parser to a different value. + # + # Example: + # ``` + # # Where `Digits` is some parser that returns an array of digit characters + # parse_i32 = Digits.new.map { |x| x.join.to_i32 } + # result = parse_i32.parse(Tokens.from_string("1234")) + # result.value # => 1234 (Int32) + # ``` + class Map(T, V, U) < Parser(T, U) + # Accepts the parser to use and the function to apply to the result. + def initialize(@p : Parser(T, V), &block : V -> U) + @f = block + end + + # Tries to parse with the given parser and applies the + # function to the result if successful. + def parse(tokens : Tokens(T)) : Result(T, U) + result = @p.parse(tokens) + Result.new(result.tokens, @f.call(result.value)) + rescue ex : ParserFail + raise ParserFail.new("Map: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/optional.cr b/src/__OLD_parcom/optional.cr new file mode 100644 index 0000000..b368d4e --- /dev/null +++ b/src/__OLD_parcom/optional.cr @@ -0,0 +1,40 @@ +require "./parser.cr" + +module Parcom + # `Optional` is a `Parser` that tries to parse with another parser, + # but does not fail the parser chain if the wrapped parser fails. + # If the wrapped parser fails, an `Optional` will not modify the input + # stream, and return `nil` instead. + # + # Example: + # ``` + # digit = Satisfy(Char).new { |c| c.digit? } + # digits = Many.new(digit) + # plus_sign = Optional.new(Token.new('+')) + # positive_int = plus_sign >> digits + # + # input1 = Tokens.from_string("+12345") + # input2 = Tokens.from_string("12345") + # + # # Both of these has the same result + # positive_int.parse(input1) + # positive_int.parse(input2) + # ``` + class Optional(T, V) < Parser(T, V?) + # Accepts the parser to use. + def initialize(@p : Parser(T, V)) + end + + # Tries to parse with the given parser, succeeds with `nil` + # instead of failing. This parser does not consume input if + # the wrapped parser fails. + def parse(tokens : Tokens(T)) : Result(T, V?) + r = @p.parse?(tokens) + + new_tokens = r.nil? ? tokens : r.tokens + new_value = r.nil? ? nil : r.value + Result.new(new_tokens, new_value) + end + end +end + diff --git a/src/__OLD_parcom/parser.cr b/src/__OLD_parcom/parser.cr new file mode 100644 index 0000000..ca350df --- /dev/null +++ b/src/__OLD_parcom/parser.cr @@ -0,0 +1,87 @@ +require "../parcom.cr" + +module Parcom + # `Parser` is the base class of all parser objects and contains + # a handful of helper methods that can allow for cleaner syntax. + # + # The generic type `T` represents the type of tokens a parser will + # operate on (usually `Char`). + # The generic type `V` represents the type of value that a parser + # will return when parsing is successful. + abstract class Parser(T, V) + # Accepts a `Tokens(T)` and either retuns a `Result(T, V)`, or raises a + # `ParserFail` exception with a message providing context of where + # in the chain the parsing failed. + # + # The `V` in the returned `Result` is arbitrary, but the `Tokens(T)` in + # the returned result MUST contain the parser's input, with some tokens + # removed from the front proprtional to what was parsed. + # + # Example: + # ``` + # hello = ParsesHello.new # inherits from Parser(Char, String) + # input = Tokens.from_string("Hello world!") + # + # result = hello.parse(input) + # result.value # => "Hello" + # result.tokens # => [' ', 'w', 'o', 'r', 'l', 'd', '!'] + # + # bad_input = Tokens.from_string("Good evening world!") + # hello.parse(bad_input) # raises ParserFail + # ``` + abstract def parse(tokens : Tokens(T)) : Result(T, V) + + # Same as `#parse`, but returns `nil` instead of raising `ParserFail`. + def parse?(tokens : Tokens(T)) : Result(T, V)? + self.parse(tokens) + rescue ParserFail + return nil + end + + # Constructs an `Alt` parser with `self` and `other`. + def |(other : Parser(T, V)) : Alt(T, V) + Alt.new(self, other) + end + + # Constructs a `Plus` parser with `self` and `other`. + def +(other : Parser(T, U)) : Plus(T, V, U) forall U + Plus.new(self, other) + end + + # Constructs a `Left` parser with `self` and `other`. + def <<(other : Parser(T, U)) : Left(T, V, U) forall U + Left.new(self, other) + end + + # Constructs a `Right` parser with `self` and `other`. + def >>(other : Parser(T, U)) : Right(T, V, U) forall U + Right.new(self, other) + end + + # Constructs an `Assert` parser with `self` and the given block. + def assert(&block : V -> Bool) : Assert(T, V) + Assert.new(self, &block) + end + + # Constructs an `Assert` parser with `self` and the given proc. + def assert(f : V -> Bool) : Assert(T, V) + Assert.new(self, &f) + end + + # Constructs a `Map` parser with `self` and the given block. + def map(&block : V -> U) : Map(T, V, U) forall U + Map.new(self, &block) + end + + # Constructs a `Map` parser with `self` and the given proc. + def map(f : V -> U) : Map(T, V, U) forall U + Map.new(self, &f) + end + + # Constructs a `Recover` parser with `self` and the given `V`. + def recover(default : V) : Recover(T, V) + Recover.new(self, default) + end + end +end + diff --git a/src/__OLD_parcom/peek.cr b/src/__OLD_parcom/peek.cr new file mode 100644 index 0000000..2b6f657 --- /dev/null +++ b/src/__OLD_parcom/peek.cr @@ -0,0 +1,23 @@ +require "./parser.cr" + +module Parcom + # `Peek` is a `Parser` that runs another `Parser` while + # leaving the input stream unmodified. + class Peek(T, V) < Parser(T, V) + # Accepts the parser to run. + def initialize(@p : Parser(T, V)) + end + + # Runs the parser it was initialized with, and returns + # that parser's result along with the original input. + # + # Re-raises a `ParserFail` exception if the other parser fails. + def parse(tokens : Tokens(T)) : Result(T, V) + result = @p.parse(tokens) + Result.new(tokens, result.value) + rescue ex : ParserFail + raise ParserFail.new("Peek: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/phrase.cr b/src/__OLD_parcom/phrase.cr new file mode 100644 index 0000000..1996fd4 --- /dev/null +++ b/src/__OLD_parcom/phrase.cr @@ -0,0 +1,33 @@ +require "./parser.cr" +require "./eof.cr" +require "./map.cr" + +module Parcom + # `Phrase` is a `Parser` that tries to parse with another parser, + # but will fail if any of the input has not been consumed. + # + # Example: + # ``` + # letter_a = Token.new('a') + # tokens = Tokens.from_string("aaa") + # one_a = Phrase(Char, Char).new(letter_a) + # result = one_a.parse(tokens) # This fails + # ``` + class Phrase(T, V) < Parser(T, V) + @p : Map(T, {V, Nil}, V) + + # Accepts the parser to parse with. + def initialize(p : Parser(T, V)) + @p = (p + EOF(T).new).map &.first + end + + # Tries to parse with the given parser, fails if there + # is any un-parsed input remaining. + def parse(tokens : Tokens(T)) : Result(T, V) + @p.parse(tokens) + rescue ex : ParserFail + raise ParserFail.new("Phrase: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/plus.cr b/src/__OLD_parcom/plus.cr new file mode 100644 index 0000000..53c9b4f --- /dev/null +++ b/src/__OLD_parcom/plus.cr @@ -0,0 +1,54 @@ +require "./parser.cr" + +module Parcom + # `Plus` is a parser that tries to parse with two different + # parsers in succession and fails if either of the two parsers fails. + # The return type of this parser is `{V, U}`, where `V` is the return + # type of the first parser and `U` is the return type of the second. + # + # Example: + # ``` + # parse1 = Token.new('1') + # parse2 = Token.new('2') + # tokens = Tokens.from_string("12") + # result = (parse1 + parse2).parse(tokens) # succeeds + # result = (parse2 + parse1).parse(tokens) # fails, wrong order + # ``` + # + # `Plus` parsers can be chained together, but the resulting return type + # can become unweildly with too many combined parsers: + # ``` + # letter_a = Token.new('a') + # a5 = letter_a + letter_a + letter_a + letter_a + letter_a + # tokens = Tokens.from_string("aaaaa") + # a5.parse(tokens) # succeeds + # # `a5` has a return type of { { { {Char, Char}, Char}, Char}, Char} + # ``` + # + # If you need to parse more than two things in this manner, + # consider using `Many`, `Some`, `Sequence`, or `TokenSeq` instead. + class Plus(T, V, U) < Parser(T, {V, U}) + # Accepts the two parsers to use, in order. + def initialize(@p1 : Parser(T, V), @p2 : Parser(T, U)) + end + + # Tries to parse with the two given parsers, and returns + # their results in a tuple if the both succeed. + def parse(tokens : Tokens(T)) : Result(T, {V, U}) + begin + r1 = @p1.parse(tokens) + rescue ex : ParserFail + raise ParserFail.new("Plus (left): #{ex.message}") + end + + begin + r2 = @p2.parse(r1.tokens) + rescue ex : ParserFail + raise ParserFail.new("Plus (right): #{ex.message}") + end + + Result.new(r2.tokens, {r1.value, r2.value}) + end + end +end + diff --git a/src/__OLD_parcom/recover.cr b/src/__OLD_parcom/recover.cr new file mode 100644 index 0000000..378f8d6 --- /dev/null +++ b/src/__OLD_parcom/recover.cr @@ -0,0 +1,27 @@ +require "./parser.cr" +require "./optional.cr" +require "./map.cr" + +module Parcom + # `Recover` is a `Parser` that tries to parse with another parser, + # but does not fail the parser chain if the wrapped parser fails. + # If the wrapped parser fails, a `Recover` will not modify the input + # stream, and return an arbitrary value of type `V` instead. + class Recover(T, V) < Parser(T, V) + @p : Map(T, V?, V) + + # Accepts the parser to use, and the default value + # to return if the parser fails. + def initialize(p : Parser(T, V), default : V) + @p = Optional.new(p).map { |x| x.nil? ? default : x } + end + + # Tries to parse with the given parser, succeeds with the + # default value instead of failing. This parser does not + # consume input if the wrapped parser fails. + def parse(tokens : Tokens(T)) : Result(T, V) + @p.parse(tokens) + end + end +end + diff --git a/src/__OLD_parcom/right.cr b/src/__OLD_parcom/right.cr new file mode 100644 index 0000000..a0489b1 --- /dev/null +++ b/src/__OLD_parcom/right.cr @@ -0,0 +1,26 @@ +require "./parser.cr" +require "./map.cr" + +module Parcom + # `Right` is a `Parser` that tries to parse with two different + # parsers in succession and fails if either of the two parsers fails. + # This parser behaves the same as `Plus`, but only returns the result + # of the second parser. + class Right(T, V, U) < Parser(T, U) + @p : Map(T, {V, U}, U) + + # Accepts the two parsers to use, in order. + def initialize(p1 : Parser(T, V), p2 : Parser(T, U)) + @p = (p1 + p2).map(&.last) + end + + # Tries to parse with the two given parsers, and returns the + # result of the second parser if they both succeed. + def parse(tokens : Tokens(T)) : Result(T, U) + @p.parse(tokens) + rescue ex : ParserFail + raise ParserFail.new("Left: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/satisfy.cr b/src/__OLD_parcom/satisfy.cr new file mode 100644 index 0000000..9734635 --- /dev/null +++ b/src/__OLD_parcom/satisfy.cr @@ -0,0 +1,33 @@ +require "./parser.cr" +require "./any_token.cr" +require "./assert.cr" + +module Parcom + # `Satisfy` is a `Parser` that parses a single token + # if that token passes a predefined test, similar + # to `Assert`. This class is effectively a shorthand + # for the following: + # ``` + # # These parsers are equivalent. + # letter_assert = Assert.new(AnyToken(Char).new) { |x| x.letter? } + # letter_satisfy = Satisfy(Char).new { |x| x.letter? } + # ``` + class Satisfy(T) < Parser(T, T) + @p : Assert(T, T) + + # Accepts the `Bool`-returning block containing the test + # to run on the parsed token. + def initialize(&block : T -> Bool) + @p = AnyToken(T).new.assert(&block) + end + + # Returns the first token of the input if that + # token passes the test. + def parse(tokens : Tokens(T)) : Result(T, T) + @p.parse(tokens) + rescue ex : ParserFail + raise ParserFail.new("Satisfy: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/sep_by.cr b/src/__OLD_parcom/sep_by.cr new file mode 100644 index 0000000..fa19027 --- /dev/null +++ b/src/__OLD_parcom/sep_by.cr @@ -0,0 +1,38 @@ +require "./parser.cr" +require "./map.cr" +require "./many.cr" + +module Parcom + # `SepBy` is a `Parser` that tries to parse one or more times with one + # parser, alternating with a second parser. + # + # Example: + # ``` + # letter_a = Token.new('a') + # letter_b = Token.new('b') + # p = SepBy(Char, Car, Char).new(letter_a, letter_b) + # tokens = Tokens.from_string("ababababa") + # + # result = p.parse(tokens) + # puts result.value # => ['a', 'a', 'a', 'a', 'a'] + # ``` + class SepBy(T, V, U) < Parser(T, Array(V)) + @p : Map(T, {V, Array(V)}, Array(V)) + + # Accepts the parser that parses the result values, and the + # parser that parses the sepatators. + def initialize(elem : Parser(T, V), sep : Parser(T, U)) + @p = (elem + Many(T, U).new(sep >> elem)).map do |tup| + [tup[0]] + tup[1] + end + end + + # Tries to parse, alternating the first and second parsers. + def parse(tokens : Tokens(T)) : Result(T, Array(V)) + @p.parse(tokens) + rescue ex : ParserFail + raise ParserFail.new("SepBy: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/sequence.cr b/src/__OLD_parcom/sequence.cr new file mode 100644 index 0000000..6a05cde --- /dev/null +++ b/src/__OLD_parcom/sequence.cr @@ -0,0 +1,33 @@ +require "./parser.cr" + +module Parcom + # `Sequence` is a `Parser` that combines multiple parsers and + # tries to parse all of them in succession. If all of the parsers + # succeed, the values parsed are returned in an array, in the order + # they were parsed in. If any of the parsers fail, + # the `Sequence` also fails. + class Sequence(T, V) < Parser(T, Array(V)) + # Accepts the parsers to use. + def initialize(@ps : Iterable(Parser(T, V))) + end + + # Tries each parser in order, and returns their results. + # Fail if any of the wrapped parsers fail. + # TODO: this can probably be optimised more for Arrays + # TODO: might be better to use #zip + def parse(tokens : Tokens(T)) : Result(T, Array(V)) + parsed = [] of V + + @ps.each do |p| + r = p.parse(tokens) + parsed << r.value + tokens = r.tokens + end + + Result.new(tokens, parsed) + rescue ex : ParserFail + raise ParserFail.new("Sequence: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/some.cr b/src/__OLD_parcom/some.cr new file mode 100644 index 0000000..a2e3563 --- /dev/null +++ b/src/__OLD_parcom/some.cr @@ -0,0 +1,33 @@ +require "./parser.cr" +require "./assert.cr" +require "./many.cr" + +module Parcom + # `Some` is a `Parser` that repeatedly tries to parse with another parser. + # The `Some` object will collect all success values in an array, and + # return them with the final state of the input stream. If the wrapped + # parser ever fails or succeeds without parsing any input, the `Some` + # object will stop attempting to parse and will return the array of + # previous successes. + # + # `Some` will raise a `ParserFail` exception if the parser never succeeds + # or consumes input. For cases where parsing should allow for 0 successes, + # use `Many`. + class Some(T, V) < Parser(T, Array(V)) + @p : Assert(T, Array(V)) + + # Accepts the parser to use. + def initialize(p : Parser(T, V)) + @p = Many.new(p).assert { |arr| !arr.empty? } + end + + # Continuously parses with the wrapped parser, returns all successes. + # Fails if there are no successes. + def parse(tokens : Tokens(T)) : Result(T, Array(V)) + @p.parse(tokens) + rescue ex : ParserFail + raise ParserFail.new("Some: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/token.cr b/src/__OLD_parcom/token.cr new file mode 100644 index 0000000..b4e1fef --- /dev/null +++ b/src/__OLD_parcom/token.cr @@ -0,0 +1,20 @@ +require "./satisfy" + +module Parcom + # `Token` is a `Parser` that tries to parse a specific token + # from the input stream. + class Token(T) < Parser(T, T) + # Accepts the token that this parser will try to parse. + def initialize(@expected : T) + @p = Satisfy(T).new { |x| x == @expected } + end + + # Tries to parse the specified token from the input stream. + def parse(tokens : Tokens(T)) : Result(T, T) + @p.parse(tokens) + rescue ex : ParserFail + raise ParserFail.new("Token <#{@expected}>: #{ex.message}") + end + end +end + diff --git a/src/__OLD_parcom/token_seq.cr b/src/__OLD_parcom/token_seq.cr new file mode 100644 index 0000000..45900f9 --- /dev/null +++ b/src/__OLD_parcom/token_seq.cr @@ -0,0 +1,38 @@ +require "./parser.cr" +require "./sequence.cr" + +module Parcom + # `TokenSeq` is a `Parser` that attempts to parse a specific + # string of tokens. If the expected tokens are not at the start + # of the input stream, the parser fails. + # + # Example: + # ``` + # parse_test = TokenSeq(Char).new("test".chars) + # tokens = Tokens.from_string("testing") + # + # result = parse_test.parse(tokens) + # + # puts result.value # => ['t', 'e', 's', 't'] + # puts result.tokens # => ['i', 'n', 'g'] + # ``` + class TokenSeq(T) < Parser(T, Array(T)) + @p : Sequence(T, T) + + # Accepts the tokens to try and parse, in order. + def initialize(expected : Iterable(T)) + ps = [] of Parser(T, T) + expected.each { |t| ps << Token.new(t) } + + @p = Sequence.new(ps) + end + + # Tries to parse the list of tokens. + def parse(tokens : Tokens(T)) : Result(T, Array(T)) + @p.parse(tokens) + rescue ex : ParserFail + raise ParserFail.new("TokenSeq: #{ex.message}") + end + end +end + |