From 3fab598b4873fda69183de21b650d041cc95411c Mon Sep 17 00:00:00 2001
From: Matthew Hall <hallmatthew314@gmail.com>
Date: Sat, 11 Mar 2023 00:57:15 +1300
Subject: Class renaming

---
 src/parcom.cr | 168 +++++++++++++++++++++++++++++-----------------------------
 1 file changed, 84 insertions(+), 84 deletions(-)

(limited to 'src')

diff --git a/src/parcom.cr b/src/parcom.cr
index 034c8e1..d13fce7 100644
--- a/src/parcom.cr
+++ b/src/parcom.cr
@@ -1,14 +1,14 @@
 module Parcom
   VERSION = "0.1.0"
 
-  class ParserException < Exception
+  class ParserFail < Exception
   end
 
-  struct TokenStream(T)
+  struct Tokens(T)
     getter tokens
 
-    def self.from_string(s : String) : TokenStream(Char)
-      TokenStream.new(s.chars)
+    def self.from_string(s : String) : Tokens(Char)
+      Tokens.new(s.chars)
     end
 
     def initialize(ts : Iterable(T))
@@ -24,12 +24,12 @@ module Parcom
       @tokens[index]
     end
 
-    def [](start : Int, count : Int) : TokenStream(T)
-      TokenStream.new(@tokens[start, count])
+    def [](start : Int, count : Int) : Tokens(T)
+      Tokens.new(@tokens[start, count])
     end
 
-    def [](range : Range) : TokenStream(T)
-      TokenStream.new(@tokens[range])
+    def [](range : Range) : Tokens(T)
+      Tokens.new(@tokens[range])
     end
 
     def []?(*args)
@@ -46,16 +46,16 @@ module Parcom
   struct Result(T, V)
     getter tokens, value
 
-    def initialize(@tokens : TokenStream(T), @value : V)
+    def initialize(@tokens : Tokens(T), @value : V)
     end
   end
 
   abstract class Parser(T, V)
-    abstract def parse(tokens : TokenStream(T)) : Result(T, V)
+    abstract def parse(tokens : Tokens(T)) : Result(T, V)
 
-    def parse?(tokens : TokenStream(T)) : Result(T, V)?
+    def parse?(tokens : Tokens(T)) : Result(T, V)?
       self.parse(tokens)
-    rescue ParserException
+    rescue ParserFail
       return nil
     end
 
@@ -98,14 +98,14 @@ module Parcom
 
   class Flunk(T, V) < Parser(T, V)
     def parse(tokens) : Result(T, V)
-      raise ParserException.new("Flunk: parsing failed")
+      raise ParserFail.new("Flunk: parsing failed")
     end
   end
 
   class AnyToken(T) < Parser(T, T)
-    def parse(tokens : TokenStream(T)) : Result(T, T)
+    def parse(tokens : Tokens(T)) : Result(T, T)
       if tokens.empty?
-        raise ParserException.new("AnyToken: input was empty")
+        raise ParserFail.new("AnyToken: input was empty")
       else
         Result.new(tokens[1..], tokens[0])
       end
@@ -113,11 +113,11 @@ module Parcom
   end
 
   class Eof(T) < Parser(T, Nil)
-    def parse(tokens : TokenStream(T)) : Result(T, Nil)
+    def parse(tokens : Tokens(T)) : Result(T, Nil)
       if tokens.empty?
         Result.new(tokens, nil)
       else
-        raise ParserException.new("Eof: input was not empty")
+        raise ParserFail.new("Eof: input was not empty")
       end
     end
   end
@@ -126,11 +126,11 @@ module Parcom
     def initialize(@p : Parser(T, V))
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, V)
+    def parse(tokens : Tokens(T)) : Result(T, V)
       result = @p.parse(tokens)
       Result.new(tokens, result.value)
-    rescue ex : ParserException
-      raise ParserException.new("Peek: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("Peek: #{ex.message}")
     end
   end
 
@@ -139,13 +139,13 @@ module Parcom
       @f = block
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, V)
+    def parse(tokens : Tokens(T)) : Result(T, V)
       result = @p.parse(tokens)
-    rescue ex : ParserException
-      raise ParserException.new("Assert (pre-assertion): #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("Assert (pre-assertion): #{ex.message}")
     else
       unless @f.call(result.value)
-        raise ParserException.new("Assert: predicate failed for <#{result.value}>")
+        raise ParserFail.new("Assert: predicate failed for <#{result.value}>")
       end
 
       return result
@@ -159,10 +159,10 @@ module Parcom
       @p = AnyToken(T).new.assert(&block)
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, T)
+    def parse(tokens : Tokens(T)) : Result(T, T)
       @p.parse(tokens)
-    rescue ex : ParserException
-      raise ParserException.new("Satisfy: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("Satisfy: #{ex.message}")
     end
   end
 
@@ -171,10 +171,10 @@ module Parcom
       @p = Satisfy(T).new { |x| x == @expected }
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, T)
+    def parse(tokens : Tokens(T)) : Result(T, T)
       @p.parse(tokens)
-    rescue ex : ParserException
-      raise ParserException.new("Token <#{@expected}>: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("Token <#{@expected}>: #{ex.message}")
     end
   end
 
@@ -182,13 +182,13 @@ module Parcom
     def initialize(@p1 : Parser(T, V), @p2 : Parser(T, V))
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, V)
+    def parse(tokens : Tokens(T)) : Result(T, V)
       @p1.parse(tokens)
-    rescue ex1 : ParserException
+    rescue ex1 : ParserFail
       begin
         @p2.parse(tokens)
-      rescue ex2 : ParserException
-        raise ParserException.new("Alt (#{ex1.message}), (#{ex2.message})")
+      rescue ex2 : ParserFail
+        raise ParserFail.new("Alt (#{ex1.message}), (#{ex2.message})")
       end
     end
   end
@@ -198,11 +198,11 @@ module Parcom
       @f = block
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, U)
+    def parse(tokens : Tokens(T)) : Result(T, U)
       result = @p.parse(tokens)
       Result.new(result.tokens, @f.call(result.value))
-    rescue ex : ParserException
-      raise ParserException.new("Map: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("Map: #{ex.message}")
     end
   end
 
@@ -213,10 +213,10 @@ module Parcom
       @p = (p + Eof(T).new).map &.first
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, V)
+    def parse(tokens : Tokens(T)) : Result(T, V)
       @p.parse(tokens)
-    rescue ex : ParserException
-      raise ParserException.new("Phrase: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("Phrase: #{ex.message}")
     end
   end
 
@@ -224,17 +224,17 @@ module Parcom
     def initialize(@p1 : Parser(T, V), @p2 : Parser(T, U))
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, {V, U})
+    def parse(tokens : Tokens(T)) : Result(T, {V, U})
       begin
         r1 = @p1.parse(tokens)
-      rescue ex : ParserException
-        raise ParserException.new("Plus (left): #{ex.message}")
+      rescue ex : ParserFail
+        raise ParserFail.new("Plus (left): #{ex.message}")
       end
 
       begin
         r2 = @p2.parse(r1.tokens)
-      rescue ex : ParserException
-        raise ParserException.new("Plus (right): #{ex.message}")
+      rescue ex : ParserFail
+        raise ParserFail.new("Plus (right): #{ex.message}")
       end
 
       Result.new(r2.tokens, {r1.value, r2.value})
@@ -248,10 +248,10 @@ module Parcom
       @p = (p1 + p2).map(&.first)
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, V)
+    def parse(tokens : Tokens(T)) : Result(T, V)
       @p.parse(tokens)
-    rescue ex : ParserException
-      raise ParserException.new("Left: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("Left: #{ex.message}")
     end
   end
 
@@ -262,10 +262,10 @@ module Parcom
       @p = (p1 + p2).map(&.last)
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, U)
+    def parse(tokens : Tokens(T)) : Result(T, U)
       @p.parse(tokens)
-    rescue ex : ParserException
-      raise ParserException.new("Right: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("Right: #{ex.message}")
     end
   end
 
@@ -276,7 +276,7 @@ module Parcom
       @p = Optional.new(p).map { |x| x.nil? ? default : x }
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, V)
+    def parse(tokens : Tokens(T)) : Result(T, V)
       @p.parse(tokens)
     end
   end
@@ -285,7 +285,7 @@ module Parcom
     def initialize(@p : Parser(T, V))
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, V?)
+    def parse(tokens : Tokens(T)) : Result(T, V?)
       r = @p.parse?(tokens)
 
       new_tokens = r.nil? ? tokens : r.tokens
@@ -300,7 +300,7 @@ module Parcom
 
     # TODO: this can probably be optimised more for Arrays
     # TODO: might be better to use #zip
-    def parse(tokens : TokenStream(T)) : Result(T, Array(V))
+    def parse(tokens : Tokens(T)) : Result(T, Array(V))
       parsed = [] of V
 
       @ps.each do |p|
@@ -310,12 +310,12 @@ module Parcom
       end
 
       Result.new(tokens, parsed)
-    rescue ex : ParserException
-      raise ParserException.new("Sequence: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("Sequence: #{ex.message}")
     end
   end
 
-  class Tokens(T) < Parser(T, Array(T))
+  class TokenSeq(T) < Parser(T, Array(T))
     @p : Sequence(T, T)
 
     def initialize(expected : Iterable(T))
@@ -325,10 +325,10 @@ module Parcom
       @p = Sequence.new(ps)
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, Array(T))
+    def parse(tokens : Tokens(T)) : Result(T, Array(T))
       @p.parse(tokens)
-    rescue ex : ParserException
-      raise ParserException.new("Tokens: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("TokenSeq: #{ex.message}")
     end
   end
 
@@ -336,7 +336,7 @@ module Parcom
     def initialize(@p : Parser(T, V))
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, Array(V))
+    def parse(tokens : Tokens(T)) : Result(T, Array(V))
       parsed = [] of V
 
       loop do
@@ -350,8 +350,8 @@ module Parcom
       end
 
       Result.new(tokens, parsed)
-    rescue ex : ParserException
-      raise ParserException.new("Many: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("Many: #{ex.message}")
     end
   end
 
@@ -362,10 +362,10 @@ module Parcom
       @p = Many.new(p).assert { |arr| !arr.empty? }
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, Array(V))
+    def parse(tokens : Tokens(T)) : Result(T, Array(V))
       @p.parse(tokens)
-    rescue ex : ParserException
-      raise ParserException.new("Some: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("Some: #{ex.message}")
     end
   end
 
@@ -377,10 +377,10 @@ module Parcom
       @p = Sequence.new(([p] of Parser(T, V)) * i)
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, Array(V))
+    def parse(tokens : Tokens(T)) : Result(T, Array(V))
       @p.parse(tokens)
-    rescue ex : ParserException
-      raise ParserException.new("Exactly: #{ex.message}")      
+    rescue ex : ParserFail
+      raise ParserFail.new("Exactly: #{ex.message}")      
     end
   end
 
@@ -393,10 +393,10 @@ module Parcom
       end
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, Array(V))
+    def parse(tokens : Tokens(T)) : Result(T, Array(V))
       @p.parse(tokens)
-    rescue ex : ParserException
-      raise ParserException.new("AtLeast: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("AtLeast: #{ex.message}")
     end
   end
 
@@ -407,10 +407,10 @@ module Parcom
       @p = Exactly.new(i, Optional.new(p)).map(&.compact)
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, Array(V))
+    def parse(tokens : Tokens(T)) : Result(T, Array(V))
       @p.parse(tokens)
-    rescue ex : ParserException
-      raise ParserException.new("AtMost: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("AtMost: #{ex.message}")
     end
   end
 
@@ -425,10 +425,10 @@ module Parcom
       end
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, Array(V))
+    def parse(tokens : Tokens(T)) : Result(T, Array(V))
       @p.parse(tokens)
-    rescue ex : ParserException
-      raise ParserException.new("Between: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("Between: #{ex.message}")
     end
   end
 
@@ -452,10 +452,10 @@ module Parcom
       end
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, V)
+    def parse(tokens : Tokens(T)) : Result(T, V)
       @p.parse(tokens)
-    rescue ex : ParserException
-      raise ParserException.new("FirstOf: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("FirstOf: #{ex.message}")
     end
   end
 
@@ -468,10 +468,10 @@ module Parcom
       end
     end
 
-    def parse(tokens : TokenStream(T)) : Result(T, Array(V))
+    def parse(tokens : Tokens(T)) : Result(T, Array(V))
       @p.parse(tokens)
-    rescue ex : ParserException
-      raise ParserException.new("SepBy: #{ex.message}")
+    rescue ex : ParserFail
+      raise ParserFail.new("SepBy: #{ex.message}")
     end
   end
 end
-- 
cgit v1.2.1