Details and Options

• ExpressionTree can construct Tree objects from lists, arrays, rules, XML and arbitrary expressions as specified.
• Possible forms for struct for arbitrary expressions include: »
• "HeadTrees"trees corresponding to heads of subexpressions of the expression by level "Heads"heads of subexpressions of the expression by level "Subexpressions"subexpressions of the expression by level "Atoms"atomic subexpressions of the expression at level -1 Nullsubexpressions of the expression by level with no data Nonethe expression itself
• ExpressionTree takes the same options as Tree.
• Additional options of ExpressionTree include:
• Heads include heads of expressions and their parts as subtrees
• Possible structures for the expression f[a,b][g[1,2],x] with the default option setting HeadsFalse include:

• Versions of these structures with the option setting HeadsTrue include: »

• Held forms for struct for arbitrary expressions include:
• "HeldHeadTrees"trees corresponding to held heads of subexpressions of the expression by level "HeldHeads"held heads of subexpressions of the expression by level "HeldSubexpressions"held subexpressions of the expression by level "HeldAtoms"held atomic subexpressions of the expression at level -1
• Possible forms for struct for common types of expressions include:
• "XML"tags, attributes and elements of an XML object
• Possible forms for struct for nested lists and associations include: »
• "List"elements of nested lists "Association"elements of nested associations "Dataset"headers and data of a dataset
• Possible forms for struct for nested rules include: »
• "Rules"left-hand sides and leaves of nested rules "JSON"names and values of a JSON object, using names as data "RawJSON"names and values of a JSON object, using names as keys "FileSystem"directories and files in a file system

Examples

Basic Examples  (4)

Construct a tree from the structure of an expression:

Include heads:

Specify the structure to use:

Construct a tree from symbolic XML:

Construct a tree from an unevaluated expression:

Construct a tree from nested associations:

Scope  (14)

Arbitrary Expressions  (6)

"HeadTrees"  (1)

If AtomQ[head] gives True, then ExpressionTree[head[arg₁,arg₂,…],"HeadTrees"] gives a tree with root containing head and with children given by the ExpressionTree[arg_i,"HeadTrees"]:

If AtomQ[head] gives False, then ExpressionTree[head[arg₁,arg₂,…],"HeadTrees"] gives a tree with root containing ExpressionTree[head,"HeadTrees"] rather than head:

Include heads:

ExpressionTree[atom,"HeadTrees"] gives a leaf containing the atomic expression atom:

"Heads"  (1)

ExpressionTree[head[arg₁,arg₂,…],"Heads"] gives a tree with root containing head and with children given by the ExpressionTree[arg_i,"Heads"]:

Include heads:

ExpressionTree[atom,"Heads"] gives a leaf containing the atomic expression atom:

"Subexpressions"  (1)

ExpressionTree[expr₀[expr₁,expr₂,…],"Subexpressions"] gives a tree with root containing expr₀[expr₁,expr₂,…] and with children given by the ExpressionTree[expr_i,"Subexpressions"]:

Include heads:

ExpressionTree[atom,"Subexpressions"] gives a leaf containing the atomic expression atom:

"Atoms"  (1)

ExpressionTree[expr₀[expr₁,expr₂,…],"Atoms"] gives a tree with children given by the ExpressionTree[expr_i,"Atoms"]:

Include heads:

ExpressionTree[atom,"Atoms"] gives a leaf containing the atomic expression atom:

Null  (1)

ExpressionTree[expr₀[expr₁,expr₂,…],Null] gives a tree with children given by the ExpressionTree[expr_i,Null]:

Include heads:

ExpressionTree[atom,Null] gives a leaf containing Null for an atomic expression atom:

None  (1)

ExpressionTree[expr,None] gives a leaf containing expr:

Common Expressions  (1)

"XML"  (1)

Construct a tree from symbolic XML:

Nested Lists and Associations  (3)

"List"  (1)

Construct a tree from nested lists:

"Association"  (1)

Construct a tree from nested associations:

"Dataset"  (1)

Construct a tree from nested lists and associations:

Nested Rules  (4)

"Rules"  (1)

Construct a tree from nested rules:

"JSON"  (1)

Construct a tree from JSON rules:

"RawJSON"  (1)

Construct a tree from JSON associations:

"FileSystem"  (1)

Construct a tree from a nested association with file names as keys:

Options  (11)

Heads  (2)

With the default option setting HeadsFalse, heads of expressions are not included as part of any level:

With HeadsTrue, heads are included just like other elements of expressions:

Structures for arbitrary expressions do not include heads by default:

Include heads:

Styling Individual Tree Elements  (2)

Specify the label for the generated tree element:

Specify labels and styles for subtrees by position:

Styling Entire Tree  (4)

Specify labels and styles for all subtrees:

Specify the base style:

Specify the style for both the edges and the edges of the tree elements:

Specify the base style and styles for individual tree elements:

Tree Layout and Graphics Options  (3)

Specify the orientation for the root:

Specify a named embedding:

Specify Graphics options:

Applications  (1)

Construct a tree from the structure of a complicated antiderivative:

Properties & Relations  (15)

Construct a tree from an expression:

Get back the original expression:

Transform a tree into an expression:

Transform the resulting expression back into a tree:

Construct trees from groupings of a list:

With the default structure "HeadTrees", ExpressionTree constructs a tree with subtrees containing data giving the tree structure of the heads of subexpressions:

The structure "Heads" gives a tree representing the same data as "HeadTrees", but with subtrees containing the heads of subexpressions themselves:

ExpressionTree[expr,"Heads"] gives output similar to TreeForm[expr]:

The structure "Subexpressions" gives a tree with the same shape as the one given by "Heads", but with data containing the subexpressions themselves rather than their heads:

The subtrees of the tree on level n correspond to the parts of the expression on level n, excluding heads:

Include heads:

The structure "Atoms" gives a tree with the same shape as the one given by "Subexpressions", but storing data only in the leaf nodes:

The structure Null gives a tree with the same shape but no data:

Construct a tree from the heads in an expression:

Use TreeFold to insert a parent node above each subtree:

This corresponds to mapping on the arguments in an expression:

Map maps on the arguments in an expression by default:

Construct a tree from the atoms in an expression:

Use TreeFold to insert a sibling node before each subtree:

This corresponds to mapping on the subexpressions in an expression:

Map maps on the subexpressions in an expression with HeadsTrue:

Construct a tree from the heads in an expression:

TreeMap maps on the data of subtrees in a tree:

This corresponds to mapping on the heads and leaves in an expression:

Map can map on the heads and leaves directly:

Construct a tree from the atoms in an expression:

TreeMap can map on the data of just the leaves in a tree:

This corresponds to mapping on the atoms in an expression:

Map can map on the atoms in an expression directly:

Depth[expr] is equivalent to TreeDepth[ExpressionTree[expr]]+1:

Depth[expr,HeadsTrue] is equivalent to TreeDepth[ExpressionTree[expr,"Subexpressions"]]+1:

ExpressionTree evaluates subexpressions before constructing the tree:

Use Unevaluated to defer evaluation of subexpressions until after the tree is constructed:

Held structures ensure that subexpressions are wrapped in HoldForm to prevent all evaluation:

Show the HoldComplete wrappers:

Construct a tree from an inactive expression: