fix: use Converter for derived rules

If rule is a rule returning other rule with semantic action it
generates Converter rule to convert result of the 1st rule semantic
action using semantic action provided to the derived rule

parsed/Generate.py

@@ -136,13 +136,14 @@ def __getitem__(self, k):
         return mk_rule_range(self, r, self._next_child_name)
 
     def __gt__(self, action):
-        if self._action == action:
-            return self
-        res = self.copy
         if action.__name__ == '<lambda>':
             action.__name__ = ''.join(['!', self.name])
-        res._action = action
-        return res
+        if isinstance(self, TopRule):
+            return Converter(self, self.name, action)
+        if self._action == action:
+            return self
+        self._action = action
+        return self
 
     @property
     def action(self):
@@ -210,7 +211,13 @@ def copy(self):
         return self.__class__(self.rule, self.name, self.default_action)
 
     def _prepare_context(self, options):
-            return self.rule(options)
+        return self.rule(options)
+
+class Converter(Modifier):
+
+    def __init__(self, rule, name, action):
+        super(Converter, self).__init__(rule, name, action)
+        self.fn = convert
 
 class Aggregate(Rule):
 
@@ -236,8 +243,6 @@ def __init__(self, fn):
     def _mk_parser(self, name, generator, action, options):
         rule = generator()
         rule.name = '.'.join([name, rule.name])
-        if action is not None:
-            rule._action = action
         parser = rule(options)
         return parser
 

parsed/Rules.py

@@ -395,6 +395,18 @@ def fn(src):
     fn.children = list((test,))
     return fn
 
+def convert(name, test, action, options):
+    @rule(name, options)
+    def fn(src):
+        pos, value = test.match(src)
+        if value != nomatch:
+            value = action(value)
+            return (pos, value) if value != nomatch else _nomatch_res
+        else:
+            return _nomatch_res
+    fn.children = list((test,))
+    return fn
+
 def lookahead(name, test, conv, options):
     @rule(name, options)
     def fn(src):