Wolfram Language Paclet Repository
Community-contributed installable additions to the Wolfram Language
Introduction to DiffTools
The Wolfram/DiffTools paclet provides features for finding, managing, and viewing changes between various types of expressions.
Load the paclet:
In[1]:=
Needs["Wolfram`DiffTools`"]
Diff
The main function in the Wolfram/DiffTools paclet is . When comparing two expressions, will automatically find the differences between them, and prepare a result to express those changes visually. Note that not all expressions are currently supported by . More about that below.
In[2]:=
 | Diff |
Out[2]=
The output of is a formatted , which is a computable object that happens to display as a interface for "browsing" the diff. There are a variety of formats available for viewing a , most of which are accessible in this output. You can go straight to a particular format by specifying the name of that format as the 3rd argument to . In the case of string comparisons, other formats include and .
"Separate"
"CharacterAlignment"
Compare two strings, and do not combine the strings in the result:
In[3]:=
| Diff |
Out[3]=
{,}
This is a te
st
This is a
no
th
er example
Compare two strings, and show how the characters align:
In[4]:=
| Diff |
Out[4]=
The function takes options as well. The option indicates which elements of the given expressions should be the focus of the diff. For example, when comparing two strings, they are by default compared character by character. But by providing a granularity of , you can change that behavior.
"Words"
Compare the words in two strings:
In[5]:=
| Diff |
 | DiffGranularity |
Out[5]=
Note that not all expression heads are supported by at this time. Supported heads include: , , , , , , , and .
Of course, strings and cells can be used to contain arbitrary expressions. So if you have expressions with heads that aren't among those explicitly supported, coercing them to one of the supported expression types can be done with the option. The setting for that option is taken to be a function to be applied to the given inputs before they are diffed.
In[6]:=
| Diff |
1
1-
3
x
1
1-
3
y
| DiffInputFunction |
Out[6]=
also supports a small number of string settings, specifying common operations, like coercing the expressions to their strings.
In[7]:=
| Diff |
1
1-
3
x
1
1-
3
y
| DiffInputFunction |
Out[7]=
In[8]:=
| Diff |
1
1-
3
x
2
1-
3
x
| DiffInputFunction |
Out[8]=
DiffObject
The high-level function conveniently combines finding and viewing of differences. In practice, that is often exactly what you want. But there may be times when you want to compare two expressions once, and view those changes in multiple different ways. Or perhaps you want to store such changes in a computable form, that you can then use to transform other expressions.
In fact, the expression typically returned by the function is a . This computable object can be visualized in different ways by the function, and can be used to transform expressions via .
a symbolic representation of those changes | |
Low-level functions in Wolfram/DiffTools.
Find the changes that would transform one string to another:
In[9]:=
obj=
["This is a test","This is another example","SummaryBox"]
 | Diff |
Out[9]=
DiffObject
 |
|
We won't document the structure of a here, but one can ask an object for its available properties in the usual way:
List all available properties:
In[10]:=
obj["Properties"]
Out[10]=
{Type,Data,Changes,Matches,Additions,Removals,Edits,Conflicts,TypesetElements,SummaryString,LabeledChanges,MetadataInfo}
Extract a summary:
In[11]:=
obj["SummaryString"]
Out[11]=
12 insertions, 3 deletions
You can view a in various formats with the function. More about that in the next section.
In[12]:=
| DiffView |
Out[12]=
This is a
no
th
est
r example
Produce a non-default view:
In[13]:=
| DiffView |
Out[13]=
{,}
This is a te
st
This is a
no
th
er example
This contains information about what string operations would be required to transform the original string into the new string. In fact, can take a along with the original string and do just that:
In[14]:=
| DiffApply |
Out[14]=
This is another example
Note that knows that the for a string stores string positions for each change. That is what allows to work on the original string. That also means it is possible to apply such changes to other strings. Of course, that is not always a sensible thing to do:
Apply changes to a string with the same initial segment as the original:
In[15]:=
| DiffApply |
Out[15]=
This is another example of DiffApply.
Corrupt a string by applying changes that were not intended for it:
In[16]:=
| DiffApply |
Out[16]=
If you thnonhkr examplehis is a test, you're mistaken.
An occasionally useful operation one can perform on a is to reverse it. If is the for turning into , then will return a for turning into .
obj
expr1
expr2
expr2
expr1
Apply reversed changes to the second string:
In[17]:=
| DiffApply |
| DiffInvert |
DiffView
Find the changes from one list to another:
View those changes in a non-standard format:
View those changes in different formats:
The available formats depend on how the expressions were compared. As we've already seen, a string comparison supports combined or separated views. But if you want to view the changes as line-by-line, then computing the changes should focus on lines to begin with.
Focusing on different elements can produce different types of changes:
Cells and Notebooks
The Wolfram/DiffTools paclet also includes functions that can find and visualize differences between cells and notebooks. This is especially useful when working with notebook files in version control systems like CVS or GIT, where a textual comparison of the ASCII contents of notebook files is often difficult to visually parse.
When viewing the changes between notebooks, the default behavior is to display a summary box, with the option of viewing a so-called report notebook, which includes information about which cells have been added, removed, or edited.
Open a report describing the diffs:
Ignore all changes in cell options:
Compare notebook files:
Two-way and Three-way Diffs
In addition to comparing one expression against another, Wolfram/DiffTools includes some support for so-called 3-way diffs. This is useful when you're interested in taking two different edits from a common starting point, and seeing if those edits can be cleanly merged with one another. When they can't -- for instance, if both edits change the same piece of the original in incompatible ways -- then human judgement may be needed to resolve the conflict.
Compute and visualize a simple 3-way diff:
A 3-way diff with additions and removals:
Some 3-way diffs may have conflicting changes: