Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

▼NMercury
▼NExceptions
CErrorActionException	Exception thrown by basic actions when a problem was encountered.
CInterpretingException	An exception thrown because of problems in the Interpreting namespace.
CInvalidActionArgumentException	An exception representing a problem while type checking the Mercury.Interpreting.RewriteRule{T}.
CInvalidActionCallException	An exception representing a problem with Mercury.Interpreting.ActionCall{T}
CInvalidActionException	An exception representing a problem with Mercury.Interpreting.InterpreterAction{T} class.
CInvalidEdgeException	An exception thrown when attempting to create an invalid Mercury.Parser.Edge instance.
CInvalidElementException	An exception representing a problem with Mercury.Interpreting.IElement descendants.
CInvalidRewriteRuleException	An exception representing a problem with Mercury.Interpreting.RewriteRule{T}.
CInvalidRuleException	An exception thrown when attempting to create an invalid Mercury.Syntax.Rule instance.
CInvalidSymbolException	An exception thrown when attempting to create an invalid Mercury.Syntax.Symbol instance.
CMercuryException	An exception thrown by the Mercury library.
CSyntaxException	An exception thrown when something wrong happens in the Mercury.Syntax
▼NInterpreting
CActionCall< T >	This class represents the application of Mercury.Interpreting.InterpreterAction{T} on the Mercury.Interpreting.IFormalParameter list.
CAlternative	Represents an alternative of elements. It may match specified symbols or symboltypes (Nonterminals, ...).
CArgument	Represents an argument passed to the Mercury.Interpreting.InterpreterAction{T}, the actual parameter given to the Mercury.Interpreting.Evaluator{T} in place of a formal parameter.
CArithmeticAction< T >	Represents the arithmetic action. It is similar to the Mercury.Interpreting.FoldingAction{T,U,V} but does not require initial value. The minimal number of arguments is therefore 2. For instance, "1 2 3" would be evaluated as `f(f(1, 2), 3)`
CBasicActions< T >	Contains basic actions for interpretation. Type specifiers of actions are defined as follows:
CConstant	Constant element. Basically equivalent of Mercury.Interpreting.Alternative.
CConstantAction< T, U >	Wraps a value as an action with no parameters
CConstantParameter	Constant parameter.
CConvertAction< T, U, V >	Applies the lambda function on a single value.
CDataEntry	Entry base (dummy) interface.
CEmptyContextFactory	Produces contexts with no custom data
CEntryWriter< T >	An auxiliary class that formats the DataEntry structure and writes it into a stream.
CFoldingAction< T, U, V >	"Folds" all its arguments into one value. For instance, for "x y z" arguments this action computes `f(f(f(s,x), y), z)` where `f` is the lamda function and `s` is the `seed` parameter of the constructor
CGenericAction< T >	Represents an action that infers its return type only after it is provided with types of its arguments.
CIElement	Element interface
CIFormalParameter	Represents formal parameters.
CIInterpreter< T >	Interface for interpreters that create objects from derivation trees according to RewriteRules.
CIInterpreterContextFactory	Factory of context.
CInstance	Represents a binding between a Mercury.Interpreting.Variable and its value
CInstanceList	Represents the list of instances
CInterpreter< T >	Interprets derivation trees using rewrite rules. The type parameter T represents the target language.
CInterpreterAction< T >	Function that wraps constant values in the RHS
CInterpreterAction< T, U >	Interpreter action with a safer return type.
CInterpreterContext< T >	Interpreter Context class. Some languages may use it to override it and remember data when parse trees are being interpreted.
CInterpreterResult< T >	Result of the interpretation.
CMemoEntry< T >	Represents memoized value
COperationAction< T, U, V >	Represents an operation on two values.
CRewriteRule< T >	Interpreter rewrite rule
CRewriteRuleCollection< T >	A read-only collection of rewrite rules
CRewriteRuleCollectionBuilder< T >	Can be used to construct Mercury.Interpreting.RewriteRuleCollection{T}
CRuleEntry< T >	Describes a rule that has been used to interpret a tree.
CSemanticInterpreter< T >	Represent the semantic analysis with interpretation. Consists of two interpreters, the first one rewrites parse trees, the second one interprets them. This class serves as a wrapper so it could be used in the Mercury.Analyser{T,TResult} class.
CStructure	Represents a tree of Mercury.Interpreting.IElement instances. Must match precisely to the parse tree.
CTextEntry	Stores informations logged by actions or internal Evaluator.
CTreeEntry< T >	Represents an entry for tree interpretation.
CVariable	Represents a variable element that captures value and can be used on the RHS of the RewriteRule as an argument
CVariableParameter	Represents a named parameter that will be replaced by an actual value of a variable captured by interpreter.
CWildcard	An element that matches zero or more values. Can be used as a variable, but the actioncall must be of arity (0, `int.MAX_VALUE`) and must accept `Tree` or `Symbol` as the argument.
▼NNucleus
▼NCollections
CIMultiDictionary< TKey, TValue >	Represents a multi-valued dictionary, in other words a map between a key and a collection of values.
CIReadOnlyMultiDictionary< TKey, TValue >	Represents a multi-valued read-only dictionary, a map between a key and a collection of values.
CListMultiDictionary< TKey, TValue >	An implementation of IMultiDictionary{TKey,TValue} using T:System.Collections.Generic.List{T} as an underlying collection of values.
CSetMultiDictionary< TKey, TValue >	An implementation of IMultiDictionary{TKey,TValue} using T:System.Collections.Generic.HashSet{T} as an underlying collection of values.
CUniqueListMultiDictionary< TKey, TValue >	An implementation of IMultiDictionary{TKey,TValue} using T:System.Collections.Generic.List{T} as underlying collection, but opposed to ListMultiDictionary{TKey,TValue} does not allow duplicate values associated with the same key
▼NTrees
CBFSTreeEnumerator< T >	Breadth-First Search tree enumerator
CDFSTreeEnumerator< T >	Depth-First Search tree enumerator
CTree< T >	A non-balanced tree implementation that can be referenced from many other trees. Because of that, there is no way to get back to the parent node
▼NScanning
CITokenizer	The tokenizer interface.
CToken	Token, a part of an input text recognized by tokenizer
CTokenizer	A default implementation of ITokenizer interface using Microsoft Regular Expressions. Splits tokens in the following fashion:
▼NSyntax
CBasicScanner	Generates four Nonterminals `@Symbol`, `@Keyword`, `@Number` and `@String` based on the given map and types of input tokens.
CBasicScannerMap	Contains mapping between TokenType and Mercury.Syntax.Mapping of Mercury.Syntax.BasicScanner.
CChartParser	Thread-safe wrapper for ChartParserInternal class.
CCompositeScanner	Mercury.Syntax.IScanner implementation that behaves like container of scanners using the Composite Design Pattern
CEdge	Represents an edge in the chart created by the ChartParser. This is an immutable class. The Edge contains four values:
CGrammar	Represents a Context-Free Grammar. This is an immutable class, to create a grammar use Mercury.Syntax.GrammarBuilder.
CGrammarBuilder	Class that creates grammars.
CIParser	Creates a derivation tree from the list of input tokens
CIScanner	Scanner scans input tokens and creates additional rules for parsing
CParserResult	Represents the result returned by the parser.
CRule	Represents a Context-Free Grammar rule. This is an immutable class
CSymbol	Represents a single symbol of the grammar. This is an immutable class. For a symbol name to be valid it must NOT contain control or separator characters, must not be empty and must meet these conditions:
CAnalyser< T >	Wrapper class for each step of analysis
CAnalyser< T, TResult >	Wrapper class for each step of analysis.
CAnalyserResult< T, TResult >	Holds the result of analysis. The fields hold information according to the following table:
CDefaults	Global class containing cool static / convenience stuff.
CExtensions	Provides extension methods for the Mercury library.
CLanguageInfo< T >	Represents a collection of information required to analyze a language with Mercury Mercury.Analyser{T,TValue}.