def apply(self, items, pattern, ls, evaluation, options): "Cases[items_, pattern_, ls_:{1}, OptionsPattern[]]" if items.is_atom(): return Expression(SymbolList) from mathics.builtin.patterns import Matcher if ls.has_form("Rule", 2): if ls.leaves[0].get_name() == "System`Heads": heads = ls.leaves[1].is_true() ls = Expression("List", 1) else: return evaluation.message("Position", "level", ls) else: heads = self.get_option(options, "Heads", evaluation).is_true() try: start, stop = python_levelspec(ls) except InvalidLevelspecError: return evaluation.message("Position", "level", ls) results = [] if pattern.has_form("Rule", 2) or pattern.has_form("RuleDelayed", 2): match = Matcher(pattern.leaves[0]).match rule = Rule(pattern.leaves[0], pattern.leaves[1]) def callback(level): if match(level, evaluation): result = rule.apply(level, evaluation) result = result.evaluate(evaluation) results.append(result) return level else: match = Matcher(pattern).match def callback(level): if match(level, evaluation): results.append(level) return level walk_levels(items, start, stop, heads=heads, callback=callback) return Expression(SymbolList, *results)
def apply_ls_n(self, items, pattern, levelspec, n, evaluation): "DeleteCases[items_, pattern_, levelspec_:1, n_:System`Infinity]" if items.is_atom(): evaluation.message("Select", "normal") return # If levelspec is specified to a non-trivial value, # we need to proceed with this complicate procedure # involving 1) decode what is the levelspec means # 2) find all the occurences # 3) Set all the occurences to ```System`Nothing``` levelspec = python_levelspec(levelspec) if n == Symbol("Infinity"): n = -1 elif n.get_head_name() == "System`Integer": n = n.get_int_value() if n < 0: evaluation.message( "DeleteCases", "innf", Expression("DeleteCases", items, pattern, levelspec, n), ) else: evaluation.message( "DeleteCases", "innf", Expression("DeleteCases", items, pattern, levelspec, n), ) return SymbolNull if levelspec[0] != 1 or levelspec[1] != 1: return deletecases_with_levelspec(items, pattern, evaluation, levelspec, n) # A more efficient way to proceed if levelspec == 1 from mathics.builtin.patterns import Matcher match = Matcher(pattern).match if n == -1: def cond(leaf): return not match(leaf, evaluation) return items.filter("List", cond, evaluation) else: def condn(leaf): nonlocal n if n == 0: return True elif match(leaf, evaluation): n = n - 1 return False else: return True return items.filter("List", condn, evaluation)
def apply(self, rules, pattern, evaluation): 'FilterRules[rules_List, pattern_]' from mathics.builtin.patterns import Matcher match = Matcher(pattern).match def matched(): for rule in rules.leaves: if rule.has_form('Rule', 2) and match(rule.leaves[0], evaluation): yield rule return Expression('List', *list(matched()))
def apply_pattern(self, items, sel, pattern, evaluation): "Pick[items_, sel_, pattern_]" from mathics.builtin.patterns import Matcher match = Matcher(pattern).match return self._do(items, sel, lambda s: match(s, evaluation), evaluation)