Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 1234567]

►CAbstractSegment
CTextEditor.TextRange
►CLoyc.Collections.Impl.AListNode< K, T >	Internal implementation class. Base class for tree nodes in a list class derived from AListBase{T}. These nodes basically form an in-memory B+tree, not necessarily sorted, but structured like a B+tree. That means there are two node types: leaf and inner (internal) nodes.
CLoyc.Collections.Impl.AListInnerBase< K, T >	Internal implementation class. Shared base class of internal nodes for AList{T}, SparseAList{T}, BList{T}, BMultiMap{K,V} and BDictionary{K,V}.
►CLoyc.Collections.Impl.AListLeaf< K, T >	Internal implementation class. Shared code of non-sparse AList leaf nodes.
CLoyc.Collections.Impl.BListLeaf< K, T >	Internal implementation class. Leaf node of BList{T} and BDictionary{K,V}.
CLoyc.Collections.Impl.SparseAListLeaf< T >	Internal implementation class. Leaf node of SparseAList{T}.
CLoyc.Collections.Impl.AListTreeObserverExt	Helper methods for IAListTreeObserver{K,T}.
CLoyc.Collections.ArrayOf4< T >
►CLoyc.MiniTest.Assert	The Assert class contains a collection of static methods that mirror the most common assertions used in NUnit.
CLoyc.Collections.Impl.TestHelpers	Helpers methods for unit tests for Loyc collection classes.
►CAttribute
CLeMP.ContainsMacrosAttribute	Marks a class to be searched for macros.
CLeMP.LexicalMacroAttribute	Marks a method as an LEL simple macro.
CLoyc.MiniTest.ExpectedExceptionAttribute	Marks a test that is expected to throw an exception of a particular type. The test fails if the expected exception is not thrown.
CLoyc.MiniTest.SetUpAttribute	Marks a method that is to be called prior to each test in a test fixture.
CLoyc.MiniTest.TearDownAttribute	Marks a method that is to be called after each test in a test fixture.
CLoyc.MiniTest.TestFixtureAttribute	Identifies a class that contains unit tests, or methods that return other tests or test fixtures.
CLoyc.Utilities.GoAliasAttribute	This attribute is applied to a method of an interface to specify alternate names that a method can have in T when you use GoInterface <Interface, T> to produce a wrapper.
CLoyc.Utilities.GoDecoratorFieldAttribute	This attribute marks a field in an abstract class as pointing to a wrapped object to which GoInterface should forward calls. It is used when you want GoInterface to "complete" a decorator pattern for you.
►CAttribute
CLoyc.LocalizableAttribute	I plan to use this attribute someday to gather all the localizable strings in an application. This attribute should be applied to a string function parameter if the method calls Localized() using that parameter as the format string.
►CLoyc.MiniTest.TestAttribute	Identifies a method that contains a unit test, or that returns other tests or test fixtures.
CLoyc.MiniTest.BenchmarkAttribute	Marks a benchmark test, which exists to test performance. Benchmark tests are often run multiple times to obtain an average running time.
►CBaseDictionary< K, V >
CLoyc.Collections.WeakValueDictionary< K, V >	A dictionary in which the values are weak. When a value has been garbage- collected, the dictionary acts as if the key is not present (except the Remove() method, which saves time by not checking whether the value is dead.)
►CBaseILexer< ICharSource, Token >
CLoyc.Syntax.Les.LesLexer	Lexer for EC# source code.
►CLoyc.Syntax.Lexing.BaseLexer	Alias for BaseLexer{C} where C is ICharSource.
CLoyc.Ecs.Parser.EcsLexer	Lexer for EC# source code (see ILexer{Token}).
►CLoyc.Syntax.BaseParser< Token, MatchType >	An base class designed for parsers that use LLLPG (Loyc LL(k) Parser Generator). Note: this is the old (harder to use) base class design. You should use BaseParserForList{Token,MatchType} instead.
►CLoyc.Syntax.BaseParser< Token >	An base class designed for parsers that use LLLPG (Loyc LL(k) Parser Generator). Note: this is the old (harder to use) base class. You should use BaseParserForList{Token, LaType} instead. This class is now an alias for BaseParser{Token,int}.
CLoyc.Ecs.Parser.EcsParser	Parses Enhanced C# code into a sequence of Loyc trees (LNode), one per top-level statement.
►CLoyc.Syntax.BaseParserNoBacktracking< Token, Enumerator >	An base class designed for parsers that use LLLPG (Loyc LL(k) Parser Generator) and receive tokens from any IEnumerator{Token}.
CLoyc.Syntax.BaseParserNoBacktracking< Token >	An base class designed for parsers that use LLLPG (Loyc LL(k) Parser Generator) and receive tokens from an IEnumerator{Token}.
CLoyc.Syntax.BaseParser< Token, MatchType >.SavePosition	A helper class used by LLLPG for backtracking.
►CLoyc.Syntax.BaseParserForList< Token, MatchType, List >	An base class designed for parsers that use LLLPG (Loyc LL(k) Parser Generator) and receive tokens from any IEnumerator{Token}. (Potentially also useful for parsers written by hand.)
►CLoyc.Syntax.BaseParserForList< Token, MatchType >	An base class designed for parsers that use LLLPG (Loyc LL(k) Parser Generator) and receive tokens from any IEnumerator{Token}.
CLoyc.Syntax.Les.LesParser	Parses LES (Loyc Expression Syntax) code into a sequence of Loyc trees (LNode), one per top-level statement.
►CLoyc.Syntax.ParserSource< Token, MatchType, List >	An implementation of the LLLPG Parser API, used with the LLLPG options inputSource and inputClass.
►CLoyc.Syntax.ParserSource< Token, MatchType >	Alias for ParserSource{Token, int, IList{Token}}.
CLoyc.Syntax.ParserSource< Token >	Alias for ParserSource{Token, int, IList{Token}}.
CLoyc.Utilities.BloomFilterM64K2	A bloom filter for very small sets.
CLoyc.Geometry.BoundingBoxExt	Extension methods for BoundingBox{T}.
CLoyc.Geometry.BoundingBoxMath	Math and extension methods for BoundingBox{T}.
CLeMP.Prelude.BuiltinMacros	Defines noMacro(...) for suppressing macro expansion and import macros your.namespace.name as an alias for #importMacros(your.namespace.name).
CLoyc.Collections.CG	Contains global functions of Loyc.Collections that don't belong in any specific class.
CLoyc.CheckParam	Helper methods for checking argument values that throw exceptions when an argument value is not acceptable.
CLoyc.Utilities.Co	Extension methods for Co{T}.
CLoyc.Syntax.CodeSymbols	A list of common symbols that have special meaning somewhere in Loyc or EC#: operators, built-in data types, keywords, trivia, etc.
CLoyc.Collections.CollectionDebugView< T >	This helper class gives a nice view of a custom collection within the debugger.
►CLeMP.Compiler	A class that helps you invoke MacroProcessor on on a set of source files, given a set of command-line options.
►CLeMP.TestCompiler	A simple version of Compiler that takes a single input and produces a StringBuilder. Pre-opens LeMP.Prelude namespace.
CLoyc.LLParserGenerator.LlpgGeneralTestsBase.TestCompiler
►CLoyc.Collections.CPTrie< T >	Compact patricia tree class that stores keys as byte arrays. This class is intended to be use as a base class; a derived class can give meaning to the byte arrays, e.g. CPStringTrie encodes strings into byte arrays so they can be placed in the trie.
►CLoyc.Collections.CPStringTrie< TValue >	A compact patricia trie that uses strings as keys.
CLoyc.Collections.CPStringTrie< TValue >.Enumerator	Enumerates key-value pairs in a CPStringTrie.
CLoyc.Collections.CPStringTrie< TValue >.Enumerator	Enumerates key-value pairs in a CPStringTrie.
CLoyc.Collections.CPStringTrie< TValue >.KeyCollection	Return value of CPStringTrie{T}.Keys.
CLoyc.Collections.CPStringTrie< TValue >.KeyEnumerator	Enumerates keys of a CPStringTrie.
CLoyc.Collections.CPStringTrie< TValue >.KeyEnumerator	Enumerates keys of a CPStringTrie.
►CLoyc.Collections.Impl.CPByteTrie< TValue >	A compact patricia trie that uses byte arrays as keys.
CLoyc.Collections.Impl.CPByteTrie< TValue >.Enumerator
CLoyc.Collections.Impl.CPByteTrie< TValue >.Enumerator
►CLoyc.Collections.Impl.CPIntTrie< TValue >	A trie that supports signed and unsigned keys with sizes up to 64 bits. Special encodings are used to preserve the sort order among integers of different sizes while using variable-length keys.
CLoyc.Collections.Impl.CPIntTrie< TValue >.IntEnumerator
CLoyc.Collections.Impl.CPIntTrie< TValue >.IntEnumerator
CLoyc.Collections.Impl.CPIntTrie< TValue >.LongEnumerator
CLoyc.Collections.Impl.CPIntTrie< TValue >.LongEnumerator
CLoyc.Collections.DictionaryDebugView< K, V >	Workaround for a limitation of the debugger: it doesn't support CollectionDebugView{T} when T is KeyValuePair{K,V}. This class is identical, except that T is replaced with KeyValuePair{K,V}.
CLoyc.Collections.DictionaryExt	Extension methods for Dictionary{K,V} and IDictionary{K,V}.
►CDList< Token >
CLoyc.Syntax.Lexing.TokenTree	A list of Token structures along with the ISourceFile object that represents the source file that the tokens came from.
CLoyc.Ecs.EcsNodePrinter	Prints a Loyc tree to EC# source code.
CLoyc.Ecs.EcsPrecedence	Contains Precedence objects that represent the precedence rules of EC#.
CLoyc.Ecs.EcsValidators	A class filled with methods for checking whether a node has the correct LNode.Name and structure. For example, IsPropertyDefinition(node) checks whether node meets the requirements for being a property definition, such as having a Name equal to #property, and having name and return value that are complex identifiers.
CLoyc.Collections.EmptyArray< T >	EmptyArray{T}.Value lets you avoid allocating an empty array on the heap.
CLoyc.Collections.Impl.AListInnerBase< K, T >.Entry
CLoyc.Collections.Impl.SparseAListLeaf< T >.Entry
CLoyc.Collections.EnumerableExt	Additional extension methods for IEnumerable{T}, beyond what LINQ provides.
►CEqualityComparer< T >
CLoyc.ReferenceComparer< T >	An IEqualityComparer{T} based on reference equality
►CEventArgs
CLoyc.Threading.ThreadStartEventArgs	Used by the ThreadEx.ThreadStarting and ThreadEx.ThreadStopping events.
►CException
CLoyc.LogException	An exception that includes a "context" object as part of a LogMessage structure, typically used to indicate where an error occurred.
►CLoyc.MiniTest.TestException	An exception thrown when a method of Assert fails.
CLoyc.MiniTest.AssertionException	Thrown when an assertion fails during a call to a method of Assert.
CLoyc.MiniTest.IgnoreException	Thrown by Assert.Ignore().
CLoyc.MiniTest.InconclusiveException	Thrown by Assert.Inconclusive().
CLoyc.MiniTest.SuccessException	Thrown by Assert.Success().
CLoyc.ExceptionExt	Extension methods for exceptions.
CLoyc.EzStopwatch	A wrapper around Stopwatch with a more convenient interface, currently oriented around measuring milliseconds (TODO: increase similarity to Stopwatch)
►CForm
CTextEditor.FindAndReplaceForm
CTextEditor.LempDemoForm	Main form for a multi-file text editor based on ICSharpCode.TextEditor.TextEditorControl.
CLoyc.G	Contains global functions that don't belong in any specific class.
CTextEditor.Globals
CLoyc.Utilities.GoInterface	Mainly for internal use by the other GoInterface classes.
CLoyc.Utilities.GoInterface< Interface >	GoInterface<Interface> creates wrappers around objects of your choosing that implement the specified Interface, forwarding calls to methods in the wrapped object. It is inspired by the duck-typed interfaces in the Go programming language.
CLoyc.Utilities.GoInterface< Interface, T >	GoInterface<Interface,T> creates a wrapper that implements the specified Interface, forwarding calls to methods in T. It is inspired by the duck-typed interfaces in the Go programming language.
CLoyc.GSymbol	This class produces global symbols.
►CLoyc.Collections.IAdd< in T >	An interface for depositing items. Includes only an Add(T) method.
►CLoyc.Collections.ISinkCollection< T >	Represents a write-only collection: you can modify it, but you cannot learn what it contains.
►CLoyc.Collections.ICollectionEx< T >	This interface combines the original ICollection(T) interface with IReadOnlyCollection(T), ISinkCollection(T), and IAddRange(T), a convenient way to implement all three.
CLoyc.Collections.BDictionary< K, V >	An sorted dictionary that is efficient for all operations and offers indexed access to its list of key-value pairs.
►CLoyc.Collections.BList< T >	An sorted in-memory list that is efficient for all operations and offers indexed access to its list.
►CLoyc.Collections.BMultiMap< K, V >	An sorted dictionary that allows multiple values to be associated with a single key. Note: both keys and values must be comparable.
CLoyc.Collections.BMultiMap< K, V >.ValueList	Represents the set of values associated with a particular key in a BMultiMap{K,V} collection.
CLoyc.Collections.BMultiMap< K, V >.ValueList	Represents the set of values associated with a particular key in a BMultiMap{K,V} collection.
►CLoyc.Collections.IListEx< T >	This interface combines the original IList(T) interface with several IListSource(T), ISinkList(T), IArray(T) and several additional methods (e.g. RemoveAll, InsertRange).
►CLoyc.Collections.AList< T >	An all-purpose list structure with the following additional features beyond what's offered by List{T}: fast insertion and deletion (O(log N)), batch insertion and deletion, observability, fast cloning, freezability, and fast splitting and joining of large collections.
CLoyc.Collections.IndexedAList< T >	A simple wrapper around AList that includes an AListIndexer{K,T} that can be used to find items relatively quickly in a large list. When an index is built and the list is large, it accelerates IndexOf(item), Contains(item) and Remove(item).
CLoyc.Collections.DList< T >	A compact auto-enlarging list that efficiently supports supports insertions at the beginning or end of the list.
CLoyc.Collections.Impl.ListExBase< T >	A base class for classes that wish to implement IListEx{T}. Provides default implementations for most of the methods.
►CLoyc.Collections.ISparseListEx< T >	A sparse list that supports additional methods including InsertRange(int, ISparseListSource{T}).
CLoyc.Collections.SparseAList< T >	A sparse A-List that implements ISparseList{T}.
CLoyc.Collections.ReversedList< T >	Adapter: a reversed of an IList{T}. TODO: unit tests.
CLoyc.Collections.SparseAList< T >	A sparse A-List that implements ISparseList{T}.
CLoyc.Collections.ListSlice< T >	Adapter: a wrapper of a list that provides a view of a range of elements. Objects of this type are returned from ListExt.Slice{T}
CLoyc.Collections.ISinkList< T >	Represents a write-only indexable list class.
CLoyc.Collections.MSet< T >	A mutable set.
►CIAdditionGroup< Vector3< T >>
CLoyc.Geometry.Vector3Math< T >	Implementation of IAdditionGroup{T} for Vector{T}.
►CIAdditionGroup< Vector< T >>
CLoyc.Geometry.VectorMath< T >	An implementation of IAdditionGroup{T} for Vector{T}.
►CLoyc.Collections.Impl.IAListTreeObserver< K, T >	An interface that is called to notify observers when items or nodes in the tree of a class derived from AListBase{K,T} (e.g. AList or BList) are added or removed.
CLoyc.Collections.Impl.AListIndexer< K, T >	Observes changes and builds a table of items in the tree.
►CIAutoCreatePool< string, Symbol >
►CLoyc.SymbolPool	A collection of Symbols.
CLoyc.SymbolPool< SymbolE >	This type of SymbolPool helps create more strongly typed Symbols that simulate enums, but provide extensibility. Specifically, it creates SymbolE objects, where SymbolE is some derived class of Symbol.
CLoyc.Collections.IBinumerable< T >	Interface for a collection that can return IBinumerator{T}s pointing to the beginning and end of the collection.
►CIBRange< uchar >
CLoyc.UString	UString is a slice of a string. It is a wrapper around string that provides a IBRange{T} of 21-bit UCS-4 characters. "U" stands for "Unicode", as in UCS-4, as opposed to a normal string that is UTF-16.
►CICloneable
►CLoyc.Collections.FVList< T >	A reference to a FVList, a so-called persistent list data structure.
CLoyc.Collections.FVList< T >.Enumerator	Enumerator for FVList; also used by FWList.
CLoyc.Collections.FWList< T >	FWList is the mutable variant of the FVList data structure.
►CLoyc.Collections.VList< T >	VList represents a reference to a reverse-order FVList.
CLoyc.Collections.VList< T >.Enumerator	Enumerates through a VList from index 0 up to index Count-1.
CLoyc.Collections.WList< T >	WList is the mutable variant of the VList data structure.
►CLoyc.ICloneable< out T >	Interface for types that can duplicate themselves.
CLoyc.Collections.AList< T >	An all-purpose list structure with the following additional features beyond what's offered by List{T}: fast insertion and deletion (O(log N)), batch insertion and deletion, observability, fast cloning, freezability, and fast splitting and joining of large collections.
►CLoyc.Collections.AListBase< T >	Common base class of AList{T} and SparseAList{T}. Most of the functionality of the two types is identical, so this class is used to share code between them.
CLoyc.Collections.AList< T >	An all-purpose list structure with the following additional features beyond what's offered by List{T}: fast insertion and deletion (O(log N)), batch insertion and deletion, observability, fast cloning, freezability, and fast splitting and joining of large collections.
CLoyc.Collections.SparseAList< T >	A sparse A-List that implements ISparseList{T}.
CLoyc.Collections.ArraySlice< T >	Adapter: Provides access to a section of an array.
CLoyc.Collections.BDictionary< K, V >	An sorted dictionary that is efficient for all operations and offers indexed access to its list of key-value pairs.
CLoyc.Collections.BList< T >	An sorted in-memory list that is efficient for all operations and offers indexed access to its list.
CLoyc.Collections.DList< T >	A compact auto-enlarging list that efficiently supports supports insertions at the beginning or end of the list.
CLoyc.Collections.FVList< T >	A reference to a FVList, a so-called persistent list data structure.
CLoyc.Collections.FWList< T >	FWList is the mutable variant of the FVList data structure.
►CLoyc.Collections.IBRange< out T >	A bidirectional range. Allows you to read or remove the first or last element in a range.
►CLoyc.Collections.IBRangeEx< R, T >	A bidirectional range that can perform operations such as intersection and overlap tests on pairs of ranges of the same type.
CLoyc.Collections.IBRangeEx< T >	A bidirectional range that can perform operations such as intersection and overlap tests on pairs of ranges.
►CLoyc.Collections.IRangeEx< R, T >	A random-access range that can perform operations such as intersection and overlap tests on pairs of ranges of the same type.
CLoyc.Collections.IRangeEx< T >	A random-access range that can perform operations such as intersection and overlap tests on pairs of ranges.
►CLoyc.Collections.IMBRange< T >	A mutable bidirectional range.
►CLoyc.Collections.IMRange< T >	A mutable random-access range.
CLoyc.Collections.ArraySlice< T >	Adapter: Provides access to a section of an array.
►CLoyc.Collections.IRange< out T >	A random-access range, also known as a "slice". Allows you to narrow down the range like IBRange{T} does, and also provides random access via IListSource{T}.
CLoyc.Collections.EmptyList< T >	Helper class: EmptyList{T}.Value is a read-only empty list.
CLoyc.Collections.IMRange< T >	A mutable random-access range.
CLoyc.Collections.IRangeEx< R, T >	A random-access range that can perform operations such as intersection and overlap tests on pairs of ranges of the same type.
CLoyc.Collections.ListSlice< T >	Adapter: a wrapper of a list that provides a view of a range of elements. Objects of this type are returned from ListExt.Slice{T}
CLoyc.Collections.NegListSlice< T >	Adapter: a random-access range for a slice of an INegListSource{T}.
CLoyc.Collections.Repeated< T >	Helper struct. A sequence that stores one value, but acts like a list in which that value is repeated a specified number of times. Returned from Range.Repeat{T}.
CLoyc.Collections.Slice_< T >	Adapter: a random-access range for a slice of an IListSource{T}.
CLoyc.Collections.StringSlice	A random-access slice of System.String.
CLoyc.Collections.IBRangeEx< T >	A bidirectional range that can perform operations such as intersection and overlap tests on pairs of ranges.
►CLoyc.Collections.IFRange< out T >	A forward range. Allows you to read the first element from the range or skip it. The forward range lays the foundation for IBRange{T} and IRange{T}.
CLoyc.Collections.IBRange< out T >	A bidirectional range. Allows you to read or remove the first or last element in a range.
►CLoyc.Collections.IMFRange< T >	A mutable forward range.
CLoyc.Collections.IMBRange< T >	A mutable bidirectional range.
►CLoyc.Collections.Impl.InternalDList< T >	A compact auto-enlarging deque structure that is intended to be used within other data structures. It should only be used internally in "private" or "protected" members of low-level code. In most cases, you should use DList{T} instead.
CLoyc.Collections.Impl.InternalDList< T >.Enumerator
CLoyc.Collections.Impl.InternalList< T >	A compact auto-enlarging array structure that is intended to be used within other data structures. It should only be used internally in "private" or "protected" members of low-level code.
CLoyc.Collections.IRange< out T >	A random-access range, also known as a "slice". Allows you to narrow down the range like IBRange{T} does, and also provides random access via IListSource{T}.
CLoyc.Collections.IRangeEx< T >	A random-access range that can perform operations such as intersection and overlap tests on pairs of ranges.
CLoyc.Collections.ListSlice< T >	Adapter: a wrapper of a list that provides a view of a range of elements. Objects of this type are returned from ListExt.Slice{T}
CLoyc.Collections.MMap< K, V >	A dictionary class built on top of InternalSet<KeyValuePair<K,V>>.
CLoyc.Collections.MSet< T >	A mutable set.
CLoyc.Collections.NegListSlice< T >	Adapter: a random-access range for a slice of an INegListSource{T}.
CLoyc.Collections.Slice_< T >	Adapter: a random-access range for a slice of an IListSource{T}.
CLoyc.Collections.SparseAList< T >	A sparse A-List that implements ISparseList{T}.
CLoyc.Collections.StringSlice	A random-access slice of System.String.
CLoyc.Collections.VList< T >	VList represents a reference to a reverse-order FVList.
CLoyc.Collections.WList< T >	WList is the mutable variant of the VList data structure.
CLoyc.Geometry.BoundingBox< T >	Holds a mutable 2D bounding rectangle.
CLoyc.LLParserGenerator.LLParserGenerator.Transition	Represents a position in a grammar (GrammarPos) plus the set of characters that leads to that position from the previous position. This is a single case in a KthSet.
►CLoyc.LLParserGenerator.Pred	Represents part of a grammar for the LLParserGenerator.
CLoyc.LLParserGenerator.Alts	Describes a series of alternatives (branches), a kleene star (*), or an optional element (?).
CLoyc.LLParserGenerator.AndPred	Represents a zero-width assertion: either user-defined code to check a condition, or a predicate that scans ahead in the input and then backtracks to the starting point.
CLoyc.LLParserGenerator.DefaultErrorBranch	A singleton to be used as the value of Alts.ErrorBranch, representing the default_error branch.
CLoyc.LLParserGenerator.EndOfRule	A container for the follow set of a Rule.
CLoyc.LLParserGenerator.Gate	Represents a "gate" (p => m), which is a mechanism to separate prediction from matching in the context of branching (Alts).
CLoyc.LLParserGenerator.RuleRef	Represents a nonterminal, which is a reference to a rule.
CLoyc.LLParserGenerator.Seq	Represents a sequence of predicates (Preds).
CLoyc.LLParserGenerator.TerminalPred	Represents a terminal (which is a token or a character) or a set of possible terminals (e.g. 'A'..'Z').
CLoyc.MessageHolder	A message sink that puts the messages it receives in a list.
CLoyc.Syntax.DescendantsFrame	Helper class used to enumerate LNode.Descendants().
CLoyc.Syntax.Les.LesLexer	Lexer for EC# source code.
►CLoyc.Syntax.Lexing.IToken< TT >	The methods of Token in the form of an interface.
CLoyc.Syntax.Lexing.Token	A common token type recommended for Loyc languages that want to use features such as token literals or the TokensToTree class.
CLoyc.Syntax.Lexing.TokenTree	A list of Token structures along with the ISourceFile object that represents the source file that the tokens came from.
►CLoyc.Syntax.LNode	All nodes in a Loyc syntax tree share this base class.
CLoyc.Syntax.CallNode	Base class of all nodes that represent calls such as f(x), operator calls such as x + y, braced blocks, and all other things that are not simple symbols and literals.
CLoyc.Syntax.IdNode	Base class of all nodes that represent simple identifiers (including special symbols such as #foo).
CLoyc.Syntax.LiteralNode	Base class of all nodes that represent literal values such as 123 and "foo".
CLoyc.UString	UString is a slice of a string. It is a wrapper around string that provides a IBRange{T} of 21-bit UCS-4 characters. "U" stands for "Unicode", as in UCS-4, as opposed to a normal string that is UTF-16.
►CICollection
►CLoyc.Collections.KeyCollection< TKey, TValue >	Adapter: this is a read-only collection of Keys read from a generic IDictionary. It is a modified version of Dictionary{TKey, TValue}.KeyCollection from the Mono project, changed to use IDictionary instead of Dictionary.
CLoyc.Collections.KeyCollection< TKey, TValue >.Enumerator
CLoyc.Collections.KeyCollection< TKey, TValue >.Enumerator
CLoyc.Collections.KeyCollection< TKey, TValue >.Enumerator
►CLoyc.Collections.ValueCollection< TKey, TValue >	Adapter: this is a read-only collection of Values read from a generic IDictionary. It is a modified version of Dictionary{TKey, TValue}.ValueCollection from the Mono project, changed to use IDictionary instead of Dictionary.
CLoyc.Collections.ValueCollection< TKey, TValue >.Enumerator	Return type of GetEnumerator().
CLoyc.Collections.ValueCollection< TKey, TValue >.Enumerator	Return type of GetEnumerator().
CLoyc.Collections.ValueCollection< TKey, TValue >.Enumerator	Return type of GetEnumerator().
►CICollection< KeyValuePair< K, V >>
CLoyc.Collections.Map< K, V >	An immutable dictionary.
CLoyc.Collections.MMap< K, V >	A dictionary class built on top of InternalSet<KeyValuePair<K,V>>.
►CICollection< Num >
►CLoyc.Collections.NumRange< Num, Math >	Represents a range of integers of a specified data type.
CLoyc.Collections.NumRange< Num, Math >.Enumerator
►CICollection< Symbol >
CLoyc.SymbolSet	A set of symbols.
►CICollection< T >
CLoyc.Collections.CPValueCollection< T >	Provides read-only access to the values of a CPTrie.
►CLoyc.Collections.ICollectionAndReadOnly< T >	This interface combines the original ICollection{T} with IReadOnlyCollection{T}. It exists for the same reason as IListAndListSource{T}, to fix ambiguity errors.
CLoyc.Collections.CollectionAsReadOnly< T >	Adapter: a read-only wrapper that implements ICollection(T) and IReadOnlyCollection(T), returned from LCExt.AsReadOnly{T}.
CLoyc.Collections.ICollectionEx< T >	This interface combines the original ICollection(T) interface with IReadOnlyCollection(T), ISinkCollection(T), and IAddRange(T), a convenient way to implement all three.
►CLoyc.Collections.IListAndListSource< T >	This interface combines the original IList{T} interface with its "source" (read-only) component interfaces, including IReadOnlyList{T}, plus IListSource{T}.
CLoyc.Collections.AListBase< T >	Common base class of AList{T} and SparseAList{T}. Most of the functionality of the two types is identical, so this class is used to share code between them.
CLoyc.Collections.FVList< T >	A reference to a FVList, a so-called persistent list data structure.
CLoyc.Collections.FWList< T >	FWList is the mutable variant of the FVList data structure.
CLoyc.Collections.IListEx< T >	This interface combines the original IList(T) interface with several IListSource(T), ISinkList(T), IArray(T) and several additional methods (e.g. RemoveAll, InsertRange).
CLoyc.Collections.Impl.InternalList< T >	A compact auto-enlarging array structure that is intended to be used within other data structures. It should only be used internally in "private" or "protected" members of low-level code.
►CLoyc.Collections.Impl.ListSourceBase< T >	A base class for read-only collections that wish to implement IList{T} and IListSource{T}. Provides default implementations for most of the methods.
CLoyc.Collections.BufferedSequence< T >	Adapter: This class wraps an IEnumerator{T} or IEnumerable{T} into an IListSource{T}, lazily reading the sequence as TryGet is called.
CLoyc.Collections.Impl.ListExBase< T >	A base class for classes that wish to implement IListEx{T}. Provides default implementations for most of the methods.
CLoyc.Collections.ListSourceAsSparse< T >	Adapter from IListSource{T} to ISparseListSource{T}.
CLoyc.Collections.ReversedListSource< T >	Adapter: reversed view of IListSource{T} returned from LCExt.Reverse{T}.
►CLoyc.Collections.ISparseList< T >	Represents a sparse list that allows insertion and removal of items and empty spaces. In a sparse list, some spaces can be "clear" meaning that they have no value.
CLoyc.Collections.ISparseListEx< T >	A sparse list that supports additional methods including InsertRange(int, ISparseListSource{T}).
CLoyc.Collections.ListAsListSource< T >	Helper type returned from LCExt.AsListSource{T}.
CLoyc.Collections.ListSlice< T >	Adapter: a wrapper of a list that provides a view of a range of elements. Objects of this type are returned from ListExt.Slice{T}
CLoyc.Collections.ListSourceAsList< T >	Adapter: a read-only wrapper that implements IList(T) and IListSource(T), returned from LCExt.AsList{T}.
CLoyc.Collections.Repeated< T >	Helper struct. A sequence that stores one value, but acts like a list in which that value is repeated a specified number of times. Returned from Range.Repeat{T}.
CLoyc.Collections.VList< T >	VList represents a reference to a reverse-order FVList.
CLoyc.Collections.WList< T >	WList is the mutable variant of the VList data structure.
►CLoyc.Collections.WListBase< T >	Shared base class of FWList and WList.
CLoyc.Collections.FWList< T >	FWList is the mutable variant of the FVList data structure.
CLoyc.Collections.WList< T >	WList is the mutable variant of the VList data structure.
►CLoyc.Collections.Impl.ReadOnlyCollectionBase< T >	Helps you implement read-only collections by providing default implementations for most methods of ICollection{T} and IReadOnlyCollection{T}.
CLoyc.Collections.Impl.ListSourceBase< T >	A base class for read-only collections that wish to implement IList{T} and IListSource{T}. Provides default implementations for most of the methods.
CLoyc.Collections.ReadOnlyAsCollection< T >	A read-only wrapper that implements ICollection(T) and ISource(T), returned from LCExt.AsCollection{T}
CLoyc.Collections.MSet< T >	A mutable set.
►CLoyc.Collections.Set< T >	An immutable set.
CLoyc.Collections.Set< T >.Enumerator	Enumerator for MSet{T}.
►CICollection< TKey >
CLoyc.Collections.KeyCollection< TKey, TValue >	Adapter: this is a read-only collection of Keys read from a generic IDictionary. It is a modified version of Dictionary{TKey, TValue}.KeyCollection from the Mono project, changed to use IDictionary instead of Dictionary.
►CICollection< TValue >
CLoyc.Collections.ValueCollection< TKey, TValue >	Adapter: this is a read-only collection of Values read from a generic IDictionary. It is a modified version of Dictionary{TKey, TValue}.ValueCollection from the Mono project, changed to use IDictionary instead of Dictionary.
►CIComparable
CLoyc.Pair< T1, T2 >	A tuple of two values, A and B, in a struct.
►CIComparable< FPI16 >
CLoyc.Math.FPI16	Fixed-point type based on Int32 with 16 fractional bits
►CIComparable< FPI23 >
CLoyc.Math.FPI23	Fixed-point type based on Int32 with 23 fractional bits
►CIComparable< FPI8 >
CLoyc.Math.FPI8	Fixed-point type based on Int32 with 8 fractional bits
►CIComparable< FPL16 >
CLoyc.Math.FPL16	Fixed-point type based on Int64 with 16 fractional bits
►CIComparable< FPL32 >
CLoyc.Math.FPL32	Fixed-point type based on Int64 with 32 fractional bits
►CIComparable< IntRange >
CLoyc.LLParserGenerator.IntRange	Represents a range of single characters (e.g. 'A'..'Z').
►CIComparable< MacroInfo >
CLeMP.MacroInfo	Data returned from IMacroContext.AllKnownMacros
►CIComparable< Pair< T1, T2 >>
CLoyc.Pair< T1, T2 >	A tuple of two values, A and B, in a struct.
►CIComparable< Symbol >
CLoyc.Symbol	Represents a symbol, which is a singleton string that supports fast comparisons and extensible enums.
►CIComparer< T >
►CLoyc.Math.IOrdered< T >	Provides comparison function for type T along with absolute value (Abs), and the minimum or maximum of two values (Min, Max).
►CLoyc.Math.IMath< T >	Provides operations available on all system numeric types (int, uint, double, etc.); see also ISignedMath{T}, IUIntMath{T}, IIntMath{T} and IFloatMath{T}.
►CLoyc.Math.ISignedMath< T >	Provides operations available on all signed numeric types (int, double, etc.); see also IUIntMath{T}, IIntMath{T} and IFloatMath{T}.
►CLoyc.Math.IIntMath< T >	Provides operations available on all unsigned integer types (byte, uint, etc.); see also IMath{T}, IIntMath{T}, and IFloatMath{T}.
CLoyc.Math.MathI	Implements IIntMath{T} for numbers of type System.Int32.
CLoyc.Math.MathI16	Implements IIntMath{T} for numbers of type System.Int16.
CLoyc.Math.MathI8	Implements IIntMath{T} for numbers of type System.SByte.
CLoyc.Math.MathL	Implements IIntMath{T} for numbers of type System.Int64.
►CLoyc.Math.IRationalMath< T >	Use this interface for floating-point, fixed-point, and rational types. Rational types support reciprocal and negation.
►CLoyc.Math.IFloatMath< T >	Provides operations available on floating-point types (float and double), including trigonometry and exponentiation.
CLoyc.Math.MathD	Implements IFloatMath{T} for numbers of type System.Double.
CLoyc.Math.MathF	Implements IFloatMath{T} for numbers of type System.Single.
CLoyc.Math.MathF16	Implements IRationalMath{T} for numbers of type FPI16.
CLoyc.Math.MathF23	Implements IRationalMath{T} for numbers of type FPI23.
CLoyc.Math.MathF8	Implements IRationalMath{T} for numbers of type FPI8.
CLoyc.Math.MathFL16	Implements IRationalMath{T} for numbers of type FPL16.
CLoyc.Math.MathFL32	Implements IRationalMath{T} for numbers of type FPL32.
►CLoyc.Math.IUIntMath< T >	Provides operations available on all unsigned integer types (byte, uint, etc.); see also IMath{T}, IIntMath{T}, and IFloatMath{T}.
CLoyc.Math.MathU	Implements IUIntMath{T} for numbers of type System.UInt32.
CLoyc.Math.MathU16	Implements IUIntMath{T} for numbers of type System.UInt16.
CLoyc.Math.MathU8	Implements IUIntMath{T} for numbers of type System.Byte.
CLoyc.Math.MathUL	Implements IUIntMath{T} for numbers of type System.UInt64.
►CIConvertible
CLoyc.Math.FPI16	Fixed-point type based on Int32 with 16 fractional bits
CLoyc.Math.FPI23	Fixed-point type based on Int32 with 23 fractional bits
CLoyc.Math.FPI8	Fixed-point type based on Int32 with 8 fractional bits
CLoyc.Math.FPL16	Fixed-point type based on Int64 with 16 fractional bits
CLoyc.Math.FPL32	Fixed-point type based on Int64 with 32 fractional bits
►CLoyc.Math.IConvertTo< T >	Provides methods for converting common numeric types to another numeric type "T".
CLoyc.Math.IComplexMath< T >	Use this interface for types such as complex numbers that satisfy the field axioms but do not have a natural order. complex numbers of course do support IHasRoot.
CLoyc.Math.IMath< T >	Provides operations available on all system numeric types (int, uint, double, etc.); see also ISignedMath{T}, IUIntMath{T}, IIntMath{T} and IFloatMath{T}.
►CIDictionary< byte[], TValue >
CLoyc.Collections.Impl.CPByteTrie< TValue >	A compact patricia trie that uses byte arrays as keys.
►CIDictionary< int, TValue >
CLoyc.Collections.Impl.CPIntTrie< TValue >	A trie that supports signed and unsigned keys with sizes up to 64 bits. Special encodings are used to preserve the sort order among integers of different sizes while using variable-length keys.
►CIDictionary< K, V >
CLoyc.Collections.BDictionary< K, V >	An sorted dictionary that is efficient for all operations and offers indexed access to its list of key-value pairs.
CLoyc.Collections.Map< K, V >	An immutable dictionary.
CLoyc.Collections.MMap< K, V >	A dictionary class built on top of InternalSet<KeyValuePair<K,V>>.
►CIDictionary< K1, K2 >
CLoyc.Collections.Bijection< K1, K2 >	A bijection is a one-to-one function and its inverse. It is implemented with a pair of dictionaries, one that maps K1 to K2 and another that maps K2 to K1.
►CIDictionary< long, TValue >
CLoyc.Collections.Impl.CPIntTrie< TValue >	A trie that supports signed and unsigned keys with sizes up to 64 bits. Special encodings are used to preserve the sort order among integers of different sizes while using variable-length keys.
►CIDictionary< string, TValue >
CLoyc.Collections.CPStringTrie< TValue >	A compact patricia trie that uses strings as keys.
►CIDictionary< Symbol, ValueT >
CLoyc.HashTags< ValueT >	An implementation of IAttributes that can hold one attribute before allocating any memory for a hashtable. It is intended to be used as a base class but can be used on its own.
CLoyc.Utilities.TagsInWList< ValueT >	An implementation of ITags designed for AstNode.
►CIDictionary< TKey, TValue >
►CLoyc.Collections.Impl.BaseDictionary< TKey, TValue >	A base class for user-defined dictionaries that want to implement both IDictionary(K,V) and IReadOnlyDictionary(K, V).
CLoyc.Collections.WeakKeyDictionary< TKey, TValue >	A dictionary with weak keys.
►CIDisposable
CLoyc.MessageSink.PushedCurrent	Returned by PushCurrent(IMessageSink).
CLoyc.Syntax.LNode.PushedPrinter	Returned by PushPrinter(LNodePrinter).
CLoyc.Syntax.ParsingService.PushedCurrent	Returned by PushCurrent(IParsingService).
CLoyc.Threading.PushedTLV< T >	Designed to be used in a "using" statement to alter a thread-local variable temporarily.
CLoyc.Threading.ThreadEx.ThreadDestructor	See PropagateVariables for more information.
CTextEditor.HighlightGroup	Bundles a group of markers together so that they can be cleared together.
CTextEditor.TextEditorSearcher	This class finds occurrances of a search string in a text editor's IDocument... it's like Find box without a GUI.
►CIEnumerable
CLoyc.Collections.KeyCollection< TKey, TValue >	Adapter: this is a read-only collection of Keys read from a generic IDictionary. It is a modified version of Dictionary{TKey, TValue}.KeyCollection from the Mono project, changed to use IDictionary instead of Dictionary.
CLoyc.Collections.ValueCollection< TKey, TValue >	Adapter: this is a read-only collection of Values read from a generic IDictionary. It is a modified version of Dictionary{TKey, TValue}.ValueCollection from the Mono project, changed to use IDictionary instead of Dictionary.
►CIEnumerable< SymbolE >
CLoyc.SymbolPool< SymbolE >	This type of SymbolPool helps create more strongly typed Symbols that simulate enums, but provide extensibility. Specifically, it creates SymbolE objects, where SymbolE is some derived class of Symbol.
►CIEnumerable< T >
CLoyc.Collections.IFRange< out T >	A forward range. Allows you to read the first element from the range or skip it. The forward range lays the foundation for IBRange{T} and IRange{T}.
►CLoyc.Collections.Impl.InternalSet< T >	A hash-trie data structure for use inside other data structures.
CLoyc.Collections.Impl.InternalSet< T >.Enumerator
CLoyc.Collections.NestedEnumerable< Frame, T >	Helper type. You pass a cloneable Frame object to the constructor, and then a copy of this Frame is used to construct a new NestedEnumerator{Frame,T} each time the user calls GetEnumerator.
CLoyc.Utilities.Co< T >	A structure that helps you to write coroutines, or to avoid the performance penalty of nested iterators.
►CIEnumerable< TKey >
CLoyc.Collections.KeyCollection< TKey, TValue >	Adapter: this is a read-only collection of Keys read from a generic IDictionary. It is a modified version of Dictionary{TKey, TValue}.KeyCollection from the Mono project, changed to use IDictionary instead of Dictionary.
►CIEnumerable< TValue >
CLoyc.Collections.ValueCollection< TKey, TValue >	Adapter: this is a read-only collection of Values read from a generic IDictionary. It is a modified version of Dictionary{TKey, TValue}.ValueCollection from the Mono project, changed to use IDictionary instead of Dictionary.
►CIEnumerator
CLoyc.Collections.EmptyEnumerator< T >	Helper class: an empty enumerator.
►CIEnumerator< T >
CLoyc.Collections.EmptyEnumerator< T >	Helper class: an empty enumerator.
CLoyc.Collections.EnumeratorBase< T >	Base class to help you implement the standard IEnumerator{T} interface. All you have to do is override MoveNext() and, when successful, set the Current property.
►CLoyc.Collections.IBinumerator< T >	Extends the "enumerator" concept to allow backward enumeration.
CLoyc.Collections.IMBinumerator< T >	A mutable bidirectional enumerator interface. Please note that the "Remove" method always moves to the next item, even though the Binumerator is capable of moving backward.
CLoyc.Collections.ReverseBinumerator< T >	Adapter: a IBinumerator{T} that swaps the MoveNext() and MovePrev() methods.
►CLoyc.Collections.IMEnumerator< T >	A mutable enumerator interface. Provides a "Remove" method like Java iterators have, and allows you to modify the current item.
CLoyc.Collections.IMBinumerator< T >	A mutable bidirectional enumerator interface. Please note that the "Remove" method always moves to the next item, even though the Binumerator is capable of moving backward.
CLoyc.Collections.Impl.CPEnumerator< T >	Traverses a CPTrie{T}. Returned by CPTrie{T}.ValueEnumerator().
CLoyc.Collections.NestedEnumerator< Frame, T >	Helper class. An enumerator that helps enumerate tree data structures. It maintains a virtual call stack that avoids the performance hit of using nested "yield return" statements in C#.
CLoyc.Collections.RangeEnumerator< R, T >	Helper struct: enumerates through a forward range (IFRange{T}), calling the range methods through R instead of through IFRange{T}.
CLoyc.Collections.RangeEnumerator< T >	Helper struct: enumerates through a forward range (IFRange{T}).
►CIEnumerator< Token >
►CLoyc.Syntax.Lexing.ILexer< Token >	A standard interface for lexers.
CLoyc.Ecs.Parser.EcsLexer	Lexer for EC# source code (see ILexer{Token}).
CLoyc.Syntax.Les.LesLexer	Lexer for EC# source code.
CLoyc.Syntax.Lexing.BaseILexer< CharSrc, Token >	A version of BaseLexer{CharSrc} that implements ILexer{Token}. You should use this base class if you want to wrap your lexer in a postprocessor such as IndentTokenGenerator or TokensToTree.
►CLoyc.Syntax.Lexing.LexerWrapper< Token >	A base class for wrappers that modify lexer behavior. Implements the ILexer interface, except for the NextToken() method.
CLoyc.Ecs.Parser.CommentSaver	A helper class that removes comments from a token stream, saving them into a list. This class deletes whitespace, but adds tokens to a list.
CLoyc.Ecs.Parser.EcsPreprocessor	Handles EC# processor directives.
►CLoyc.Syntax.Lexing.IndentTokenGenerator< Token >	A preprocessor usually inserted between the lexer and parser that inserts "indent", "dedent", and "end-of-line" tokens at appropriate places in a token stream.
CLoyc.Syntax.Les.LesIndentTokenGenerator	Indent postprocessor for Loyc Expression Syntax
CLoyc.Syntax.Lexing.TokensToTree	A preprocessor usually inserted between the lexer and parser that converts a token list into a token tree. Everything inside brackets, parens or braces is made a child of the open bracket.
CLoyc.Syntax.Lexing.WhitespaceFilter< Token >	Filters out tokens whose Value is WhitespaceTag.Value.
CLoyc.Syntax.Lexing.TokenListAsLexer	Adapter: converts IEnumerable(Token) to the ILexer{Token} interface.
►CIEnumeratorFrame< DescendantsFrame, LNode >
CLoyc.Syntax.DescendantsFrame	Helper class used to enumerate LNode.Descendants().
►CLoyc.Collections.Impl.IEnumeratorFrame< Frame, T >	Helper interface for NestedEnumerator{Frame, T}.
CLoyc.Collections.Impl.EnumeratorFrame< T >	A standard base class for enumerator frames used by NestedEnumerator{EnumeratorFrame{T},T}.
►CIEqualityComparer< KeyValuePair< K, V >>
►CLoyc.Collections.MapOrMMap< K, V >	Common base class that contains code shared between Map{K,V} and MMap{K,V}.
CLoyc.Collections.Map< K, V >	An immutable dictionary.
CLoyc.Collections.MMap< K, V >	A dictionary class built on top of InternalSet<KeyValuePair<K,V>>.
►CIEqualityComparer< LNode >
CLoyc.Syntax.LNode.DeepComparer	An IEqualityComparer that compares nodes structurally.
►CIEqualityComparer< object >
CLoyc.Collections.WeakKeyComparer< T >	Compares objects of the given type or WeakKeyReferences to them for equality based on the given comparer. Note that we can only implement IEqualityComparer{T} for T = object as there is no other common base between T and WeakKeyReference{T}. We need a single comparer to handle both types because we don't want to allocate a new weak reference for every lookup.
►CIEqualityComparer< T >
CLoyc.Math.IOrdered< T >	Provides comparison function for type T along with absolute value (Abs), and the minimum or maximum of two values (Min, Max).
►CIEquatable< AndPred >
CLoyc.LLParserGenerator.AndPred	Represents a zero-width assertion: either user-defined code to check a condition, or a predicate that scans ahead in the input and then backtracks to the starting point.
►CIEquatable< FPI16 >
CLoyc.Math.FPI16	Fixed-point type based on Int32 with 16 fractional bits
►CIEquatable< FPI23 >
CLoyc.Math.FPI23	Fixed-point type based on Int32 with 23 fractional bits
►CIEquatable< FPI8 >
CLoyc.Math.FPI8	Fixed-point type based on Int32 with 8 fractional bits
►CIEquatable< FPL16 >
CLoyc.Math.FPL16	Fixed-point type based on Int64 with 16 fractional bits
►CIEquatable< FPL32 >
CLoyc.Math.FPL32	Fixed-point type based on Int64 with 32 fractional bits
►CIEquatable< GrammarPos >
CLoyc.LLParserGenerator.LLParserGenerator.GrammarPos	Represents a location in a grammar: a predicate and a "return stack" which is a so-called persistent singly-linked list. This type is used within Transition.
►CIEquatable< IntRange >
CLoyc.LLParserGenerator.IntRange	Represents a range of single characters (e.g. 'A'..'Z').
►CIEquatable< IntSet >
►CLoyc.LLParserGenerator.IntSet	Represents a set of characters (e.g. 'A'..'Z' | 'a'..'z' | '_'), or a set of token IDs.
CLoyc.LLParserGenerator.PGIntSet	Represents a set of characters (e.g. 'A'..'Z' | 'a'..'z' | '_'), or a set of integers, used in the grammar of a parser.
►CIEquatable< InvertibleSet< T >>
CLoyc.Collections.InvertibleSet< T >	An immutable set that can be inverted. For example, an InvertibleSet<int> could contain "everything except 4 and 10", or it could contain a positive set such as "1, 2, and 3".
►CIEquatable< IPGTerminalSet >
►CLoyc.LLParserGenerator.IPGTerminalSet	This interface represents a set of terminals (and only a set of terminals, unlike TerminalPred which includes actions and a Basis Node). Typical lexers and parsers use PGIntSet and PGNodeSet, respectively.
CLoyc.LLParserGenerator.PGIntSet	Represents a set of characters (e.g. 'A'..'Z' | 'a'..'z' | '_'), or a set of integers, used in the grammar of a parser.
CLoyc.LLParserGenerator.PGNodeSet	An immutable set that implements IPGTerminalSet so that it can be used by LLParserGenerator.
►CIEquatable< LNode >
CLoyc.Syntax.LNode	All nodes in a Loyc syntax tree share this base class.
►CIEquatable< MSet< T >>
CLoyc.Collections.MSet< T >	A mutable set.
►CIEquatable< NegList< T >>
CLoyc.Collections.NegList< T >	Adapter: provides a view of an IList{T} in which the Count is the same, but the minimum index is not necessarily zero. Returned from LCExt.NegView{T}(IList{T},int).
►CIEquatable< NegListSource< T >>
CLoyc.Collections.NegListSource< T >	Adapter: provides a view of an IListSource{T} in which the Count is the same, but the minimum index is not necessarily zero. Returned from LCExt.NegView{T}(IListSource{T},int).
►CIEquatable< Pair< T1, T2 >>
CLoyc.Pair< T1, T2 >	A tuple of two values, A and B, in a struct.
►CIEquatable< Precedence >
CLoyc.Syntax.Precedence	A four-byte tuple that represents the precedence and miscibility of an operator.
►CIEquatable< ReversedList< T >>
CLoyc.Collections.ReversedList< T >	Adapter: a reversed of an IList{T}. TODO: unit tests.
►CIEquatable< Set< T >>
CLoyc.Collections.Set< T >	An immutable set.
►CIEquatable< Symbol >
CLoyc.Symbol	Represents a symbol, which is a singleton string that supports fast comparisons and extensible enums.
►CIEquatable< Token >
CLoyc.Syntax.Lexing.Token	A common token type recommended for Loyc languages that want to use features such as token literals or the TokensToTree class.
►CIEquatable< TokenTree >
CLoyc.Syntax.Lexing.TokenTree	A list of Token structures along with the ISourceFile object that represents the source file that the tokens came from.
►CIEquatable< UString >
CLoyc.UString	UString is a slice of a string. It is a wrapper around string that provides a IBRange{T} of 21-bit UCS-4 characters. "U" stands for "Unicode", as in UCS-4, as opposed to a normal string that is UTF-16.
►CLoyc.Math.IExp< T >	Provides power, logarithm, raise-e-to-exponent (Exp) and logarithm-of-e (Log) operations.
CLoyc.Math.IComplexMath< T >	Use this interface for types such as complex numbers that satisfy the field axioms but do not have a natural order. complex numbers of course do support IHasRoot.
CLoyc.Math.IFloatMath< T >	Provides operations available on floating-point types (float and double), including trigonometry and exponentiation.
►CIFoldingStrategy
CTextEditor.RegionFoldingStrategy	The class to generate the foldings, it implements ICSharpCode.TextEditor.Document.IFoldingStrategy
CLoyc.Utilities.IGoInterfaceWrapper	All GoInterface wrappers implement this interface.
►CLoyc.IHasLocation	This interface allows an object to declare its "location". It is used by MessageSink.LocationString, which helps convert the "context" of a message into a string.
CLoyc.LLParserGenerator.Pred	Represents part of a grammar for the LLParserGenerator.
CLoyc.LogMessage	Holds an argument list compatible with IMessageSink.Write. Typically used with MessageHolder.
CLoyc.Syntax.LNode	All nodes in a Loyc syntax tree share this base class.
►CLoyc.Math.IHasRoot< T >	Provides the Sqrt operation and its inverse, Square.
CLoyc.Math.IComplexMath< T >	Use this interface for types such as complex numbers that satisfy the field axioms but do not have a natural order. complex numbers of course do support IHasRoot.
CLoyc.Math.IMath< T >	Provides operations available on all system numeric types (int, uint, double, etc.); see also ISignedMath{T}, IUIntMath{T}, IIntMath{T} and IFloatMath{T}.
►CLoyc.IHasValue< out T >	Interface for things that have a Value property.
CLoyc.Holder< T >	A trivial class that holds a single value of type T in the Value property.
CLoyc.Maybe< T >	Same as Nullable{T} except that it behaves like a normal type, i.e. (1) T is allowed to be a reference type and (2) you can nest them, as in Maybe{Maybe{int}}.
CLoyc.Pair< T1, T2 >	A tuple of two values, A and B, in a struct.
►CLoyc.Syntax.Lexing.ISimpleToken< TokenType >	Basic information about a token as expected by BaseParser{Token}: a token Type, which is the type of a "word" in the program (string, identifier, plus sign, etc.), a value (e.g. the name of an identifier), and an index where the token starts in the source file.
CLoyc.Syntax.Lexing.IToken< TT >	The methods of Token in the form of an interface.
CLoyc.Syntax.LNode	All nodes in a Loyc syntax tree share this base class.
CLoyc.Threading.ScratchBuffer< T >	Holds a single Value that is associated with the thread that assigned it.
►CLoyc.Math.IIncrementer< T >	Provides increment, decrement, and next/previous-representable- value operations.
CLoyc.Math.IMath< T >	Provides operations available on all system numeric types (int, uint, double, etc.); see also ISignedMath{T}, IUIntMath{T}, IIntMath{T} and IFloatMath{T}.
►CLoyc.Syntax.IIndexToLine	Contains IndexToLine method.
►CLoyc.Syntax.IIndexPositionMapper	This interface is for classes that can convert indexes to SourcePos structures and back.
►CLoyc.Syntax.IndexPositionMapper< CharSource >	Helper class for mapping from indexes to SourcePos and back.
►CLoyc.Syntax.SourceFile< CharSource >	A default implementation of ISourceFile based on IndexPositionMapper.
CLoyc.Syntax.Lexing.LexerSourceFile< CharSource >	Adds the AfterNewline method to SourceFile.
►CLoyc.Syntax.ISourceFile	Represents a text file with a file name and its textual content, plus the data necessary to convert between line-column positions and 0-based integer indexes.
CLoyc.Syntax.EmptySourceFile	A dummy implementation of ISourceFile that has only a filename, no source text. Used as the source file of synthetic syntax nodes.
CLoyc.Syntax.Lexing.LexerSourceFile< CharSource >	Adds the AfterNewline method to SourceFile.
CLoyc.Syntax.SourceFile< CharSource >	A default implementation of ISourceFile based on IndexPositionMapper.
CLoyc.Syntax.SourceFileWithLineRemaps	An wrapper around ISourceFile that applies line remapping information (if the source file uses it).
►CLoyc.Syntax.Lexing.BaseLexer< CharSrc >	The recommended base class for lexers generated by LLLPG, when not using the inputSource option.
CLoyc.Syntax.Lexing.BaseILexer< CharSrc, Token >	A version of BaseLexer{CharSrc} that implements ILexer{Token}. You should use this base class if you want to wrap your lexer in a postprocessor such as IndentTokenGenerator or TokensToTree.
CLoyc.Syntax.Lexing.BaseLexer< CharSrc >.SavePosition	A helper class used by LLLPG for backtracking.
►CLoyc.Syntax.Lexing.LexerSourceWorkaround< CharSrc >	This class only exists to work around a limitation of the C# language: "cannot change access modifiers when overriding 'protected' inherited member Error(...)".
CLoyc.Syntax.Lexing.LexerSource< CharSrc >	An implementation of the LLLPG Lexer API, used with the LLLPG options inputSource and inputClass.
CLoyc.Syntax.Lexing.ILexer< Token >	A standard interface for lexers.
►CLoyc.Collections.IIsEmpty	Holds the IsEmpty property that tells you if a collection is empty.
CLoyc.Collections.ArraySlice< T >	Adapter: Provides access to a section of an array.
CLoyc.Collections.EmptyList< T >	Helper class: EmptyList{T}.Value is a read-only empty list.
CLoyc.Collections.ICollectionEx< T >	This interface combines the original ICollection(T) interface with IReadOnlyCollection(T), ISinkCollection(T), and IAddRange(T), a convenient way to implement all three.
►CLoyc.Collections.ICount	Holds the Count property found in nearly all collection interfaces.
►CLoyc.Collections.IAddRange< T >	An interface typically implemented alongside ICollection{T}, for collection types that can add multiple items in one method call.
CLoyc.Collections.BDictionary< K, V >	An sorted dictionary that is efficient for all operations and offers indexed access to its list of key-value pairs.
CLoyc.Collections.BList< T >	An sorted in-memory list that is efficient for all operations and offers indexed access to its list.
CLoyc.Collections.ICollectionEx< T >	This interface combines the original ICollection(T) interface with IReadOnlyCollection(T), ISinkCollection(T), and IAddRange(T), a convenient way to implement all three.
►CLoyc.Collections.IListRangeMethods< T >	An interface typically implemented alongside IList{T} for collection types that can add or remove multiple items in one method call.
CLoyc.Collections.AList< T >	An all-purpose list structure with the following additional features beyond what's offered by List{T}: fast insertion and deletion (O(log N)), batch insertion and deletion, observability, fast cloning, freezability, and fast splitting and joining of large collections.
CLoyc.Collections.DList< T >	A compact auto-enlarging list that efficiently supports supports insertions at the beginning or end of the list.
CLoyc.Collections.IListEx< T >	This interface combines the original IList(T) interface with several IListSource(T), ISinkList(T), IArray(T) and several additional methods (e.g. RemoveAll, InsertRange).
CLoyc.Collections.Impl.InternalList< T >	A compact auto-enlarging array structure that is intended to be used within other data structures. It should only be used internally in "private" or "protected" members of low-level code.
CLoyc.Collections.ReversedList< T >	Adapter: a reversed of an IList{T}. TODO: unit tests.
CLoyc.Collections.SparseAList< T >	A sparse A-List that implements ISparseList{T}.
CLoyc.Collections.MMap< K, V >	A dictionary class built on top of InternalSet<KeyValuePair<K,V>>.
►CLoyc.Collections.IDeque< T >	Represents a double-ended queue that allows items to be added or removed at the beginning or end.
CLoyc.Collections.AListBase< T >	Common base class of AList{T} and SparseAList{T}. Most of the functionality of the two types is identical, so this class is used to share code between them.
CLoyc.Collections.DList< T >	A compact auto-enlarging list that efficiently supports supports insertions at the beginning or end of the list.
CLoyc.Collections.INegDeque< T >	Represents a Deque that supports negative indexes. In this kind of Deque, pushing and popping elements does not affect the indexes of the other elements in the collection.
CLoyc.Collections.IQueue< T >	Represents a FIFO (first-in-first-out) queue.
CLoyc.Collections.IStack< T >	Represents a LIFO (last-in-first-out) stack.
CLoyc.NullMessageSink	Discards all messages. However, there is a Count property that increases by one with each message received.
CLoyc.Collections.IDeque< T >	Represents a double-ended queue that allows items to be added or removed at the beginning or end.
CLoyc.Collections.IFRange< out T >	A forward range. Allows you to read the first element from the range or skip it. The forward range lays the foundation for IBRange{T} and IRange{T}.
CLoyc.Collections.Impl.ListSourceBase< T >	A base class for read-only collections that wish to implement IList{T} and IListSource{T}. Provides default implementations for most of the methods.
CLoyc.Collections.ListSlice< T >	Adapter: a wrapper of a list that provides a view of a range of elements. Objects of this type are returned from ListExt.Slice{T}
CLoyc.Collections.NegListSlice< T >	Adapter: a random-access range for a slice of an INegListSource{T}.
CLoyc.Collections.NumRange< Num, Math >	Represents a range of integers of a specified data type.
CLoyc.Collections.Repeated< T >	Helper struct. A sequence that stores one value, but acts like a list in which that value is repeated a specified number of times. Returned from Range.Repeat{T}.
CLoyc.Collections.Slice_< T >	Adapter: a random-access range for a slice of an IListSource{T}.
►CIList
CLoyc.Collections.DList	This class is the same as DList{object} except that it also implements the IList interface.
►CIList< T >
CLoyc.Collections.EmptyList< T >	Helper class: EmptyList{T}.Value is a read-only empty list.
CLoyc.Collections.IListAndListSource< T >	This interface combines the original IList{T} interface with its "source" (read-only) component interfaces, including IReadOnlyList{T}, plus IListSource{T}.
►CIListSource< char >
CLoyc.UString	UString is a slice of a string. It is a wrapper around string that provides a IBRange{T} of 21-bit UCS-4 characters. "U" stands for "Unicode", as in UCS-4, as opposed to a normal string that is UTF-16.
►CIListSource< IntRange >
CLoyc.LLParserGenerator.IntSet	Represents a set of characters (e.g. 'A'..'Z' | 'a'..'z' | '_'), or a set of token IDs.
►CIListSource< IToken< int >>
CLoyc.Syntax.Lexing.TokenTree	A list of Token structures along with the ISourceFile object that represents the source file that the tokens came from.
►CIListSource< Token >
CLoyc.Syntax.Lexing.Token	A common token type recommended for Loyc languages that want to use features such as token literals or the TokensToTree class.
CLoyc.Syntax.Lexing.TokenTree	A list of Token structures along with the ISourceFile object that represents the source file that the tokens came from.
►CLoyc.Syntax.Lexing.ILllpgApi< Token, MatchType, LaType >	For reference purposes, this interface is a list of the non-static methods that LLLPG expects to be able to call when it is generating code. LLLPG does not actually need lexers and parsers to implement this interface; they simply need to implement the same set of methods as this interface contains.
►CLoyc.Syntax.Lexing.ILllpgLexerApi< Token >	For reference purposes, this interface contains the non-static methods that LLLPG expects lexers to implement. LLLPG does not actually expect lexers to implement this interface; they simply need to implement the same set of methods as this interface contains.
CLoyc.Syntax.Lexing.LexerSource< CharSrc >	An implementation of the LLLPG Lexer API, used with the LLLPG options inputSource and inputClass.
►CILllpgApi< Token, MatchType, MatchType >
CLoyc.Syntax.ParserSource< Token, MatchType, List >	An implementation of the LLLPG Parser API, used with the LLLPG options inputSource and inputClass.
►CLoyc.Syntax.ILNodeVisitor	Interface for people that want to implement the visitor pattern with LNode. If your visitor does not need a base class, use LNodeVisitor as the base class.
CLoyc.Syntax.LNodeVisitor	Base class for people that want to implement the visitor pattern with LNode.
►CLoyc.IMessageSink	A general-purpose interface for a class that accepts formatted messages with context information.
CLeMP.IMacroContext	This interface provides services offered by the lexical macro processor (LeMP).
CLoyc.ConsoleMessageSink	Sends all messages to System.Console.WriteLine(), with hard-coded colors for Error, Warning, Note, Verbose, and Detail.
CLoyc.MessageFilter	A decorator that uses a delegate to accept or ignore messages.
CLoyc.MessageHolder	A message sink that puts the messages it receives in a list.
CLoyc.MessageSinkFromDelegate	This helper class lets you implement IMessageSink with one or two delegates (a writer method, and an optional severity filter).
CLoyc.MessageSplitter	A message sink that sends its messages to a list of other sinks.
CLoyc.NullMessageSink	Discards all messages. However, there is a Count property that increases by one with each message received.
CLoyc.SeverityMessageFilter	A decorator (wrapper) for IMessageSink that filters out some messages if their Severity is too low, according to the value of the MinSeverity property.
CLoyc.TraceMessageSink	Sends all messages to System.Diagnostics.Trace.WriteLine(string).
CLoyc.Syntax.Lexing.IndentTokenGenerator	A preprocessor usually inserted between the lexer and parser that inserts "indent", "dedent", and "end-of-line" tokens at appropriate places in a token stream.
CLoyc.Syntax.IndexPositionMapper	Synonym for IndexPositionMapper<IListSource<char>>.
►CINegListSource< LNode >
CLoyc.Syntax.LNode	All nodes in a Loyc syntax tree share this base class.
►CLoyc.Geometry.INewPoint3< Point, T >	This interface exists to work around a limitation of C#; see IPoint{T} and IPoint3{T}.
►CLoyc.Geometry.IPoint3< T >	A mutable 3D point with X, Y, and Z coordinates.
CLoyc.Geometry.Point3< T >	A 3D point (X-Y-Z triplet) structure.
CLoyc.Geometry.Vector3< T >	Represents a three-dimensional vector, i.e. a magnitude and direction or the difference between two points, stored as X, Y and Z components.
CLoyc.Geometry.Point3< T >	A 3D point (X-Y-Z triplet) structure.
CLoyc.Geometry.Vector3< T >	Represents a three-dimensional vector, i.e. a magnitude and direction or the difference between two points, stored as X, Y and Z components.
►CLoyc.Geometry.INewPoint< Point, T >	This interface exists to work around a limitation of C#; see IPoint{T}.
►CLoyc.Geometry.IPoint< T >	A mutable 2D point with X and Y coordinates.
CLoyc.Geometry.Point< T >	A 2D point (X-Y pair) structure.
CLoyc.Geometry.Vector< T >	Represents a two-dimensional vector, i.e. a magnitude and direction or the difference between two points, stored as X and Y components.
CLoyc.Geometry.Point< T >	A 2D point (X-Y pair) structure.
CLoyc.Geometry.Vector< T >	Represents a two-dimensional vector, i.e. a magnitude and direction or the difference between two points, stored as X and Y components.
►CLoyc.Geometry.INewRectangle3< Rect, T >	This interface exists to work around a limitation of C#; see IRectangle3{T}.
CLoyc.Geometry.IRectangle3< T >	Represents a mutable 3D rectangle.
►CLoyc.Geometry.INewRectangle< Rect, T >	This interface exists to work around a limitation of C#; see IRectangle{T}.
CLoyc.Geometry.BoundingBox< T >	Holds a mutable 2D bounding rectangle.
►CLoyc.Geometry.IRectangle< T >	Represents a mutable 2D rectangle.
CLoyc.Geometry.BoundingBox< T >	Holds a mutable 2D bounding rectangle.
►CLoyc.Syntax.Les.INodePrinterWriter	This interface is implemented by helper objects that handle the low-level details of node printing. It is used by LesNodePrinter.
►CLoyc.Syntax.Les.NodePrinterWriterBase	Abstract base class for INodePrinterWriter. Has an protected _indentLevel field that is increased by Indent() and decreased by Dedent().
CLoyc.Syntax.Les.DefaultNodePrinterWriter	Base class for the helper classes of LesNodePrinter and Ecs.EcsNodePrinter, called LesNodePrinterWriter and EcsNodePrinterWriter. See INodePrinterWriter.
►CLoyc.Collections.INotifyListChanging< T >	Encapsulates the ListChanging event that notifies listeners of dynamic changes to an indexed list, such as when items get added and removed or the whole list is refreshed.
►CLoyc.Collections.AListBase< K, T >	Base class for the indexed tree-based data structures known as AList{T} and BList{T}.
CLoyc.Collections.AListBase< K, T >.Enumerator
CLoyc.Collections.AListBase< K, T >.ObserverMgr	A multiplexer that is only created for ALists that have two or more attached intances of IAListTreeObserver{K,T}.
CLoyc.Collections.AListBase< T >	Common base class of AList{T} and SparseAList{T}. Most of the functionality of the two types is identical, so this class is used to share code between them.
CLoyc.Collections.BDictionary< K, V >	An sorted dictionary that is efficient for all operations and offers indexed access to its list of key-value pairs.
CLoyc.Collections.BList< T >	An sorted in-memory list that is efficient for all operations and offers indexed access to its list.
CLoyc.Collections.AListBase< K, T >	Base class for the indexed tree-based data structures known as AList{T} and BList{T}.
CSystem.Windows.Forms.InputBox	This static class contains methods named Show() to display a dialog box with an input field, similar in appearance to the one in Visual Basic. The Show() method returns null if the user clicks Cancel, and non-null if the user clicks OK.
CLeMP.InputOutput	For LeMP: an input file plus per-file options (input and output language) and output code.
CLoyc.Collections.Impl.InternalList	Contains static methods to help manage raw arrays with even less overhead than InternalList{T}.
CLoyc.Collections.Impl.InternalSetStats	Statistics returned from InternalSet{T}.CountMemory.
►CInvalidOperationException
CLoyc.Collections.EmptySequenceException	An exception thrown by methods or properties that require a non-empty sequence but were provided with an empty sequence.
CLoyc.Collections.EnumerationException	An exception thrown by an enumerator when it detects that the collection was modified after enumeration started but before it finished.
CLoyc.Collections.KeyAlreadyExistsException	An exception thrown by dictionary objects when they are asked to "add" a key-value pair that already exists.
CLoyc.ConcurrentModificationException	An exception thrown when a data structure is accessed (read or written) by one thread at the same time as it is modified on another thread.
CLoyc.InvalidStateException	An exception thrown when an object detects that its own state is invalid, or in other words, that an invariant has been violated.
CLoyc.ReadOnlyException	An exception thrown when an attempt is made to modify a read-only object.
►CInvertibleSet< LNode >
CLoyc.LLParserGenerator.PGNodeSet	An immutable set that implements IPGTerminalSet so that it can be used by LLParserGenerator.
►CLoyc.Math.IOneProvider< T >	Provides the value of "one" for type T.
►CLoyc.Math.IBitwise< T >	Provides the standard set of bitwise operators.
►CLoyc.Math.IBinaryMath< T >	Provides additional bit-oriented integer operations.
CLoyc.Math.IIntMath< T >	Provides operations available on all unsigned integer types (byte, uint, etc.); see also IMath{T}, IIntMath{T}, and IFloatMath{T}.
CLoyc.Math.IUIntMath< T >	Provides operations available on all unsigned integer types (byte, uint, etc.); see also IMath{T}, IIntMath{T}, and IFloatMath{T}.
CLoyc.Math.MathF16	Implements IRationalMath{T} for numbers of type FPI16.
CLoyc.Math.MathF23	Implements IRationalMath{T} for numbers of type FPI23.
CLoyc.Math.MathF8	Implements IRationalMath{T} for numbers of type FPI8.
CLoyc.Math.MathFL16	Implements IRationalMath{T} for numbers of type FPL16.
CLoyc.Math.MathFL32	Implements IRationalMath{T} for numbers of type FPL32.
►CLoyc.Math.IMultiply< T >	Provides the multiplication operation and the multiplicative identity, one.
►CLoyc.Math.IMultiplicationGroup< T >	This defines a Group with the operation *, the neutral element One, the inverse Inverse and an operation / that is defined in terms of the inverse.
►CLoyc.Math.IField< T >	This defines a Field with the operations +,-,*,/
CLoyc.Math.IComplexMath< T >	Use this interface for types such as complex numbers that satisfy the field axioms but do not have a natural order. complex numbers of course do support IHasRoot.
CLoyc.Math.IMath< T >	Provides operations available on all system numeric types (int, uint, double, etc.); see also ISignedMath{T}, IUIntMath{T}, IIntMath{T} and IFloatMath{T}.
►CLoyc.Math.IRing< T >	This defines a Ring with the operations +,*
CLoyc.Math.IField< T >	This defines a Field with the operations +,-,*,/
►CLoyc.Math.INumTraits< T >	This interface provides information about a numeric type T.
CLoyc.Math.IComplexMath< T >	Use this interface for types such as complex numbers that satisfy the field axioms but do not have a natural order. complex numbers of course do support IHasRoot.
CLoyc.Math.IMath< T >	Provides operations available on all system numeric types (int, uint, double, etc.); see also ISignedMath{T}, IUIntMath{T}, IIntMath{T} and IFloatMath{T}.
►CLoyc.Syntax.IParsingService	An interface that encapsulates the lexer, parser, and printer of a programming language, or a non-programming language that can be represented by Loyc trees.
CLoyc.Ecs.EcsLanguageService	The Value property provides easy access to the lexer, parser and printer for Enhanced C#.
CLoyc.Syntax.Les.LesLanguageService	The Value property provides easy access to the lexer, parser and printer for Loyc Expression Syntax (LES).
►CLoyc.LLParserGenerator.IPGCodeGenHelper	A class that implements this interface will generate small bits of code that the parser generator will use. The default implementation is IntStreamCodeGenHelper. To install a new code generator, set the LLParserGenerator.CodeGenHelper property or supply the generator in the constructor of LLParserGenerator.
►CLoyc.LLParserGenerator.CodeGenHelperBase	Suggested base class for custom code generators. Each derived class is typically designed for a different kind of token.
CLoyc.LLParserGenerator.GeneralCodeGenHelper	General-purpose code generator that supports any language with a finite number of input symbols represented by LNode expressions. This is the code generator helper for LLLPG parser {...}.
CLoyc.LLParserGenerator.IntStreamCodeGenHelper	Standard code generator for character/integer input streams and is the default code generator for LLParserGenerator. This is the code generator helper for LLLPG lexer {...}.
►CLoyc.Geometry.IPointReader< T >	Interface for reading the coordinates of a 2D point.
►CLoyc.Geometry.IPoint3Reader< T >	Interface for reading the coordinates of a 3D point.
►CLoyc.Geometry.IPoint3Base< T >	This interface exists to work around a limitation of C#; use IPoint{T} instead.
CLoyc.Geometry.IPoint3< T >	A mutable 3D point with X, Y, and Z coordinates.
►CLoyc.Geometry.IPointBase< T >	This interface exists to work around a limitation of C#; use IPoint{T} instead.
CLoyc.Geometry.IPoint3Base< T >	This interface exists to work around a limitation of C#; use IPoint{T} instead.
CLoyc.Geometry.IPoint< T >	A mutable 2D point with X and Y coordinates.
►CLoyc.Collections.IPop< T >	Represents a collection that produces a sequence of items, and can return the next item without popping it (the Peek operation).
CLoyc.Collections.IQueue< T >	Represents a FIFO (first-in-first-out) queue.
CLoyc.Collections.IStack< T >	Represents a LIFO (last-in-first-out) stack.
►CLoyc.Collections.IPush< T >	Represents a collection that accepts a sequence of items.
CLoyc.Collections.IQueue< T >	Represents a FIFO (first-in-first-out) queue.
CLoyc.Collections.IStack< T >	Represents a LIFO (last-in-first-out) stack.
►CIReadOnlyCollection< KeyValuePair< K, V >>
CLoyc.Collections.MapOrMMap< K, V >	Common base class that contains code shared between Map{K,V} and MMap{K,V}.
►CIReadOnlyCollection< Symbol >
CLoyc.SymbolPool	A collection of Symbols.
►CIReadOnlyCollection< T >
CLoyc.Collections.ICollectionAndReadOnly< T >	This interface combines the original ICollection{T} with IReadOnlyCollection{T}. It exists for the same reason as IListAndListSource{T}, to fix ambiguity errors.
►CLoyc.Collections.Impl.KeylessHashtable< T >	A fairly obscure space-saving hashtable that offers no built-in way to store keys, only values. Because there are no keys, the hashtable cannot be rehashed when it is full, and searching for a given key finds all values in the same bucket, some of which may be unrelated.
CLoyc.Collections.Impl.KeylessHashtable< T, Int, Math >	The concrete implementation of KeylessHashtable{T}. Do not use directly; instead, call KeylessHashtable{T}.New.
►CLoyc.Collections.INegListSource< T >	This interface is the counterpart to IListSource{T} for lists whose minimum index is not (necessarily) zero.
►CLoyc.Collections.INegArray< T >	This interface models the capabilities of an array: getting and setting elements by index, but not adding or removing elements. This interface is the counterpart to IListSource{T} for lists whose minimum index is not (necessarily) zero.
CLoyc.Collections.INegAutoSizeArray< T >	An auto-sizing array is a list structure that allows you to modify the element at any index, including indexes that don't yet exist; the collection automatically adds missing indexes.
CLoyc.Collections.INegDeque< T >	Represents a Deque that supports negative indexes. In this kind of Deque, pushing and popping elements does not affect the indexes of the other elements in the collection.
CLoyc.Collections.NegList< T >	Adapter: provides a view of an IList{T} in which the Count is the same, but the minimum index is not necessarily zero. Returned from LCExt.NegView{T}(IList{T},int).
CLoyc.Collections.NegListSlice< T >	Adapter: a random-access range for a slice of an INegListSource{T}.
CLoyc.Collections.NegListSource< T >	Adapter: provides a view of an IListSource{T} in which the Count is the same, but the minimum index is not necessarily zero. Returned from LCExt.NegView{T}(IListSource{T},int).
►CLoyc.Collections.ISetImm< T >	An immutable set that supports numerous set operations.
CLoyc.Collections.MSet< T >	A mutable set.
CLoyc.Collections.Set< T >	An immutable set.
►CLoyc.Collections.ISetImm< T, SetT >	An immutable set of type SetT with elements of type T.
CLoyc.Collections.InvertibleSet< T >	An immutable set that can be inverted. For example, an InvertibleSet<int> could contain "everything except 4 and 10", or it could contain a positive set such as "1, 2, and 3".
CLoyc.Collections.MSet< T >	A mutable set.
CLoyc.Collections.Set< T >	An immutable set.
CLoyc.Collections.MSet< T >	A mutable set.
►CIReadOnlyCollection< TKey >
CLoyc.Collections.KeyCollection< TKey, TValue >	Adapter: this is a read-only collection of Keys read from a generic IDictionary. It is a modified version of Dictionary{TKey, TValue}.KeyCollection from the Mono project, changed to use IDictionary instead of Dictionary.
►CIReadOnlyCollection< TValue >
CLoyc.Collections.IAutoCreatePool< in TKey, out TValue >	Represents a pool of objects in which an object is automatically created when requested by its key.
CLoyc.Collections.ValueCollection< TKey, TValue >	Adapter: this is a read-only collection of Values read from a generic IDictionary. It is a modified version of Dictionary{TKey, TValue}.ValueCollection from the Mono project, changed to use IDictionary instead of Dictionary.
►CIReadOnlyDictionary< byte[], TValue >
CLoyc.Collections.Impl.CPByteTrie< TValue >	A compact patricia trie that uses byte arrays as keys.
►CIReadOnlyDictionary< int, TValue >
CLoyc.Collections.Impl.CPIntTrie< TValue >	A trie that supports signed and unsigned keys with sizes up to 64 bits. Special encodings are used to preserve the sort order among integers of different sizes while using variable-length keys.
►CIReadOnlyDictionary< K, BMultiMap< K, V >.ValueList >
CLoyc.Collections.BMultiMap< K, V >	An sorted dictionary that allows multiple values to be associated with a single key. Note: both keys and values must be comparable.
►CIReadOnlyDictionary< K, V >
CLoyc.Collections.BDictionary< K, V >	An sorted dictionary that is efficient for all operations and offers indexed access to its list of key-value pairs.
CLoyc.Collections.MapOrMMap< K, V >	Common base class that contains code shared between Map{K,V} and MMap{K,V}.
►CIReadOnlyDictionary< K1, K2 >
CLoyc.Collections.Bijection< K1, K2 >	A bijection is a one-to-one function and its inverse. It is implemented with a pair of dictionaries, one that maps K1 to K2 and another that maps K2 to K1.
►CIReadOnlyDictionary< long, TValue >
CLoyc.Collections.Impl.CPIntTrie< TValue >	A trie that supports signed and unsigned keys with sizes up to 64 bits. Special encodings are used to preserve the sort order among integers of different sizes while using variable-length keys.
►CIReadOnlyDictionary< Symbol, ValueT >
CLoyc.HashTags< ValueT >	An implementation of IAttributes that can hold one attribute before allocating any memory for a hashtable. It is intended to be used as a base class but can be used on its own.
CLoyc.Utilities.TagsInWList< ValueT >	An implementation of ITags designed for AstNode.
►CIReadOnlyDictionary< TKey, TValue >
CLoyc.Collections.Impl.BaseDictionary< TKey, TValue >	A base class for user-defined dictionaries that want to implement both IDictionary(K,V) and IReadOnlyDictionary(K, V).
►CIReadOnlyList< Num >
CLoyc.Collections.NumRange< Num, Math >	Represents a range of integers of a specified data type.
►CIReadOnlyList< T >
►CLoyc.Collections.IListSource< out T >	A read-only list indexed by an integer.
CLoyc.Collections.AListBase< K, T >	Base class for the indexed tree-based data structures known as AList{T} and BList{T}.
CLoyc.Collections.AListBase< K, T >	Base class for the indexed tree-based data structures known as AList{T} and BList{T}.
CLoyc.Collections.AListReverseView< K, T >	A reverse view of an AList.
CLoyc.Collections.BList< T >	An sorted in-memory list that is efficient for all operations and offers indexed access to its list.
►CLoyc.Collections.IArray< T >	This interface models the capabilities of an array: getting and setting elements by index, but not adding or removing elements.
CLoyc.Collections.IAutoSizeArray< T >	An auto-sizing array is a list structure that allows you to modify the element at any index, including indices that don't yet exist; the collection automatically adds missing indices.
CLoyc.Collections.IListEx< T >	This interface combines the original IList(T) interface with several IListSource(T), ISinkList(T), IArray(T) and several additional methods (e.g. RemoveAll, InsertRange).
CLoyc.Collections.ListSlice< T >	Adapter: a wrapper of a list that provides a view of a range of elements. Objects of this type are returned from ListExt.Slice{T}
►CLoyc.Collections.ICharSource	A read-only list of characters plus a Slice(int,int) method.
CLoyc.Collections.StringSlice	A random-access slice of System.String.
CLoyc.Syntax.StreamCharSource	Exposes a stream as an ICharSource, as though it were an array of characters. The stream must support seeking, and if a text decoder is specified, it must meet certain constraints.
CLoyc.UString	UString is a slice of a string. It is a wrapper around string that provides a IBRange{T} of 21-bit UCS-4 characters. "U" stands for "Unicode", as in UCS-4, as opposed to a normal string that is UTF-16.
CLoyc.Collections.IListAndListSource< T >	This interface combines the original IList{T} interface with its "source" (read-only) component interfaces, including IReadOnlyList{T}, plus IListSource{T}.
CLoyc.Collections.Impl.InternalDList< T >	A compact auto-enlarging deque structure that is intended to be used within other data structures. It should only be used internally in "private" or "protected" members of low-level code. In most cases, you should use DList{T} instead.
CLoyc.Collections.IRange< out T >	A random-access range, also known as a "slice". Allows you to narrow down the range like IBRange{T} does, and also provides random access via IListSource{T}.
►CLoyc.Collections.ISparseListSource< T >	Represents a read-only indexed list in which parts of the index space may be unused or "clear".
CLoyc.Collections.ISparseList< T >	Represents a sparse list that allows insertion and removal of items and empty spaces. In a sparse list, some spaces can be "clear" meaning that they have no value.
CLoyc.Collections.ListSourceAsSparse< T >	Adapter from IListSource{T} to ISparseListSource{T}.
►CLoyc.IReferenceComparable	This is a tag which indicates that objects of this type are unique; specifically, any two different objects that implement this interface are always unequal, and one object is equal only to itself.
CLoyc.Symbol	Represents a symbol, which is a singleton string that supports fast comparisons and extensible enums.
►CISet< T >
CLoyc.Collections.MSet< T >	A mutable set.
►CLoyc.Collections.ISetOperations< in T, in InSetT, out OutSetT >
CLoyc.Collections.ISetImm< T >	An immutable set that supports numerous set operations.
►CLoyc.Collections.ISetOperations< in T, SetT >	Set-combining operations: With, Without, Union, Intersect, Except, Xor.
CLoyc.Collections.ISetImm< T, SetT >	An immutable set of type SetT with elements of type T.
CLoyc.Collections.Map< K, V >	An immutable dictionary.
CLoyc.Collections.MMap< K, V >	A dictionary class built on top of InternalSet<KeyValuePair<K,V>>.
►CLoyc.Collections.ISetTests< SetT >	Set testing operations.
CLoyc.Collections.ISetImm< T >	An immutable set that supports numerous set operations.
CLoyc.Collections.ISetImm< T, SetT >	An immutable set of type SetT with elements of type T.
CLoyc.Syntax.Lexing.ISimpleToken	Alias for ISimpleToken{int}.
►CLoyc.Collections.ISinkArray< T >	Represents a write-only array.
CLoyc.Collections.IArray< T >	This interface models the capabilities of an array: getting and setting elements by index, but not adding or removing elements.
CLoyc.Collections.ISinkList< T >	Represents a write-only indexable list class.
►CLoyc.Geometry.ISizeReader< T >	Interface for reading the size of a 2D object.
►CLoyc.Geometry.IRectangleReader< T >	Represents a read-only 2D rectangle.
►CLoyc.Geometry.IRectangle3Reader< T >	Represents a read-only 3D rectangular prism.
►CLoyc.Geometry.IRectangle3Base< T >	Represents a mutable 3D rectangular prism.
CLoyc.Geometry.IRectangle3< T >	Represents a mutable 3D rectangle.
►CLoyc.Geometry.IRectangleBase< T >	Represents a mutable 2D rectangle.
CLoyc.Geometry.IRectangle3Base< T >	Represents a mutable 3D rectangular prism.
CLoyc.Geometry.IRectangle< T >	Represents a mutable 2D rectangle.
►CLoyc.Geometry.ISize3Reader< T >	Interface for reading the size of a 3D object.
CLoyc.Geometry.IRectangle3Reader< T >	Represents a read-only 3D rectangular prism.
►CLoyc.ITags< T >	Interface for an object that can have "tags" attached, which are arbitrary objects reached through a key Symbol.
CLoyc.HashTags< ValueT >	An implementation of IAttributes that can hold one attribute before allocating any memory for a hashtable. It is intended to be used as a base class but can be used on its own.
CLoyc.Utilities.TagsInWList< ValueT >	An implementation of ITags designed for AstNode.
►CLoyc.Math.ITrigonometry< T >	Provides trigonometry operations.
CLoyc.Math.IFloatMath< T >	Provides operations available on floating-point types (float and double), including trigonometry and exponentiation.
►CLoyc.Math.IZeroProvider< T >	Provides the value of "zero" for type T.
►CLoyc.Math.IAdditionGroup< T >	This defines a Group with the operation +, the neutral element Zero, and an operation - that is defined in terms of the inverse. A Negate operation is not provided so that this interface makes more sense for use with unsigned types
CLoyc.Math.IRing< T >	This defines a Ring with the operations +,*
CLoyc.Math.IBitwise< T >	Provides the standard set of bitwise operators.
CLoyc.Math.INumTraits< T >	This interface provides information about a numeric type T.
CLoyc.Collections.Impl.KeyWalker	Internal implementation class. Represents a pointer to a location within a byte array.
CLoyc.LLParserGenerator.LLParserGenerator.KthSet	Represents the possible interpretations of a single input character, in terms of transitions in the grammar.
CLoyc.Collections.LCExt	Extension methods for Loyc Collection interfaces (such as IListSource{T}) and for Loyc Collection adapters (such as AsReadOnly{T}, which returns a CollectionAsReadOnly{T} adapter.)
CLoyc.Collections.LCInterfaces	This class contains extension methods that are provided as part of various Loyc.Collections interfaces. For example, it provides methods such as IndexOf(), Contains() and CopyTo(), that the traditional ICollection{T} and IList{T} interfaces require the author to write himself.
CLoyc.Syntax.Les.LesNodePrinter	Prints a Loyc tree in LES (Loyc Expression Syntax) format.
CLoyc.Syntax.Les.LesPrecedence	Contains Precedence objects that represent the precedence levels of LES.
CLoyc.Syntax.Les.LesPrecedenceMap	This class's main job is to maintain a table of Precedence values for LES operators. When you ask about a new operator, its precedence is cached for future reference.
CLoyc.Syntax.Lexing.LexerSource	A synonym for LexerSource{C} where C is ICharSource.
►CLoyc.Syntax.LineAndCol	Holds a line number (Line) and a position in the line (PosInLine). This class isn't really needed in Loyc but is separated from SourcePos in case anyone might want position without a filename.
►CLoyc.Syntax.SourcePos	Holds a filename (FileName), a line number (Line) and a position in the line (PosInLine), representing a position in a source code file.
CLoyc.Syntax.SourcePosAndIndex	A SourcePos that also includes the original index from which the Line and PosInLine were derived.
CLoyc.Geometry.LineMath	Contains algorithms that operate on lines.
CLoyc.Syntax.LineRemapper	A small helper class for languages such as C# and C++ that permit the locations reported by error messages to be remapped. This class stores and applies such commands (#line in C#/C++)
CLoyc.Geometry.LineSegment3< T >	Holds a 3D line segment.
CLoyc.Geometry.LineSegment< T >	Holds a 2D line segment.
CLoyc.Collections.LinqToCollections	Work in progress. This class will enhance LINQ-to-Objects with type-preserving and/or higher-performance extension methods.
CLoyc.Collections.ListChangeInfo< T >	Contains information about how a collection is about to change.
CLoyc.Collections.ListExt	Extension methods and helper methods for List{T}, IList{T}, IReadOnlyList{T}, arrays, IListSource{T}, and for related mutable interfaces such as IArray{T}.
►CListSourceBase< char >
CLoyc.Syntax.StreamCharSource	Exposes a stream as an ICharSource, as though it were an array of characters. The stream must support seeking, and if a text decoder is specified, it must meet certain constraints.
►CListSourceBase< NegList< T >>
CLoyc.Collections.SelectNegLists< T >	Adapter: provides a view of an IList{T} in which element [i] is a NegList{T} N such that N[0] refers to element [i] in the original list. See LCExt.NegLists{T}(IList{T}) for more information.
►CListSourceBase< NegListSource< T >>
CLoyc.Collections.SelectNegListSources< T >	Adapter: provides view of an IListSource{T} in which element [i] is a NegListSource{T} N such that N[0] refers to element [i] in the original list. See LCExt.NegLists{T}(IListSource{T}) for more information.
►CListSourceBase< TOut >
CLoyc.Collections.UpCastListSource< T, TOut >	Helper class for treating a collection of a derived type as a collection of a base type or interface.
►CListSourceBase< TResult >
CLoyc.Collections.SelectListSource< T, TResult >	Helper class: provides a modified view of an IListSource by transforming each element on-demand. Objects of this type are returned from LCExt.Select{T,TResult}(IListSource{T},Func{T,TResult})
CLoyc.Collections.ListSourceDebugView< T >	This helper class gives a nice view of a custom collection within the debugger.
CLoyc.LLParserGenerator.LLParserGenerator	Encapsulates LLLPG, the Loyc LL Parser Generator, which generates LL(k) recursive-descent parsers.
►CLoyc.LLParserGenerator.LlpgGeneralTestsBase	Shared base class for "full-stack" LLLPG tests that use LeMP, the Ecs parser, and LLLPG macros in addition to the core engine.
CLoyc.LLParserGenerator.LlpgBugsAndSlugs	Tests for known slugs (slowness bugs) and fixed bugs (regressions)
CLoyc.LLParserGenerator.LlpgTestLargerExamples
CLoyc.LLParserGenerator.LlpgHelpers	Helper methods for making LLLPG grammar nodes. Used by LlpgCoreTests.
CLoyc.Syntax.LNodeExt	Standard extension methods for LNode.
CLoyc.Syntax.LNodeFactory	Contains helper methods for creating LNodes. An LNodeFactory holds a reference to the current source file (File) so that it does not need to be repeated every time you create a node.
CLoyc.Localize	Localize is a global hook into which a string-mapping localizer can be installed. It is designed to make internationalization exceptionally easy for developers. TODO: expand I18N features based on Mozilla's L20N.
CLeMP.MacroContext	Standard extension methods for IMacroContext.
CLeMP.MacroProcessor	Encapsulates the LeMP engine, a simple LISP-style macro processor, suitable for running LLLPG and other lexical macros.
CLoyc.LLPG.Macros	Macros for using LLLPG in LeMP.
CLoyc.Math.Math128	Contains methods for manipulating 128-bit numbers, multiplying 64-bit numbers to produce 128-bit results, and dividing 128-bit numbers by 64-bit numbers.
CLoyc.Math.MathEx	Provides additional math functions that are not available in System.Math.
CLoyc.Math.MathExtensions	Standard extension methods for generic math interfaces such as IOrdered{T}.
CLoyc.Math.Maths< T >	This class helps generic code to perform calculations on numbers of unknown type, by providing access to various math interfaces.
CLoyc.Maybe
CLoyc.MemoizedTypeName	.NET Framework reflection doesn't offer complete type names for generic types such as "List&lt;int>" (the Type.Name value of that class is "List`1"). Get fills in the gap, and also saves the computed name for fast repeated lookups.
CLoyc.MemoizedTypeName< T >	MemoizedTypeName<T>.Get() is an alternative to MemoizedTypeName.Get(typeof(T)).
CLoyc.MessageSink	Holds the default message sink for this thread (Current), Symbols for the common message types, such as Warning and Error, and default instances of ConsoleMessageSink, TraceMessageSink and NullMessageSink.
CLoyc.NoValue	NoValue.Value is meant to be used as the value of a property that has "no value", meaning no value is assigned or that the property is meaningless at the current time or in the current context.
CLoyc.Pair	Pair.Create(a, b) is a helper method for making pairs.
CLoyc.Syntax.ParsingService	Extension methods for IParsingService.
CLoyc.LLParserGenerator.PGTerminalSet	Extension methods for IPGTerminalSet.
CLoyc.Geometry.PointExt	Contains methods for manipulating points in generic code.
CLoyc.Geometry.PointMath	Math and extension methods for Point{T}.
CLoyc.Geometry.PolygonMath	Contains useful basic polygon algorithms: hit testing, area calculation, orientation detection.
►CLoyc.LLParserGenerator.PredA	Analytic predicate: a simpler form of predicate used for prediction analysis.
CLoyc.LLParserGenerator.AltsA
CLoyc.LLParserGenerator.EmptyA
CLoyc.LLParserGenerator.RecursiveRefA
CLoyc.LLParserGenerator.TerminalA
►CLoyc.LLParserGenerator.PredVisitor	Base class for implementing a visitor that examines a tree of LLLPG Predicates.
CLoyc.LLParserGenerator.LLParserGenerator.ComputeNext	Gathers a list of all one-token transitions starting from a single position. Also gathers any and-predicates that must be traversed before completing a transition.
CLoyc.LLParserGenerator.LLParserGenerator.GenerateCodeVisitor	Directs code generation using the visitor pattern to visit the predicates in a rule. The process starts with Generate(Rule).
CLoyc.LLParserGenerator.LLParserGenerator.GetCanonical	Computes the "canonical" interpretation of a position for prediction purposes, so that ConsolidateDuplicatePositions can detect duplicates reliably. Call Do() to use.
►CLoyc.LLParserGenerator.RecursivePredVisitor	Base class for implementing a visitor that examines a tree of LLLPG Predicates. The default implementation of Visit(P) for each predicate type P recursively visits the children of the P.
CLoyc.LLParserGenerator.AutoValueSaverVisitor	Helper class invoked just after StageTwoParser. Its job is to create variables referenced by labels (label:item) and by code blocks ($RuleName), to modify the code blocks to remove the $ operator, and to update the ResultSaver of each labeled predicate. Also supports $result.
CLoyc.LLParserGenerator.LLParserGenerator.PredictionAnalysisVisitor	Performs prediction analysis using the visitor pattern to visit the predicates in a rule. The process starts with Analyze(Rule).
CLoyc.LLParserGenerator.RecursiveReplacementPredVisitor	Base class for visitors that can replace predicates entirely.
CLoyc.LLParserGenerator.Program	Entry point of LLLPG.exe, with QuickRun() method to help invoke LLLPG programmatically.
CTextEditor.Program
CLoyc.Range
CLoyc.Collections.RangeExt	Extension/helper methods for ranges.
►CReadOnlyCollectionBase< TOut >
CLoyc.Collections.UpCastSource< T, TOut >	Helper class for treating a collection of a derived type as a collection of a base type or interface.
CLoyc.Geometry.Rectangle3Ext	Contains methods to manipulate rectangles.
CLoyc.Geometry.RectangleExt	Contains methods to manipulate rectangles.
CLoyc.LLParserGenerator.Rule	Represents an LLLPG rule, which is a Predicate plus a Name and optional attributes (e.g. token, private, etc.).
CLoyc.MiniTest.RunTests	Searches for test methods and runs them, printing the name of each test to the console followed by errors (if any) produced by the test.
CLoyc.Collections.Impl.SCell	Standard cell, used to encode keys in a CPSNode
CLoyc.Collections.SimpleCache< T >	A cache designed to save memory by sharing instances of identical strings and other immutable objects.
CLoyc.Utilities.SimpleTimer	A fast, simple timer class with a more convenient interface than System.Diagnostics.Stopwatch. Its resolution is typically 10-16 ms on desktop Windows systems.
CLoyc.Syntax.SourceFile
CLoyc.Syntax.SourceRange	Holds a reference to a source file (ISourceFile<char>) and the beginning and end indices of a range in that file.
CLoyc.Utilities.Statistic	A lightweight class to help you compute the minimum, maximum, average and standard deviation of a set of values. Call Clear(), then Add(each value); you can compute the average and standard deviation at any time by calling Avg() and StdDeviation().
CLoyc.StringExt	Extension methods for strings, such as SplitAt, Left, Right, Format and USlice.
CLeMP.Test.TestMacros
CLoyc.Threading.ThreadEx	Creates and controls a thread, and fills in a gap in the .NET framework by propagating thread-local variables from parent to child threads, and by providing a ThreadStarting event.
►CLoyc.Threading.ThreadLocalVariableBase	When used with ThreadEx, implementing this base class allows you to be notified when a child thread is created or terminates.
CLoyc.Threading.ThreadLocalVariable< T >	Provides access to a thread-local variable through a dictionary that maps thread IDs to values.
CLoyc.Threading.TinyReaderWriterLock	A fast, tiny 4-byte lock to support multiple readers or a single writer. Designed for low-contention, high-performance scenarios where reading is common and writing is rare.
CLoyc.Syntax.Les.TokenExt	Provides the Type() extension method required by Token and the ToString(Token) method to express an LES token as a string, for tokens that contain sufficient information to do so.
CLoyc.Ecs.Parser.TokenExt	Provides the Type() extension method required by Token and the ToString(Token) method to express an EC# token as a string, for tokens that contain sufficient information to do so.
CLoyc.Triplet< T1, T2, T3 >	A tuple of three values (A, B and C) in a struct.
CLoyc.TypeExt	Extension methods for Type.
CLoyc.Utilities.UG	Contains global functions of Loyc.Utilities that don't belong in any specific class.
►CUserControl
CTextEditor.LempDemoPanel
CLoyc.ValueComparer< T >	You'd think the .NET framework would have a built-in method–even a CIL opcode–to bitwise-compare two values. Not supporting bitwise compare is, in my opinion, one of several mind-bogglingly dumb decisions in the CLR. Instead, all you can do is call ValueComparer.Default.Equals(a, b).
CLoyc.Geometry.VectorExt	Extension methods for vectors. TODO: reconsider distribution of methods between this class and PointMath in Loyc.Utilities.
►CLoyc.Collections.VListBlock< T >	VListBlock implements the core functionality of FVList, VList, FWList and WList. It is not intended to be used directly.
CLoyc.Collections.VListBlockArray< T >	Implementation of VListBlock(of T) that contains an array. It is always initialized with at least one item, and items cannot be removed unless the list is mutable.
CLoyc.Collections.VListBlockOfTwo< T >	The tail of a VList contains only one or two items. To improve efficiency slightly, these two-item lists are represented by a VListBlockOfTwo, which is more compact than VListBlockArray.
CLoyc.void	.Value represents the sole value of System.Void (called "void" in C#).
►CWeakReference
CLoyc.Collections.WeakKeyReference< T >	Provides a weak reference to an object of the given type to be used in a WeakDictionary along with the given comparer.
CLoyc.WeakReferenceExt	The new WeakReference{T} type in .NET 4.5 removes the Target and IsAlive properties. These extension methods restore that traditional functionality, making it easier to transition from the old WeakReference to the new one.
CLoyc.Syntax.Lexing.WhitespaceFilter	Alias for WhitespaceFilter{Token}
CLoyc.Syntax.Lexing.WhitespaceTag	WhitespaceTag.Value can be used as the Token.Value of whitespace tokens, to make whitespace easy to filter out.
►CWListProtected< KeyValuePair< Symbol, ValueT >>
CLoyc.Utilities.TagsInWList< ValueT >	An implementation of ITags designed for AstNode.
►CLoyc.Collections.WListProtected< T >	WList implementation in which the WList operations are only accessible to a derived class.
CLoyc.Collections.WListBase< T >	Shared base class of FWList and WList.
►CLoyc.WrapperBase< T >	Abstract class that helps you implement wrappers by automatically forwarding calls to Equals(), GetHashCode() and ToString().
CLoyc.Collections.CollectionAsReadOnly< T >	Adapter: a read-only wrapper that implements ICollection(T) and IReadOnlyCollection(T), returned from LCExt.AsReadOnly{T}.
CLoyc.Collections.ListAsListSource< T >	Helper type returned from LCExt.AsListSource{T}.
CLoyc.Collections.ListSourceAsList< T >	Adapter: a read-only wrapper that implements IList(T) and IListSource(T), returned from LCExt.AsList{T}.
CLoyc.Collections.ReadOnlyAsCollection< T >	A read-only wrapper that implements ICollection(T) and ISource(T), returned from LCExt.AsCollection{T}
CLoyc.Syntax.SourceFileWithLineRemaps	An wrapper around ISourceFile that applies line remapping information (if the source file uses it).