simplify constructors of enfa, pda and cfg, use hashable in fcfg constructor

Author: bygu4

pyformlang/cfg/cfg.py

@@ -47,16 +47,12 @@ def __init__(self,
                  start_symbol: Hashable = None,
                  productions: Iterable[Production] = None) -> None:
         super().__init__()
-        if variables is not None:
-            variables = {to_variable(x) for x in variables}
-        self._variables = variables or set()
-        if terminals is not None:
-            terminals = {to_terminal(x) for x in terminals}
-        self._terminals = terminals or set()
+        self._variables = {to_variable(x) for x in variables or set()}
+        self._terminals = {to_terminal(x) for x in terminals or set()}
+        self._start_symbol = None
         if start_symbol is not None:
-            start_symbol = to_variable(start_symbol)
-            self._variables.add(start_symbol)
-        self._start_symbol = start_symbol
+            self._start_symbol = to_variable(start_symbol)
+            self._variables.add(self._start_symbol)
         self._productions = set()
         for production in productions or set():
             self.add_production(production)

pyformlang/finite_automaton/epsilon_nfa.py

@@ -65,24 +65,14 @@ def __init__(
             start_states: AbstractSet[Hashable] = None,
             final_states: AbstractSet[Hashable] = None) -> None:
         super().__init__()
-        if states is not None:
-            states = {to_state(x) for x in states}
-        self._states = states or set()
-        if input_symbols is not None:
-            input_symbols = {to_symbol(x) for x in input_symbols}
-        self._input_symbols = input_symbols or set()
+        self._states = {to_state(x) for x in states or set()}
+        self._input_symbols = {to_symbol(x) for x in input_symbols or set()}
         self._transition_function = transition_function \
             or NondeterministicTransitionFunction()
-        if start_states is not None:
-            start_states = {to_state(x) for x in start_states}
-        self._start_states = start_states or set()
-        if final_states is not None:
-            final_states = {to_state(x) for x in final_states}
-        self._final_states = final_states or set()
-        for state in self._final_states:
-            self._states.add(state)
-        for state in self._start_states:
-            self._states.add(state)
+        self._start_states = {to_state(x) for x in start_states or set()}
+        self._states.update(self._start_states)
+        self._final_states = {to_state(x) for x in final_states or set()}
+        self._states.update(self._final_states)
 
     def _get_next_states_iterable(
             self,

pyformlang/pda/pda.py

@@ -69,33 +69,23 @@ def __init__(self,
                  transition_function: TransitionFunction = None,
                  start_state: Hashable = None,
                  start_stack_symbol: Hashable = None,
-                 final_states: AbstractSet[Hashable] = None):
+                 final_states: AbstractSet[Hashable] = None) -> None:
         # pylint: disable=too-many-arguments
-        if states is not None:
-            states = {to_state(x) for x in states}
-        if input_symbols is not None:
-            input_symbols = {to_symbol(x) for x in input_symbols}
-        if stack_alphabet is not None:
-            stack_alphabet = {to_stack_symbol(x) for x in stack_alphabet}
-        if start_state is not None:
-            start_state = to_state(start_state)
-        if start_stack_symbol is not None:
-            start_stack_symbol = to_stack_symbol(start_stack_symbol)
-        if final_states is not None:
-            final_states = {to_state(x) for x in final_states}
-        self._states: Set[State] = states or set()
-        self._input_symbols: Set[PDASymbol] = input_symbols or set()
-        self._stack_alphabet: Set[StackSymbol] = stack_alphabet or set()
+        self._states = {to_state(x) for x in states or set()}
+        self._input_symbols = {to_symbol(x) for x in input_symbols or set()}
+        self._stack_alphabet = {to_stack_symbol(x)
+                                for x in stack_alphabet or set()}
         self._transition_function = transition_function or TransitionFunction()
-        self._start_state: Optional[State] = start_state
+        self._start_state = None
         if start_state is not None:
-            self._states.add(start_state)
-        self._start_stack_symbol: Optional[StackSymbol] = start_stack_symbol
+            self._start_state = to_state(start_state)
+            self._states.add(self._start_state)
+        self._start_stack_symbol = None
         if start_stack_symbol is not None:
-            self._stack_alphabet.add(start_stack_symbol)
-        self._final_states: Set[State] = final_states or set()
-        for state in self._final_states:
-            self._states.add(state)
+            self._start_stack_symbol = to_stack_symbol(start_stack_symbol)
+            self._stack_alphabet.add(self._start_stack_symbol)
+        self._final_states = {to_state(x) for x in final_states or set()}
+        self._states.update(self._final_states)
 
     @property
     def states(self) -> Set[State]: