# Cases

Cases[{e1,e2,},pattern]

gives a list of the ei that match the pattern.

Cases[{e1,},patternrhs]

gives a list of the values of rhs corresponding to the ei that match the pattern.

Cases[expr,pattern,levelspec]

gives a list of all parts of expr on levels specified by levelspec that match the pattern.

Cases[expr,patternrhs,levelspec]

gives the values of rhs that match the pattern.

Cases[expr,pattern,levelspec,n]

gives the first n parts in expr that match the pattern.

Cases[pattern]

represents an operator form of Cases that can be applied to an expression.

# Details and Options

• The first argument to Cases need not have head List.
• When used on an Association, Cases picks out elements according to their values.
• Cases[expr,pattern:>rhs] evaluates rhs only when the pattern is found.
• Cases[pattern][list] is equivalent to Cases[list,pattern].
• Cases uses standard level specifications:
•  n levels 1 through n Infinity levels 1 through Infinity {n} level n only {n1,n2} levels n1 through n2
• The default value for levelspec in Cases is {1}.
• A positive level n consists of all parts of expr specified by n indices.
• A negative level -n consists of all parts of expr with depth n.
• Level -1 consists of numbers, symbols, and other objects that do not have subparts.
• Level 0 corresponds to the whole expression.
• With the option setting , Cases looks at heads of expressions, and their parts.
• Cases traverses the parts of expr in a depth-first order, with leaves visited before roots.

# Examples

open allclose all

## Basic Examples(4)

Find cases that explicitly match integers:

Find cases that do not match integers:

Return the x from inside each f[x_] matched:

Use the operator form of Cases:

Pick elements from an Association:

## Scope(10)

Find all cases of lists of two elements:

Find the sum of every pair of elements:

Pick out elements that are not 0:

Pick out cases of integers down to level 2:

Return only the first three matching elements:

Use :> to evaluate only after explicit elements have been found:

Find all possible subexpressions at any level:

Find all possible subexpressions at any level, including the head of the expression:

Pick elements from nested associations:

Pick elements from a List matching an Association:

Find keys of each matching Association:

Pick pairs of keys from each association in a list:

Find associations with the key satisfying a condition:

## Options(1)

Find symbols among the elements of an expression:

Also include the head of the expression in the search:

## Properties & Relations(1)

Count returns the length of the result given by Cases:

## Possible Issues(1)

A rule transforms the matching elements into its right side:

Use HoldPattern to treat the rule itself as a pattern:

Wolfram Research (1988), Cases, Wolfram Language function, https://reference.wolfram.com/language/ref/Cases.html (updated 2014).

#### Text

Wolfram Research (1988), Cases, Wolfram Language function, https://reference.wolfram.com/language/ref/Cases.html (updated 2014).

#### BibTeX

@misc{reference.wolfram_2020_cases, author="Wolfram Research", title="{Cases}", year="2014", howpublished="\url{https://reference.wolfram.com/language/ref/Cases.html}", note=[Accessed: 24-January-2021 ]}

#### BibLaTeX

@online{reference.wolfram_2020_cases, organization={Wolfram Research}, title={Cases}, year={2014}, url={https://reference.wolfram.com/language/ref/Cases.html}, note=[Accessed: 24-January-2021 ]}

#### CMS

Wolfram Language. 1988. "Cases." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2014. https://reference.wolfram.com/language/ref/Cases.html.

#### APA

Wolfram Language. (1988). Cases. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/Cases.html