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)