update indexed grammars tests and utils

pyformlang/indexed_grammar/indexed_grammar.py

@@ -15,7 +15,7 @@
 from .production_rule import ProductionRule
 from .consumption_rule import ConsumptionRule
 from .end_rule import EndRule
-from .utils import exists, addrec_bis
+from .utils import addrec_bis
 from ..objects.cfg_objects.utils import to_variable
 
 
@@ -47,9 +47,9 @@ def __init__(self,
             self._marked[non_terminal_a].add(temp)
         # Mark all end symbols
         for non_terminal_a in non_terminals:
-            if exists(self._rules.rules,
-                      lambda x: isinstance(x, EndRule)
-                      and x.left_term == non_terminal_a):
+            if any(map(lambda x: isinstance(x, EndRule)
+                       and x.left_term == non_terminal_a,
+                       self._rules.rules)):
                 self._marked[non_terminal_a].add(frozenset())
 
     @property

pyformlang/indexed_grammar/tests/test_rules.py

@@ -17,18 +17,17 @@ class TestIndexedGrammar:
 
     def test_consumption_rules(self):
         """ Tests the consumption rules """
-        conso = ConsumptionRule("end", "C", "T")
-        terminals = conso.terminals
+        consumption = ConsumptionRule("end", "C", "T")
+        terminals = consumption.terminals
         assert terminals == {"end"}
-        representation = str(conso)
+        representation = str(consumption)
         assert representation == "C [ end ] -> T"
 
     def test_duplication_rules(self):
         """ Tests the duplication rules """
-        dupli = DuplicationRule("B0", "A0", "C")
-        assert dupli.terminals == set()
-        assert str(dupli) == \
-                         "B0 -> A0 C"
+        duplication = DuplicationRule("B0", "A0", "C")
+        assert duplication.terminals == set()
+        assert str(duplication) == "B0 -> A0 C"
 
     def test_end_rule(self):
         """ Tests the end rules """
@@ -39,9 +38,9 @@ def test_end_rule(self):
 
     def test_production_rules(self):
         """ Tests the production rules """
-        produ = ProductionRule("S", "C", "end")
-        assert produ.terminals == {"end"}
-        assert str(produ) == "S -> C [ end ]"
+        production = ProductionRule("S", "C", "end")
+        assert production.terminals == {"end"}
+        assert str(production) == "S -> C [ end ]"
 
     def test_rules(self):
         """ Tests the rules """

pyformlang/indexed_grammar/utils.py

@@ -2,21 +2,7 @@
 
 # pylint: disable=cell-var-from-loop
 
-from typing import Callable, List, Set, Iterable, Any
-
-
-def exists(list_elements: List[Any],
-           check_function: Callable[[Any], bool]) -> bool:
-    """exists
-    Check whether at least an element x of l is True for f(x)
-    :param list_elements: A list of elements to test
-    :param check_function: The checking function (takes one parameter and  \
-    return a boolean)
-    """
-    for element in list_elements:
-        if check_function(element):
-            return True
-    return False
+from typing import List, Set, Iterable, Any
 
 
 def addrec_bis(l_sets: Iterable[Any],
@@ -58,7 +44,7 @@ def addrec_ter(l_sets: List[Any], marked_left: Set[Any]) -> bool:
     # End condition, nothing left to process
     temp_in = [x[0] for x in l_sets]
     exists_after = [
-        exists(l_sets[index + 1:], lambda x: x[0] == l_sets[index][0])
+        any(map(lambda x: x[0] == l_sets[index][0], l_sets[index + 1:]))
         for index in range(len(l_sets))]
     exists_before = [l_sets[index][0] in temp_in[:index]
                      for index in range(len(l_sets))]