Basic Examples (13) 

Create an AST pattern that will match any CallNode or LeafNode generated by CodeParse:

In[1]:=

Out[1]=

Specify a head:

In[2]:=

Out[2]=

A function with two arguments:

In[3]:=

Out[3]=

A function with any number of arguments:

In[4]:=

Out[4]=

A named Pattern:

In[5]:=

Out[5]=

A Repeated pattern:

In[6]:=

Out[6]=

A Verbatim pattern:

In[7]:=

Out[7]=

A PatternSequence:

In[8]:=

Out[8]=

A pattern for unevaluated code wrapped in HoldPattern:

In[9]:=

Out[9]=

A PatternTest:

In[10]:=

Out[10]=

A Condition:

In[11]:=

Out[11]=

Duplicate pattern bindings:

In[12]:=

Out[12]=

Nested patterns:

In[13]:=

Out[13]=

Scope (3) 

Use the second argument of ASTPattern to match node metadata:

In[14]:=

Out[14]=

Match only nodes that start on a particular line:

In[15]:=

Out[15]=

Bind parts of metadata in pattern names:

In[16]:=

Out[16]=

In[17]:=

Out[17]=

In[18]:=

Out[18]=

Applications (2) 

Parse a Wolfram Language file to get an abstract syntax tree:

In[19]:=

Out[19]=

Extract all nodes from the AST that correspond to a pattern:

In[20]:=

Out[20]=

Convert to expressions:

In[21]:=

Out[21]=

Extract source positions:

In[22]:=

Out[22]=

Extract the corresponding parts of the file as strings:

In[23]:=

Out[23]=

Create a CodeCases function:

In[24]:=

In[25]:=

Out[25]=

Compare to string matching:

In[26]:=

Out[26]=

This incorrectly matched part of the usage message as code:

In[27]:=

Out[27]=

When matching against the AST, there's no need to account for different types of input syntax:

In[28]:=

Out[28]=

Properties and Relations (4) 

The single-argument form of ASTPattern is effectively invisible to an outer ASTPattern:

In[29]:=

Out[29]=

In[30]:=

Out[30]=

In[31]:=

Out[31]=

The two-argument form inserts the corresponding metadata patterns:

In[32]:=

Out[32]=

Get an AST node corresponding to a simple expression:

In[33]:=

Out[33]=

For simple patterns, the performance of matching an ASTPattern is comparable to normal pattern matching:

In[34]:=

Out[34]=

In[35]:=

Out[35]=

In[36]:=

Out[36]=

Matching patterns that require evaluation typically incur significant cost as an ASTPattern:

In[37]:=

Out[37]=

In[38]:=

Out[38]=

Compare to normal pattern matching:

In[39]:=

Out[39]=

Some pattern tests allow for optimized patterns:

In[40]:=

Out[40]=

In[41]:=

Out[41]=

In[42]:=

Out[42]=

In[43]:=

Out[43]=

This will only work for certain pattern tests that appear literally:

In[44]:=

Out[38]=

Pattern bindings that stay within ASTPattern correspond to expressions:

In[45]:=

Out[41]=

Once a value passes outside of ASTPattern, the binding corresponds to the AST node:

In[46]:=

Out[46]=

Note that all instances of the pattern symbol appear below ASTPattern in this case:

In[47]:=

Out[47]=

In this case, there is an x that's "lifted" out of the ASTPattern, which is why it appears as an AST node:

In[48]:=

Out[48]=

Possible Issues (4) 

ASTPattern cannot generalize to all possible WL patterns:

In[49]:=

Out[49]=

In[50]:=

Out[50]=

In[51]:=

Out[51]=

In this case, the pattern binding prevents matching, since the metadata will always be different between nodes:

In[52]:=

Out[52]=

In[53]:=

Out[53]=

Without any repeated binding this pattern will match:

In[54]:=

Out[54]=

Not all raw patterns are supported by ASTPattern:

In[55]:=

Out[55]=

In[56]:=

Out[56]=

In[57]:=

Out[57]=

In[58]:=

Out[58]=

Unsupported patterns are represented verbatim:

In[59]:=

Out[59]=

In[60]:=

Out[60]=

ASTPattern ignores the Unevaluated wrapper:

In[61]:=

Out[61]=

In[62]:=

Out[62]=

Use HoldPattern instead:

In[63]:=

Out[63]=

In[64]:=

Out[64]=

ASTPattern must evaluate in order to create the desired pattern, so it should not be wrapped in HoldPattern:

In[65]:=

Out[65]=

Use HoldPattern within ASTPattern instead:

In[66]:=

Out[66]=