class FunctionalParser

# File lib/functional_parser.rb, line 98
def self.alpha
  lower | upper
end

# File lib/functional_parser.rb, line 102
def self.alphanum
  alpha | digit
end

# File lib/functional_parser.rb, line 72
def self.append(parser1, parser2)
  parser1 >> proc{|x|
    parser2 >> proc{|y|
      ret(x + y)
    }
  }
end

# File lib/functional_parser.rb, line 106
def self.char(char)
  sat{|c| c == char}
end

# File lib/functional_parser.rb, line 86
def self.digit
  sat{|c| "0" <= c && c <= "9"}
end

# File lib/functional_parser.rb, line 59
def self.either(parser1, parser2)
  new{|inp|
    case result = parser1.parse(inp)
    when Failed
      parser2.parse(inp)
    when Succeeded
      result
    else
      raise "error."
    end
  }
end

# File lib/functional_parser.rb, line 38
def self.failure
  new{|inp| Failed.new}
end

# File lib/functional_parser.rb, line 134
def self.ident
  many1(alphanum) >> proc{|cs|
    ret(cs.inject(&:+))
  }
end

# File lib/functional_parser.rb, line 162
def self.identifier
  token(ident)
end

# File lib/functional_parser.rb, line 42
def self.item
  new{|inp| inp.size == 0 ? Failed.new : Succeeded.new(inp[0], inp[1, inp.size - 1])}
end

# File lib/functional_parser.rb, line 90
def self.lower
  sat{|c| "a" <= c && c <= "z"}
end

# File lib/functional_parser.rb, line 122
def self.many(parser)
  many1(parser) | ret([])
end

# File lib/functional_parser.rb, line 126
def self.many1(parser)
  parser >> proc{|x|
    many(parser) >> proc{|xs|
      ret([x] + xs)
    }
  }
end

# File lib/functional_parser.rb, line 140
def self.nat
  many1(digit) >> proc{|cs|
    ret(cs.inject(&:+).to_i)
  }
end

# File lib/functional_parser.rb, line 166
def self.natural
  token(nat)
end

# File lib/functional_parser.rb, line 14
def initialize(&proc)
  @f = proc
end

# File lib/functional_parser.rb, line 34
def self.ret(something)
  new{|inp| Succeeded.new(something, inp)}
end

# File lib/functional_parser.rb, line 80
def self.sat(&proc)
  item >> proc{|c|
    proc.call(c) ? ret(c) : failure
  }
end

# File lib/functional_parser.rb, line 46
def self.so(parser, &proc)
  new{|inp|
    case result = parser.parse(inp)
    when Failed
      result
    when Succeeded
      proc.call(result.parsed).parse(result.rest)
    else
      raise "error."
    end
  }
end

# File lib/functional_parser.rb, line 110
def self.string(str)
  if str.size == 0
    ret(str)
  else
    char(str[0]) >> proc{|c|
      string(str[1, str.size - 1]) >> proc{
        ret(str)
      }
    }
  end
end

# File lib/functional_parser.rb, line 152
def self.token(parser)
  whitespace >> proc{
    parser >> proc{|x|
      whitespace >> proc{
        ret(x)
      }
    }
  }
end

# File lib/functional_parser.rb, line 94
def self.upper
  sat{|c| "A" <= c && c <= "Z"}
end

# File lib/functional_parser.rb, line 146
def self.whitespace
  many(char("\s") | char("\n") | char("\t")) >> proc{
    ret(nil)
  }
end

# File lib/functional_parser.rb, line 30
def +(other)
  FunctionalParser.append(self, other)
end

# File lib/functional_parser.rb, line 22
def >>(proc)
  FunctionalParser.so(self, &proc)
end

# File lib/functional_parser.rb, line 18
def parse(inp)
  @f.call(inp)
end

# File lib/functional_parser.rb, line 26
def |(other)
  FunctionalParser.either(self, other)
end