refactor Itemizer implementations to reduce duplication and get rid o…

…f unnecessary low-level muddling

unparse/combinators.py

@@ -294,14 +294,14 @@ def f(xs, s):
 
 class Itemizer(object):
 
-    def __init__(self, itemP):
+    def __init__(self, item):
         '''
-        itemP :: [t] -> s -> MaybeError e (t, [t], s)
-        `itemP` is the most basic parser and should:
+        item :: Parser e s (m t) t
+        `item` is the most basic parser and should:
          - succeed, consuming one single token if there are any tokens left
          - fail if there are no tokens left
         '''
-        self.item = Parser(itemP)
+        self.item = item
 
     def literal(self, x):
         '''
@@ -333,7 +333,7 @@ def oneOf(self, elems):
         return self.satisfy(lambda x: x in c_set)
 
 
-def _item_basic(xs, s):
+def _f_item_basic(xs, s):
     '''
     Simply consumes a single token if one is available, presenting that token
     as the value.  Fails if token stream is empty.
@@ -343,38 +343,21 @@ def _item_basic(xs, s):
     first, rest = xs.first(), xs.rest()
     return good(first, rest, s)
 
-def _bump(c, p):
-    line, col = p
-    if c == '\n':
+basic = Itemizer(Parser(_f_item_basic))
+
+def _bump(char, position):
+    line, col = position
+    if char == '\n':
         return (line + 1, 1)
     return (line, col + 1)
 
-def _item_position(xs, position):
-    '''
-    Does two things:
-     - consumes a single token if available, failing otherwise (see `_item_basic`)
-     - updates the position info in state -- `\n` is a newline
-     
-    This assumes that the state is a 2-tuple of integers, (line, column).
-    '''
-    if xs.isEmpty():
-        return M.zero
-    first, rest = xs.first(), xs.rest()
-    return good(first, rest, _bump(first, position))
-
-def _item_count(xs, ct):
-    '''
-    Does two things:
-      1. see `_item_basic`
-      2. increments a counter -- which tells how many tokens have been consumed
-    '''
-    if xs.isEmpty():
-        return M.zero
-    first, rest = xs.first(), xs.rest()
-    return good(first, rest, ct + 1)
+def _f_position(c):
+    return seq2R(updateState(lambda s: _bump(c, s)), pure(c))
 
+_item_position = bind(basic.item, _f_position)
 position = Itemizer(_item_position)
-basic = Itemizer(_item_basic)
+
+_item_count = seq2L(basic.item, updateState(lambda x: x + 1))
 count = Itemizer(_item_count)