Class Hierarchy

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

[detail level 123456]

CLoyc.Syntax.AbstractTriviaInjector< Trivia >	Encapsulates an algorithm that consumes trivia (comments and newlines) from a list and adds it as trivia attributes into LNodes
►CLoyc.Syntax.AbstractTriviaInjector< Token >
►CLoyc.Syntax.StandardTriviaInjector	Encapsulates an algorithm that consumes trivia (comments and newlines) from a list and adds it as trivia attributes into LNodes. This makes it possible to preserve comments and newlines independently of the language parser, so that the parser need not be specifically designed to preserve them
CLoyc.Ecs.Parser.EcsTriviaInjector	Trivia injector customized for Enhanced C#
CLeMP.Tests.A.AliasTest
CLeMP.Tests.B.AliasTest
►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.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.SparseAList< T >	A sparse A-List that implements ISparseList<T>
CLoyc.Collections.AListBase< K, T >	Base class for the indexed tree-based data structures known as AList<T> and BList<T>
►CLoyc.Collections.AListBase< int, T >
CLoyc.Collections.AListBase< K, T >	Manages a collection of IAListTreeObserver<K, T>
►CAListBase< K, KeyValuePair< 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.AListBase< K, T >
►CLoyc.Collections.AListBase< T, T >
CLoyc.Collections.BList< T >	An sorted in-memory list that is efficient for all operations and offers indexed access to its list
CLoyc.Collections.AListExt
CLoyc.Collections.Impl.AListIndexer< int, T >
CLoyc.Collections.Impl.AListInnerBase< int, T >
►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.AListLeaf< int, T >
►CLoyc.Collections.Impl.AListLeafBase< int, T >
CLoyc.Collections.Impl.SparseAListLeaf< T >	Internal implementation class. Leaf node of SparseAList<T>
►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.AListLeafBase< K, T >
CLoyc.Collections.AListStatisticTracker< K, T, TSummary >	This class efficiently lets you keep track of simple commutative statistics (such as total, average, sum of squares, and min/max) derived from the items of AList<T> and its variants (BList, BDictionary, and BMultiMap)
CLoyc.Collections.AListStatisticTracker< K, T >	This class incrementally updates a Statistic object based on changes to AList<T> and its variants (BList, BDictionary, and BMultiMap)
►CLoyc.Collections.AListStatisticTracker< int, T >
CLoyc.Collections.AListStatisticTracker< T >
►CLoyc.Collections.AListStatisticTracker< K, T, double >
CLoyc.Collections.AListSumTracker< T >
CLoyc.Collections.AListStatisticTracker< K, T, TStatistic >
►CLoyc.Collections.AListStatisticTrackerBase< K, T, Statistic >
CLoyc.Collections.AListStatisticTracker< T >
CLoyc.Collections.AListSumTracker< K, T >	This class incrementally recomputes the sum of an AList<T> (or its variants - BList, BDictionary, and BMultiMap)
►CLoyc.Collections.AListSumTracker< int, T >
CLoyc.Collections.AListSumTracker< 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, especially used by Loyc collection classes but sometimes useful in other cases
►CAttribute
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
►CAttribute
CLeMP.ContainsMacrosAttribute	Marks a class to be searched for macros
►CLeMP.LexicalMacroAttribute	Marks a method as a LeMP lexical macro
CLeMP.MacroInfo	Data returned from IMacroContext.AllKnownMacros
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, or passes it to another localizing method
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.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
CLoyc.MiniTest.TestFixtureAttribute	Identifies a class that contains unit tests, or methods that return other tests or test fixtures
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
►CLoyc.Syntax.Lexing.BaseILexer< ICharSource, Token >
CLoyc.Syntax.Les.Les2Lexer	Lexer for EC# source code
CLoyc.Syntax.Les.Les3Lexer
►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.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.BaseParser< Token >
CLoyc.Ecs.Parser.EcsParser	Parses Enhanced C# code into a sequence of Loyc trees (LNode), one per top-level statement
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, Int32 >
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.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.ParserSource< Token >	Alias for ParserSource{Token, int, IList{Token}}
►CLoyc.Syntax.BaseParserForList< Token, int >
CLoyc.Syntax.Les.Les2Parser	Parses LES (Loyc Expression Syntax) code into a sequence of Loyc trees (LNode), one per top-level statement
CLoyc.Syntax.Les.Les3Parser
►CBaseParserForList< Token, MatchType, IList< Token >>
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.BaseParserNoBacktracking< Token, Enumerator >	An base class designed for parsers that use LLLPG (Loyc LL(k) Parser Generator) and receive tokens from any IEnumerator<Token>
►CBaseParserNoBacktracking< Token, 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.Collections.BDictionary< int, Loyc.Pair< int, string > >
CLoyc.Collections.Bijection< K2, K1 >
►CBList< KeyValuePair< K, V >>
CLoyc.Collections.BMultiMap< K, V >	An sorted dictionary that allows multiple values to be associated with a single key
CLoyc.Utilities.BloomFilterM64K2	A bloom filter for very small sets
CLoyc.Collections.BMultiMap< Loyc.Collections.Impl.AListNode< K, T >, Loyc.Collections.Impl.AListInnerBase< K, T > >
CLoyc.Collections.BMultiMap< T, Loyc.Collections.Impl.AListLeafBase< K, 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.ByteArrayInString	Encodes and decodes BAIS (Byte Array In String) encoding, which preserves runs of ASCII characters unchanged. This encoding is useful for debugging (since ASCII runs are visible) and for conversion of bytes to JSON
CLoyc.Collections.CG	Contains global functions of Loyc.Collections that don't belong in any specific class
CLoyc.Syntax.Lexing.CharCategory
CLoyc.CheckParam	Helper methods for checking argument values that throw exceptions when an argument value is not acceptable
CLoyc.Syntax.Impl.PrinterState.Checkpoint
►CLoyc.Syntax.CodeSymbols	A list of common symbols that, by convention, have special meaning: operators, built-in data types, keywords, trivia, etc
CLoyc.Ecs.EcsCodeSymbols	A list of symbols that are very specific to C# or Enhanced C#. Note: many symbols Loyc.Syntax.CodeSymbols should be in this class instead, but this class was created very belatedly
CLoyc.Collections.CollectionDebugView< T >	This helper class gives a nice view of a custom collection within the debugger
CLoyc.Collections.CollectionSource
►CCollectionWithChangeEvents< T, ICollection< T >>
CLoyc.Collections.CollectionWithChangeEvents< T >	A collection wrapper that provides ListChanging and ListChanged events. Shorthand for Loyc.Collections.Impl.CollectionWithChangeEvents<T,ICollection<T>>
►CLoyc.Collections.Impl.CollectionWrapper< KeyValuePair< K, V >, TDictionary >
►CLoyc.Collections.Impl.DictionaryWrapper< K, V, TDictionary >	A simple base class that helps you use the decorator pattern on a dictionary. By default, all it does is forward every method to the underlying collection (including GetHashCode, Equals and ToString). You can change its behavior by overriding methods
CLoyc.Collections.Impl.DictionaryWithChangeEvents< K, V, TDictionary >	A dictionary wrapper that provides ListChanging and ListChanged events. You can also implement custom behavior by overriding its methods
►CLoyc.Collections.Impl.CollectionWrapper< T, TColl >
CLoyc.Collections.Impl.CollectionWithChangeEvents< T, TColl >	A collection wrapper that provides ListChanging and ListChanged events. You can also implement custom behavior by overriding its methods
►CLoyc.Collections.Impl.CollectionWrapper< T, TList >
►CLoyc.Collections.Impl.ListWrapper< T, TList >	A simple base class that to helps you implement a "smart" collection. By default, all it does is forward every method to the underlying collection (including GetHashCode, Equals and ToString). You can change its behavior by overriding methods
CLoyc.Collections.Impl.ListWithChangeEvents< T, TList >	A list wrapper that provides ListChanging and ListChanged events. You can also implement custom behavior by overriding its methods
►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 namespaces
CLoyc.LLParserGenerator.LlpgGeneralTestsBase.TestCompiler
►CLoyc.Collections.Impl.CPEnumerator< TValue >
CLoyc.Collections.CPStringTrie< TValue >.Enumerator	Enumerates key-value pairs in a CPStringTrie
CLoyc.Collections.CPStringTrie< TValue >.KeyEnumerator	Enumerates keys of a CPStringTrie
CLoyc.Collections.Impl.CPByteTrie< TValue >.Enumerator
CLoyc.Collections.Impl.CPIntTrie< TValue >.IntEnumerator
CLoyc.Collections.Impl.CPIntTrie< TValue >.LongEnumerator
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.CPTrie< TValue >
CLoyc.Collections.CPStringTrie< TValue >	A compact patricia trie that uses strings as keys
CLoyc.Collections.Impl.CPByteTrie< TValue >	A compact patricia trie that uses byte arrays as keys
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.DictionaryBase< 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.)
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>, IDictionary<K,V> and IDictionaryEx<K, V>
►CDictionaryWithChangeEvents< K, V, IDictionary< K, V >>
CLoyc.Collections.DictionaryWithChangeEvents< K, V >	A dictionary wrapper that provides ListChanging and ListChanged events. Shorthand for Loyc.Collections.Impl.DictionaryWithChangeEvents<K,V,IDictionary<K,V>>
CLoyc.Ecs.EcsNodePrinter	Encapsulates the code for printing an LNode 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.EmptyList< T >	Helper class: EmptyList<T>.Value is a read-only empty list
CLoyc.Collections.EnumerableExt	Additional extension methods for IEnumerable<T>, IReadOnlyCollection<T>, and ICollection<T>, beyond what LINQ provides
CLoyc.Compatibility.EnumStatic	Implements Enum.TryParse in .NET 3.5
►CEqualityComparer
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)
CLoyc.G	Contains global functions that don't belong in any specific class
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.Heap
CLoyc.Collections.IAdd< in in T >	An interface for depositing items. Includes only an Add(T) method
►CLoyc.Collections.IAdd< T >
CLoyc.Collections.ICollectionSink< in in T >	Represents a write-only collection: you can modify it, but you cannot learn what it contains
►CIAddRange< KeyValuePair< 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.Impl.DictionaryWithChangeEvents< K, V, TDictionary >	A dictionary wrapper that provides ListChanging and ListChanged events. You can also implement custom behavior by overriding its methods
CLoyc.Collections.MMap< K, V >	A dictionary class built on top of InternalSet<KeyValuePair<K,V>>
►CLoyc.Collections.IAddRange< T >
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 is intended to be implemented by editable collection classes that are not indexable lists nor dictionaries
CLoyc.Collections.BList< T >	An sorted in-memory list that is efficient for all operations and offers indexed access to its list
CLoyc.Collections.ICollectionExWithChangeEvents< T >	Combines ICollectionEx<T> with INotifyListChanging<T, ICollection<T>> and INotifyListChanged<T, ICollection<T>>. This exists for completeness; as of 2020/12 there are no implementations
►CLoyc.Collections.IListEx< T >	This interface combines the original IList(T) interface with others - IListSource(T), ISinkList(T), IArray(T) - and some 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.DList< T >	A compact auto-enlarging list that efficiently supports supports insertions at the beginning or end of the list
►CLoyc.Collections.IListExWithChangeEvents< T >
CLoyc.Collections.Impl.ListWithChangeEvents< T, TList >	A list wrapper that provides ListChanging and ListChanged events. You can also implement custom behavior by overriding its methods
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.IListRangeMethods< in in T >	The batch-operation methods of IListEx<T>, mainly for collection types that can add or remove multiple items in one method call
►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.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.AListStatisticTrackerBase< K, T, TSummary >	Base class that helps efficiently keep track of statistics about the contents of one or more AListBase<K, T> objects (including derived classes such as AList, BList, BDictionary and BMultiMap). Usually you'll use one of the derived classes instead, e.g. AListSumTracker<K,T>
CLoyc.Collections.AListStatisticTracker< T >
CLoyc.Collections.Impl.AListIndexer< K, T >	Observes changes and builds a table of items in the tree
CLoyc.Collections.Impl.IAListTreeObserver< int, T >
CLoyc.Collections.IArraySink< in in T >	Represents a write-only array
►CLoyc.Collections.IArraySink< T >
►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 others - IListSource(T), ISinkList(T), IArray(T) - and some 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.IListSink< in in T >	Represents a write-only indexable list class
►CLoyc.Collections.IAutoCreatePool< UString, Symbol >
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
CLoyc.Collections.IBRange< char >
►CLoyc.Collections.IBRange< T >
CLoyc.Collections.IBRangeEx< T >	A bidirectional 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 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.IBRange< 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
►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.IRangeEx< T >	A random-access range that can perform operations such as intersection and overlap tests on pairs of ranges
►CLoyc.Collections.IBRangeEx< IBRangeEx< T >, T >
CLoyc.Collections.IBRangeEx< T >	A bidirectional range that can perform operations such as intersection and overlap tests on pairs of ranges
►CLoyc.ICloneable< out out T >	Interface for types that can duplicate themselves
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.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
►CICloneable< AList< T >>
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
►CICloneable< AListBase< T >>
CLoyc.Collections.AListBase< K, T >	Manages a collection of IAListTreeObserver<K, T>
►CICloneable< ArraySlice< T >>
CLoyc.Collections.ArraySlice< T >	Adapter: Provides access to a section of an array
►CICloneable< BDictionary< 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
►CICloneable< BList< T >>
CLoyc.Collections.BList< T >	An sorted in-memory list that is efficient for all operations and offers indexed access to its list
►CLoyc.ICloneable< DescendantsFrame >
CLoyc.Syntax.DescendantsFrame	Helper class used to enumerate LNode.Descendants()
►CICloneable< DList< T >>
CLoyc.Collections.DList< T >	A compact auto-enlarging list that efficiently supports supports insertions at the beginning or end of the list
►CICloneable< FVList< T >>
CLoyc.Collections.FVList< T >	A reference to a FVList, a so-called persistent list data structure
►CICloneable< FWList< T >>
CLoyc.Collections.FWList< T >	FWList is the mutable variant of the FVList data structure
►CICloneable< IBRange< T >>
CLoyc.Collections.IBRange< out out T >	A bidirectional range. Allows you to read or remove the first or last element in a range
►CICloneable< IBRangeEx< T >>
CLoyc.Collections.IBRangeEx< T >	A bidirectional range that can perform operations such as intersection and overlap tests on pairs of ranges
►CICloneable< IDictionaryEx< K, V >>
►CLoyc.Collections.IDictionaryEx< K, V >	Combines IDictionary, IReadOnlyDictionary, and IDictonarySink with a few additional methods
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.IDictionaryExWithChangeEvents< K, V >
CLoyc.Collections.MMap< K, V >	A dictionary class built on top of InternalSet<KeyValuePair<K,V>>
►CICloneable< IFRange< T >>
CLoyc.Collections.IFRange< out 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>
►CICloneable< InternalDList< 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
►CICloneable< InternalList< T >>
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
►CICloneable< IRange< T >>
CLoyc.Collections.IRange< out 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>
►CICloneable< IRangeEx< T >>
CLoyc.Collections.IRangeEx< T >	A random-access range that can perform operations such as intersection and overlap tests on pairs of ranges
►CICloneable< IToken< TT >>
CLoyc.Syntax.Lexing.IToken< TT >	The methods of Token in the form of an interface
►CLoyc.ICloneable< Les2Lexer >
CLoyc.Syntax.Les.Les2Lexer	Lexer for EC# source code
►CICloneable< ListSlice< 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.ICloneable< LNode >
►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.ICloneable< LNodeList >
CLoyc.Syntax.LNodeList	A list of non-null references to LNode
►CLoyc.ICloneable< MessageHolder >
CLoyc.MessageHolder	A message sink that puts the messages it receives in a list
►CICloneable< MMap< K, V >>
CLoyc.Collections.MMap< K, V >	A dictionary class built on top of InternalSet<KeyValuePair<K,V>>
►CICloneable< MSet< T >>
CLoyc.Collections.MSet< T >	A mutable set
►CICloneable< NegListSlice< T >>
CLoyc.Collections.NegListSlice< T >	Adapter: a random-access range for a slice of an INegListSource<T>
►CLoyc.ICloneable< Pred >
►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.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.LLParserGenerator.ZeroWidthPred
CLoyc.LLParserGenerator.ActionPred
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
►CICloneable< ROLSlice< TList, T >>
CLoyc.Collections.ROLSlice< TList, T >	Adapter: a random-access range for a slice of an IReadOnlyList<T>
CLoyc.ICloneable< Scope >
►CICloneable< Slice_< T >>
CLoyc.Collections.Slice_< T >	Adapter: a random-access range for a slice of an IListSource<T>
►CICloneable< SparseAList< T >>
CLoyc.Collections.SparseAList< T >	A sparse A-List that implements ISparseList<T>
►CLoyc.ICloneable< 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
►CLoyc.ICloneable< Transition >
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.ICloneable< 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
►CICloneable< VList< T >>
CLoyc.Collections.VList< T >	VList represents a reference to a reverse-order FVList
►CICloneable< WeakValueDictionary< 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.)
►CICloneable< WList< T >>
CLoyc.Collections.WList< T >	WList is the mutable variant of the VList data structure
►CICollection
CLoyc.Collections.BMultiMap< K, V >.ValueList	Represents the set of values associated with a particular key in a BMultiMap<K,V> collection
CLoyc.Collections.CPStringTrie< TValue >.KeyCollection	Return value of CPStringTrie<T>.Keys
CLoyc.Collections.CPValueCollection< T >	Provides read-only access to the values of a CPTrie
►CLoyc.Collections.ICollectionAndReadOnly< T >	This interface is meant to be implemented by read-only sequence types that originally implemented ICollection<T> and want to now implement IReadOnlyCollection<T>. It is recommended to implement ICollectionAndSource<T> instead, but the latter requires you to implement a couple of additional methods
CLoyc.Collections.CollectionAsReadOnly< T >	Adapter: a read-only wrapper that implements ICollection(T) and IReadOnlyCollection(T), returned from EnumerableExt.AsReadOnly<T>
►CLoyc.Collections.ICollectionAndSource< T >	This interface is to be implemented by read-only sequence types that still want to be compatible with APIs that accept ICollection<T>. (writable collections should implement ICollectionImpl<T> instead.)
►CLoyc.Collections.IListAndListSource< T >	This interface is to be used by read-only sequences that nevertheless wish to be compatible with APIs that accept IList<T>. (writable collections should implement IListImpl<T> instead.)
CLoyc.Collections.AListBase< K, T >	Manages a collection of IAListTreeObserver<K, T>
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 others - IListSource(T), ISinkList(T), IArray(T) - and some additional methods (e.g. RemoveAll, InsertRange)
►CLoyc.Collections.IListWithChangeEvents< T >
CLoyc.Collections.IListExWithChangeEvents< T >
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 LinqToLists.Reverse<T>
CLoyc.Collections.Impl.ListWrapper< T, TList >	A simple base class that to helps you implement a "smart" collection. By default, all it does is forward every method to the underlying collection (including GetHashCode, Equals and ToString). You can change its behavior by overriding methods
►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 ListExt.Repeat<T>(T, int)
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.ICollectionImpl< T >	This interface is intended to be implemented by editable collection classes that are not indexable lists nor dictionaries. It is recommended to implement ICollectionEx<T> instead, but the latter requires more effort
CLoyc.Collections.ICollectionEx< T >	This interface is intended to be implemented by editable collection classes that are not indexable lists nor dictionaries
►CLoyc.Collections.IListAndReadOnly< T >	This interface is meant to be implemented by read-only sequence classes that originally implemented IList<T> and want to now implement IReadOnlyList<T> and IReadOnlyCollection<T>. It is recommended to implement IListAndListSource<T> instead, but the latter requires you to implement more methods
CLoyc.Collections.IListAndListSource< T >	This interface is to be used by read-only sequences that nevertheless wish to be compatible with APIs that accept IList<T>. (writable collections should implement IListImpl<T> instead.)
CLoyc.Collections.IListImpl< T >	This interface is intended to be implemented by all Loyc collections that implement IList<T>. It combines the original IList<T> interface with its component interfaces IReadOnlyList<T> and IListSink<T>, plus a little bit of additional functionality in IListSource<T>
►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.MSet< T >	A mutable set
CLoyc.Collections.ReadOnlyAsCollection< T >	A read-only wrapper that implements ICollection(T) and ISource(T), returned from LCExt.AsCollection<T>
CLoyc.Collections.Set< T >	An immutable set
CLoyc.Collections.ICollectionImpl< T >	This interface is intended to be implemented by editable collection classes that are not indexable lists nor dictionaries. It is recommended to implement ICollectionEx<T> instead, but the latter requires more effort
►CLoyc.Collections.ICollectionWithChangeEvents< T >	Combines ICollection<T> with INotifyListChanging<T, ICollection<T>> and INotifyListChanged<T, ICollection<T>>
CLoyc.Collections.Impl.CollectionWithChangeEvents< T, TColl >	A collection wrapper that provides ListChanging and ListChanged events. You can also implement custom behavior by overriding its methods
CLoyc.Collections.Impl.CollectionWrapper< T, TCollection >	A simple base class that helps you use the decorator pattern on a collection. By default, all it does is forward every method to the underlying collection (including GetHashCode, Equals and ToString). You can change its behavior by overriding methods
CLoyc.Collections.Impl.SetWrapper< T, TSet >	A simple base class that helps you use the decorator pattern on a set. By default, all it does is forward every method to the underlying collection (including GetHashCode, Equals and ToString). You can change its behavior by overriding methods
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 >	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.NumRange< Num, Math >	Represents a range of integers of a specified data type
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 >	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.SymbolSet	A set of symbols
►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>>
►CLoyc.Collections.ICollectionAndReadOnly< 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
►CLoyc.Collections.ICollectionAndReadOnly< 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
►CICollectionEx< KeyValuePair< 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.MutableListExtensionMethods.ICollectionExt	Extension methods for ICollection<T>
►CLoyc.Collections.ICollectionSink< T >
CLoyc.Collections.ICollectionImpl< T >	This interface is intended to be implemented by editable collection classes that are not indexable lists nor dictionaries. It is recommended to implement ICollectionEx<T> instead, but the latter requires more effort
CLoyc.Collections.IListSink< in in T >	Represents a write-only indexable list class
CLoyc.Collections.MSet< T >	A mutable set
►CIComparable
CLoyc.LLParserGenerator.IntRange	Represents a range of single characters (e.g. 'A'..'Z')
CLoyc.Pair< T1, T2 >	A tuple of two values, A and B, in a struct
►CLoyc.Symbol	Represents a symbol, which is a singleton string that supports fast comparisons and extensible enums
CLoyc.Syntax.ParsingMode	Standard parsing modes used with IParsingService and ILNodePrinterOptions
►CIComparable< Pair< T1, T2 >>
CLoyc.Pair< T1, T2 >	A tuple of two values, A and B, in a struct
►CIComparer
CLoyc.Collections.ReverseComparer< T, TComparer >	Reverses the order used by an IComparer object
CLoyc.Collections.ReverseComparer< T, TComparer >	Reverses the order used by an IComparer object
►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.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.IUIntMath< T >	Provides operations available on all unsigned integer types (byte, uint, etc.); see also IMath<T>, IIntMath<T>, and IFloatMath<T>
CLoyc.Collections.IContains< in in T >
►CLoyc.Collections.IContains< T >
►CLoyc.Collections.ICollectionSource< T >	A variation of IReadOnlyCollection that provides the Contains() and CopyTo() methods from ICollection
CLoyc.Collections.ICollectionAndSource< T >	This interface is to be implemented by read-only sequence types that still want to be compatible with APIs that accept ICollection<T>. (writable collections should implement ICollectionImpl<T> instead.)
CLoyc.Collections.ICollectionImpl< T >	This interface is intended to be implemented by editable collection classes that are not indexable lists nor dictionaries. It is recommended to implement ICollectionEx<T> instead, but the latter requires more effort
CLoyc.Collections.ISetImm< T >	An immutable set that supports numerous set operations
►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
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
CLoyc.Collections.CPStringTrie< TValue >	A compact patricia trie that uses strings as keys
►CLoyc.Collections.IDictionaryAndReadOnly< K, V >	This interface is meant to be implemented by read-only dictionary classes that originally implemented IDictionary<K, V> and now want to add its read-only version, IReadOnlyDictionary<K, V>
►CLoyc.Collections.IDictionaryImpl< K, V >	This interface is intended to be implemented by all Loyc collections that implement IDictionary<K,V>. It combines the original IDictionary<K,V> interface with its component interfaces IReadOnlyDictionary<K,V> and IDictionarySink<K,V>
CLoyc.Collections.IDictionaryEx< K, V >	Combines IDictionary, IReadOnlyDictionary, and IDictonarySink with a few additional methods
►CLoyc.Collections.IDictionaryWithChangeEvents< K, V >
CLoyc.Collections.IDictionaryExWithChangeEvents< K, V >
CLoyc.Collections.Impl.DictionaryWithChangeEvents< K, V, TDictionary >	A dictionary wrapper that provides ListChanging and ListChanged events. You can also implement custom behavior by overriding its methods
CLoyc.Collections.Impl.DictionaryWrapper< K, V, TDictionary >	A simple base class that helps you use the decorator pattern on a dictionary. By default, all it does is forward every method to the underlying collection (including GetHashCode, Equals and ToString). You can change its behavior by overriding methods
CLoyc.Collections.IDictionaryImpl< K, V >	This interface is intended to be implemented by all Loyc collections that implement IDictionary<K,V>. It combines the original IDictionary<K,V> interface with its component interfaces IReadOnlyDictionary<K,V> and IDictionarySink<K,V>
CLoyc.Collections.Impl.CPByteTrie< TValue >	A compact patricia trie that uses byte arrays as keys
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 >	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.Map< K, V >	An immutable dictionary
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.Collections.IDictionaryAndReadOnly< TKey, TValue >
►CLoyc.Collections.Impl.DictionaryBase< 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
►CLoyc.Collections.IDictionaryImpl< 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
CLoyc.Collections.IDictionarySink< in in K, in in V >	Represents a write-only dictionary class
►CLoyc.Collections.IDictionarySink< 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.IDictionaryImpl< K, V >	This interface is intended to be implemented by all Loyc collections that implement IDictionary<K,V>. It combines the original IDictionary<K,V> interface with its component interfaces IReadOnlyDictionary<K,V> and IDictionarySink<K,V>
►CIDisposable
CLoyc.Collections.KeyCollection< TKey, TValue >.Enumerator
CLoyc.Collections.ValueCollection< TKey, TValue >.Enumerator	Return type of GetEnumerator()
CLoyc.MessageSink.PushedCurrent	Returned by PushCurrent(IMessageSink)
CLoyc.Syntax.BaseParser< Token, MatchType >.SavePosition	A helper class used by LLLPG for backtracking
CLoyc.Syntax.Lexing.BaseLexer< CharSrc >.SavePosition	A helper class used by LLLPG for backtracking
CLoyc.Syntax.LNode.PushedPrinter	Returned by PushPrinter(ILNodePrinter)
CLoyc.Syntax.ParsingService.PushedCurrent	Returned by PushCurrent(IParsingService)
CLoyc.Threading.SavedThreadLocal< T >	Designed to be used in a "using" statement to temporarily alter a ThreadLocal<T>
CLoyc.Threading.SavedValue< T >	Designed to be used in a "using" statement to temporarily alter a ThreadLocalVariable<T> or Holder<T> or something else implementing IHasMutableValue<T>
CLoyc.Threading.ThreadEx.ThreadDestructor	See PropagateVariables for more information
CLoyc.IEither< out out L, out out R >	Represents a type that holds a single value of one of two types (L or R)
►CLoyc.IEither< L, R >
CLoyc.Either< L, R >	Holds a single value of one of two types (L or R)
►CIEnumerable
CLoyc.Collections.IFRange< out 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.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 >	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.MaxHeap< T >	This is a max-heap, i.e. a priority queue that always knows the smallest item and can remove it in O(log Count) time, or add a new item in O(log Count) time. The ToMaxHeap extension method returns this type
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.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 >	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.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.Utilities.Co< T >	A structure that helps you to write coroutines, or to avoid the performance penalty of nested iterators
►CIEnumerator
CLoyc.Collections.CPStringTrie< TValue >.KeyEnumerator	Enumerates keys of a CPStringTrie
CLoyc.Collections.EmptyEnumerator< T >	Helper class: an empty enumerator
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.FVList< T >.Enumerator	Enumerator for FVList; also used by FWList
►CLoyc.Collections.IBinumerator< T >	Extends the "enumerator" concept to allow backward enumeration
CLoyc.Collections.AListBase< K, T >.Enumerator
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.Impl.InternalDList< T >.Enumerator
CLoyc.Collections.Impl.InternalList< T >.Enumerator< T >
CLoyc.Collections.Impl.InternalSet< T >.Enumerator
CLoyc.Collections.KeyCollection< TKey, TValue >.Enumerator
CLoyc.Collections.KeyCollection< TKey, TValue >.Enumerator
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.NumRange< Num, Math >.Enumerator
CLoyc.Collections.RangeEnumerator< T >	Helper struct: enumerates through a forward range (IFRange<T>)
CLoyc.Collections.RangeEnumerator< T >	Helper struct: enumerates through a forward range (IFRange<T>)
CLoyc.Collections.Set< T >.Enumerator	Enumerator for MSet<T>
CLoyc.Collections.ValueCollection< TKey, TValue >.Enumerator	Return type of GetEnumerator()
CLoyc.Collections.ValueCollection< TKey, TValue >.Enumerator	Return type of GetEnumerator()
CLoyc.Collections.VList< T >.Enumerator	Enumerates through a VList from index 0 up to index Count-1
►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.Les2Lexer	Lexer for EC# source code
CLoyc.Syntax.Les.Les3Lexer
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. It can also be used with the EnumerableExt.Buffered extension method to help feed data to your parser
►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.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.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.TriviaSaver	A lexer wrapper that saves whitespace tokens into a list (TriviaList)
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
►CIEnumerator< KeyValuePair< byte[], TValue >>
CLoyc.Collections.Impl.CPByteTrie< TValue >.Enumerator
►CIEnumerator< KeyValuePair< int, TValue >>
CLoyc.Collections.Impl.CPIntTrie< TValue >.IntEnumerator
►CIEnumerator< KeyValuePair< long, TValue >>
CLoyc.Collections.Impl.CPIntTrie< TValue >.LongEnumerator
►CIEnumerator< KeyValuePair< string, TValue >>
CLoyc.Collections.CPStringTrie< TValue >.Enumerator	Enumerates key-value pairs in a CPStringTrie
CLoyc.Collections.Impl.IEnumeratorFrame< Frame, T >	Helper interface for NestedEnumerator<Frame, T>
►CLoyc.Collections.Impl.IEnumeratorFrame< DescendantsFrame, LNode >
CLoyc.Syntax.DescendantsFrame	Helper class used to enumerate LNode.Descendants()
►CLoyc.Collections.Impl.IEnumeratorFrame< EnumeratorFrame< T >, T >
CLoyc.Collections.Impl.EnumeratorFrame< T >	A standard base class for enumerator frames used by NestedEnumerator{EnumeratorFrame{T},T}
►CIEqualityComparer
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
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)
►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>>
►CIEquatable
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.IntRange	Represents a range of single characters (e.g. 'A'..'Z')
►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
►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
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
CLoyc.Symbol	Represents a symbol, which is a singleton string that supports fast comparisons and extensible enums
►CLoyc.Syntax.ILNode	A read-only interface for objects that act as Loyc trees
CLoyc.Syntax.LNode	All nodes in a Loyc syntax tree share this base class
CLoyc.Syntax.Les.CustomLiteral	A custom literal is a normal number or string paired with a (typically unrecognized) type prefix or suffix
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.LNodeList	A list of non-null references to LNode
CLoyc.Syntax.Precedence	A four-byte tuple that represents the precedence and miscibility of an operator
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.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
►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< 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.AsNegList<T>(IListSource<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.AsNegList<T>(IListSource<T>,int)
►CIEquatable< Pair< T1, T2 >>
CLoyc.Pair< T1, T2 >	A tuple of two values, A and B, in a struct
►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
►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
CLoyc.Collections.IFRange< char >
►CLoyc.Collections.IFRange< T >
CLoyc.Collections.IBRange< out 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.Utilities.IGoInterfaceWrapper	All GoInterface wrappers implement this interface
►CLoyc.Syntax.IHasFileName
►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.Ecs.Parser.EcsLexer	Lexer for EC# source code (see ILexer<Token>)
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. It can also be used with the EnumerableExt.Buffered extension method to help feed data to your parser
►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.Syntax.ILineColumnFile
►CLoyc.Syntax.SourcePos	Please use the new name of this class: LineColumnFile. Holds a filename (FileName), a line number (Line) and a position in the line (Column), representing a position in a source code file
►CLoyc.Syntax.LineColumnFile	This is the new (and recommended) name for SourcePos. It's named after what it contains: a line number, column number and file name. Numbering starts at one for both Line and Column
►CLoyc.Syntax.SourcePosAndIndex	Please use the new name of this class, LineColumnFile. This is a LineColumnFile that also includes the original index from which the Line and PosInLine were derived
CLoyc.Syntax.LineColumnFileAndIndex	This is a tuple of a FileName, Line, Column, and OriginalIndex
CLoyc.Syntax.Lexing.BaseLexer< CharSrc >	The recommended base class for lexers generated by LLLPG, when not using the inputSource option
►CLoyc.IHasLocation	This interface allows an object to declare its "location"
CLoyc.LLParserGenerator.Pred	Represents part of a grammar for the LLParserGenerator
CLoyc.LogMessage	Holds an argument list compatible with IMessageSink<TContext>.Write(Severity,TContext,string). Typically used with MessageHolder
CLoyc.Syntax.ILNode	A read-only interface for objects that act as Loyc trees
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 out T >	Interface for things that have a Value property
►CLoyc.IHasValue< object >
CLoyc.Either< L, R >	Holds a single value of one of two types (L or R)
►CLoyc.Syntax.ILiteralValue	Bundles the optional original text of a value with an optional in-memory form of it
CLoyc.Syntax.ILNode	A read-only interface for objects that act as Loyc trees
CLoyc.Syntax.LiteralValue	Bundles the optional original text of a value with an optional in-memory form of it; see remarks at ILiteralValue. This struct can also be turned into an LNode by calling LNode.Literal<LiteralValue>(SourceRange, LiteralValue, NodeStyle)
CLoyc.Syntax.LNode	All nodes in a Loyc syntax tree share this base class
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.LNode	All nodes in a Loyc syntax tree share this base class
►CLoyc.IHasValue< T >
►CLoyc.IHasMutableValue< T >	Interface for things that have a mutable Value property
CLoyc.Holder< T >	A trivial class that holds a single value of type T in the Value property
CLoyc.Threading.ThreadLocalVariable< T >	Provides access to a thread-local variable through a dictionary that maps thread IDs to values
CLoyc.IMaybe< out out T >
CLoyc.Threading.ScratchBuffer< T >	Holds a single Value that is associated with the thread that assigned it
►CLoyc.IHasValue< T2 >
CLoyc.Pair< T1, T2 >	A tuple of two values, A and B, in a struct
►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.Collections.IIndexed< in in K, out out V >	Represents the essence of a dictionary, which returns a value given a key
►CLoyc.Collections.IIndexed< byte[], TValue >
CLoyc.Collections.Impl.CPByteTrie< TValue >	A compact patricia trie that uses byte arrays as keys
►CLoyc.Collections.IIndexed< int, T >
CLoyc.Collections.AListBase< K, T >	Manages a collection of IAListTreeObserver<K, T>
CLoyc.Collections.IListSource< out out T >	A read-only list indexed by an integer
CLoyc.Collections.INegListSource< out out T >	This interface is the counterpart to IListSource<T> for lists whose minimum index is not (necessarily) zero
►CLoyc.Collections.IIndexed< 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
►CLoyc.Collections.IIndexed< K, BMultiMap< K, V >.ValueList >
CLoyc.Collections.BMultiMap< K, V >	An sorted dictionary that allows multiple values to be associated with a single key
►CLoyc.Collections.IIndexed< 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.IDictionaryAndReadOnly< K, V >	This interface is meant to be implemented by read-only dictionary classes that originally implemented IDictionary<K, V> and now want to add its read-only version, IReadOnlyDictionary<K, V>
CLoyc.Collections.MapOrMMap< K, V >	Common base class that contains code shared between Map<K,V> and MMap<K,V>
►CLoyc.Collections.IIndexed< 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
►CLoyc.Collections.IIndexed< string, TValue >
CLoyc.Collections.CPStringTrie< TValue >	A compact patricia trie that uses strings as keys
►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.ICollectionEx< T >	This interface is intended to be implemented by editable collection classes that are not indexable lists nor dictionaries
►CLoyc.Collections.ICount	Holds the Count property found in nearly all collection interfaces
CLoyc.Collections.IAddRange< in in T >	An interface for the AddRange method, part of IListEx<T> and ICollectionEx<T>, for collection types that can add multiple items in one method call
►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< K, T >	Manages a collection of IAListTreeObserver<K, T>
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 (or a priority queue if IPriorityQueue<ThisAssembly> is also implemented)
►CLoyc.Collections.IPriorityQueue< T >	Represents a priority queue, in which Pop() always returns the largest or smallest item
CLoyc.Collections.MaxHeap< T >	This is a max-heap, i.e. a priority queue that always knows the smallest item and can remove it in O(log Count) time, or add a new item in O(log Count) time. The ToMaxHeap extension method returns this type
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, as well as an ErrorCount
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 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 ListExt.Repeat<T>(T, int)
CLoyc.Collections.Slice_< T >	Adapter: a random-access range for a slice of an IListSource<T>
►CLoyc.Syntax.ILineAndColumn	A line/column pair representing a location in a text file. Numbering starts at one for both Line and Column
CLoyc.Syntax.ILineColumnFile
►CLoyc.Syntax.LineAndCol	Please use the new name of this class: LineAndColumn. Holds a line number (Line) and a position in the line (Column). This class isn't really needed in Loyc but is separated from SourcePos in case anyone might want position without a filename
►CLoyc.Syntax.LineAndColumn	This is the new (and recommended) name for LineAndCol. It holds a line number (Line) and a position in the line (Column). Numbering starts at one for both Line and Column
CLoyc.Syntax.SourcePos	Please use the new name of this class: LineColumnFile. Holds a filename (FileName), a line number (Line) and a position in the line (Column), representing a position in a source code file
►CIList
CLoyc.Collections.DList< LNode >
CLoyc.Collections.DList< Loyc.Syntax.Lexing.Token >
CLoyc.Collections.DList< Pair< LNode, int > >
CLoyc.Collections.DList< Prematched >
►CLoyc.Collections.DList< 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.Collections.DList< T >	A compact auto-enlarging list that efficiently supports supports insertions at the beginning or end of the list
CLoyc.Collections.IListAndListSource< T >	This interface is to be used by read-only sequences that nevertheless wish to be compatible with APIs that accept IList<T>. (writable collections should implement IListImpl<T> instead.)
CLoyc.Collections.IListAndReadOnly< T >	This interface is meant to be implemented by read-only sequence classes that originally implemented IList<T> and want to now implement IReadOnlyList<T> and IReadOnlyCollection<T>. It is recommended to implement IListAndListSource<T> instead, but the latter requires you to implement more methods
CLoyc.Collections.IListImpl< T >	This interface is intended to be implemented by all Loyc collections that implement IList<T>. It combines the original IList<T> interface with its component interfaces IReadOnlyList<T> and IListSink<T>, plus a little bit of additional functionality in IListSource<T>
►CLoyc.Collections.IListAndListSource< LNode >
CLoyc.Syntax.LNodeList	A list of non-null references to LNode
CLoyc.Collections.MutableListExtensionMethods.IListExt	Extension methods and helper methods for IList<T>
►CLoyc.Collections.IListRangeMethods< T >
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 others - IListSource(T), ISinkList(T), IArray(T) - and some 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.IListSink< T >
CLoyc.Collections.IListImpl< T >	This interface is intended to be implemented by all Loyc collections that implement IList<T>. It combines the original IList<T> interface with its component interfaces IReadOnlyList<T> and IListSink<T>, plus a little bit of additional functionality in IListSource<T>
►CLoyc.Collections.IListSource< char >
►CLoyc.Collections.ICharSource	A read-only list of characters plus a Slice(int,int) method
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.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.IListSource< 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
CLoyc.Collections.IListSource< LNode >
►CLoyc.Collections.IListSource< T >
CLoyc.Collections.AListBase< K, T >	Manages a collection of IAListTreeObserver<K, 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.IListAndListSource< T >	This interface is to be used by read-only sequences that nevertheless wish to be compatible with APIs that accept IList<T>. (writable collections should implement IListImpl<T> instead.)
CLoyc.Collections.IListImpl< T >	This interface is intended to be implemented by all Loyc collections that implement IList<T>. It combines the original IList<T> interface with its component interfaces IReadOnlyList<T> and IListSink<T>, plus a little bit of additional functionality in 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 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.Collections.ReadOnlyListAsListSource< T >	Helper type returned from LCExt.AsListSource<T>(IReadOnlyList<T>)
CLoyc.Collections.ROLSlice< TList, T >	Adapter: a random-access range for a slice of an IReadOnlyList<T>
►CLoyc.Collections.IListSource< 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.ILiteralParser	This interface for parsing text into objects is implemented by LiteralHandlerTable
►CLoyc.Syntax.LiteralHandlerTable	A central class for keeping track of literal parsers and literal printers
CLoyc.Syntax.StandardLiteralHandlers	A LiteralHandlerTable that is preinitialized with all standard literal parsers and printers
►CLoyc.Syntax.ILiteralPrinter	This interface for converting literals to text is implemented by LiteralHandlerTable
CLoyc.Syntax.LiteralHandlerTable	A central class for keeping track of literal parsers and literal printers
►CLoyc.Syntax.ILiteralValueProvider	The intention of this interface is that a struct implementing it can be embedded inside a LiteralNode in order to lazily obtain the text of a literal, or even parse it lazily
CLoyc.Syntax.LiteralValue	Bundles the optional original text of a value with an optional in-memory form of it; see remarks at ILiteralValue. This struct can also be turned into an LNode by calling LNode.Literal<LiteralValue>(SourceRange, LiteralValue, NodeStyle)
CLoyc.Syntax.UninterpretedLiteral	A simple implementation of IUninterpretedLiteral which can also be turned into an LNode by calling LNode.Literal<UninterpretedLiteral>(SourceRange, UninterpretedLiteral, NodeStyle)
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.ILllpgApi< Token, int, int >
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.ILllpgApi< Token, MatchType, MatchType >
CLoyc.Syntax.ParserSource< Token >	Alias for ParserSource{Token, int, IList{Token}}
►CLoyc.Syntax.Lexing.ILllpgLexerApi< int >
CLoyc.Syntax.Lexing.LexerSource< CharSrc >	An implementation of the LLLPG Lexer API, used with the LLLPG options inputSource and inputClass
►CLoyc.Syntax.ILNodePrinter	This interface allows serializing LNode objects into the syntax of a particular programming language
CLoyc.Ecs.EcsLanguageService	The Value property provides easy access to the lexer, parser and printer for Enhanced C#
►CLoyc.Syntax.Les.Les2LanguageService	The Value property provides easy access to the lexer, parser and printer for Loyc Expression Syntax (LES)
CLoyc.Syntax.Les.LesLanguageService	Alternate name for Les2LanguageService (will change to Les3LanguageService in the future)
CLoyc.Syntax.Les.Les3LanguageService
►CLoyc.Syntax.ILNodePrinterOptions	A set of relatively universal printing options that LNodePrinters should understand
►CLoyc.Syntax.LNodePrinterOptions	A concrete class that users can pass to an LNodePrinter
CLoyc.Ecs.EcsPrinterOptions	Options to control the way EcsNodePrinter's output is formatted
CLoyc.Syntax.Les.Les2PrinterOptions	Options to control the way Loyc trees are printed by Les2Printer
CLoyc.Syntax.Les.Les3PrinterOptions	A set of extended options supported when printing in LES3
►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.ILogMessage	A formatted message with an associated Context
CLoyc.LogMessage	Holds an argument list compatible with IMessageSink<TContext>.Write(Severity,TContext,string). Typically used with MessageHolder
CLoyc.IMaybe< L >
CLoyc.IMaybe< R >
►CLoyc.IMaybe< T >
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.IMessageSink< in in TContext >	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.MessageMulticaster< TContext >	A message sink that sends its messages to a list of other sinks
CLoyc.MessageSinkFromDelegate	This helper class lets you implement IMessageSink with one or two delegates (a writer method, and an optional severity filter)
CLoyc.MessageSinkWithContext< TContext >	A message sink wrapper that has a default value for the context parameter, which is used when the context provided is null, and an optional message prefix which is inserted at the beginning of the format string
CLoyc.NullMessageSink	Discards all messages. However, there is a Count property that increases by one with each message received, as well as an ErrorCount
CLoyc.SeverityMessageFilter< TContext >	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.IMessageSink< Loyc.Syntax.LNode >
►CLoyc.IMessageSink< TContext >
CLoyc.MessageMulticaster< TContext >	A message sink that sends its messages to a list of other sinks
CLoyc.MessageSinkWithContext< TContext >	A message sink wrapper that has a default value for the context parameter, which is used when the context provided is null, and an optional message prefix which is inserted at the beginning of the format string
CLoyc.SeverityMessageFilter< TContext >	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.Collections.INegListSource< ILNode >
CLoyc.Syntax.ILNode	A read-only interface for objects that act as Loyc trees
►CLoyc.Collections.INegListSource< LNode >
CLoyc.Syntax.LNode	All nodes in a Loyc syntax tree share this base class
►CLoyc.Collections.INegListSource< T >
►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.AsNegList<T>(IListSource<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.AsNegList<T>(IListSource<T>,int)
CLoyc.Geometry.INewPoint< Point, T >	This interface exists to work around a limitation of C#; see IPoint<T>
CLoyc.Geometry.INewPoint3< Point, T >	This interface exists to work around a limitation of C#; see IPoint<T> and IPoint3<T>
►CLoyc.Geometry.INewPoint3< IPoint3< T >, T >
CLoyc.Geometry.IPoint3< T >	A mutable 3D point with X, Y, and Z coordinates
►CLoyc.Geometry.INewPoint< IPoint< T >, T >
CLoyc.Geometry.IPoint< T >	A mutable 2D point with X and Y coordinates
CLoyc.Geometry.INewRectangle< Rect, T >	This interface exists to work around a limitation of C#; see IRectangle<T>
CLoyc.Geometry.INewRectangle3< Rect, T >	This interface exists to work around a limitation of C#; see IRectangle3<T>
►CLoyc.Geometry.INewRectangle3< IRectangle< T >, T >
CLoyc.Geometry.IRectangle3< T >	Represents a mutable 3D rectangle
►CLoyc.Geometry.INewRectangle< IRectangle< T >, T >
CLoyc.Geometry.IRectangle< T >	Represents a mutable 2D 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 Les2Printer
►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 token-printing helper classes. See INodePrinterWriter
CLoyc.Collections.INotifyListChanged< T, TCollection >	Encapsulates a ListChanged event that notifies listeners that a list has changed, such as when items are added or removed or the whole list is refreshed
►CINotifyListChanged< KeyValuePair< K, V >, IDictionary< K, V >>
CLoyc.Collections.IDictionaryWithChangeEvents< K, V >
►CLoyc.Collections.INotifyListChanged< T >
CLoyc.Collections.IListWithChangeEvents< T >
►CINotifyListChanged< T, ICollection< T >>
CLoyc.Collections.ICollectionExWithChangeEvents< T >	Combines ICollectionEx<T> with INotifyListChanging<T, ICollection<T>> and INotifyListChanged<T, ICollection<T>>. This exists for completeness; as of 2020/12 there are no implementations
CLoyc.Collections.ICollectionWithChangeEvents< T >	Combines ICollection<T> with INotifyListChanging<T, ICollection<T>> and INotifyListChanged<T, ICollection<T>>
►CINotifyListChanged< T, IListSource< T >>
CLoyc.Collections.INotifyListChanged< T >	A version of INotifyListChanging<T, TCollection> in which TCollection is fixed at IListSource<T>
CLoyc.Collections.INotifyListChanging< T, TCollection >	Encapsulates the ListChanging event that notifies listeners of dynamic changes to a collection, such as when items are about to be added and removed or the whole list is about to be refreshed
►CINotifyListChanging< KeyValuePair< K, V >, IDictionary< K, V >>
CLoyc.Collections.IDictionaryWithChangeEvents< K, V >
►CLoyc.Collections.INotifyListChanging< T >
CLoyc.Collections.AListBase< K, T >	Manages a collection of IAListTreeObserver<K, T>
CLoyc.Collections.IListWithChangeEvents< T >
►CINotifyListChanging< T, ICollection< T >>
CLoyc.Collections.ICollectionExWithChangeEvents< T >	Combines ICollectionEx<T> with INotifyListChanging<T, ICollection<T>> and INotifyListChanged<T, ICollection<T>>. This exists for completeness; as of 2020/12 there are no implementations
CLoyc.Collections.ICollectionWithChangeEvents< T >	Combines ICollection<T> with INotifyListChanging<T, ICollection<T>> and INotifyListChanged<T, ICollection<T>>
►CINotifyListChanging< T, IListSource< T >>
CLoyc.Collections.INotifyListChanging< T >	A version of INotifyListChanging<T, TCollection> in which TCollection is fixed at IListSource<T>
CLeMP.InputOutput	For LeMP: an input file plus per-file options (input and output language) and output code
CLoyc.Collections.Impl.InternalDList< Loyc.Syntax.Lexing.Token >
CLoyc.Collections.Impl.InternalDList< Token >
CLoyc.Collections.Impl.InternalList< Division >
CLoyc.Collections.Impl.InternalList< Entry >
CLoyc.Collections.Impl.InternalList< Frame >
CLoyc.Collections.Impl.InternalList< int >
CLoyc.Collections.Impl.InternalList< Loyc.Collections.Impl.IAListTreeObserver< K, T > >
CLoyc.Collections.Impl.InternalList< Loyc.LLParserGenerator.IntRange >
CLoyc.Collections.Impl.InternalList< Loyc.Symbol >
CLoyc.Collections.Impl.InternalList< MacroResult >
CLoyc.Collections.Impl.InternalList< Node >
CLoyc.Collections.Impl.InternalList< PredictionBranch >
CLoyc.Collections.Impl.InternalList< Revokable >
CLoyc.Collections.Impl.InternalList< Scope >
CLoyc.Collections.Impl.InternalList< Symbol >
CLoyc.Collections.Impl.InternalList< TokenType >
CLoyc.Collections.Impl.InternalSet< KeyValuePair< K, V > >
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
►CLoyc.Collections.InvertibleSet< LNode >
CLoyc.LLParserGenerator.PGNodeSet	An immutable set that implements IPGTerminalSet so that it can be used by LLParserGenerator
CLoyc.Collections.InvertibleSet< string >
►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.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.Collections.IOptimize	Interface for an Optimize() method
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.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.Math.IOrderedExt	Extension methods for IOrdered<T>
►CLoyc.Syntax.IParsingOptions	A set of relatively universal parsing options that IParsingServices should understand
CLoyc.Syntax.ParsingOptions	A simple implementation of IParsingOptions
►CLoyc.Syntax.IParsingService	An interface that encapsulates the lexer and parser 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.Les2LanguageService	The Value property provides easy access to the lexer, parser and printer for Loyc Expression Syntax (LES)
CLoyc.Syntax.Les.Les3LanguageService
►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.IPoint< T >	A mutable 2D point with X and Y coordinates
CLoyc.Geometry.IPoint3Base< T >	This interface exists to work around a limitation of C#; use IPoint<T> instead
CLoyc.Collections.IPop< out out T >	Represents a collection that produces a sequence of items, and can return the next item without popping it (the Peek operation)
►CLoyc.Collections.IPop< T >
CLoyc.Collections.IQueue< T >	Represents a FIFO (first-in-first-out) queue (or a priority queue if IPriorityQueue<ThisAssembly> is also implemented)
CLoyc.Collections.IStack< T >	Represents a LIFO (last-in-first-out) stack
CLoyc.Collections.VList< T >	VList represents a reference to a reverse-order FVList
CLoyc.Collections.IPopExt
CLoyc.Collections.IPush< in in T >	Represents a collection that accepts a sequence of items
►CLoyc.Collections.IPush< T >
CLoyc.Collections.IQueue< T >	Represents a FIFO (first-in-first-out) queue (or a priority queue if IPriorityQueue<ThisAssembly> is also implemented)
CLoyc.Collections.IStack< T >	Represents a LIFO (last-in-first-out) stack
►CLoyc.Collections.IRange< 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
►CLoyc.Collections.IRange< T >
CLoyc.Collections.IMRange< T >	A mutable random-access range
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.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 ListExt.Repeat<T>(T, int)
CLoyc.Collections.ROLSlice< TList, T >	Adapter: a random-access range for a slice of an IReadOnlyList<T>
CLoyc.Collections.Slice_< T >	Adapter: a random-access range for a slice of an IListSource<T>
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< IRangeEx< T >, T >
CLoyc.Collections.IRangeEx< T >	A random-access range that can perform operations such as intersection and overlap tests on pairs of ranges
►CIReadOnlyCollection
CLoyc.Collections.BMultiMap< K, V >.ValueList	Represents the set of values associated with a particular key in a BMultiMap<K,V> collection
CLoyc.Collections.IAutoCreatePool< in in TKey, out out TValue >	Represents a pool of objects in which an object is automatically created when requested by its key
CLoyc.Collections.ICollectionAndReadOnly< T >	This interface is meant to be implemented by read-only sequence types that originally implemented ICollection<T> and want to now implement IReadOnlyCollection<T>. It is recommended to implement ICollectionAndSource<T> instead, but the latter requires you to implement a couple of additional methods
CLoyc.Collections.ICollectionSource< T >	A variation of IReadOnlyCollection that provides the Contains() and CopyTo() methods from ICollection
CLoyc.Collections.Impl.KeylessHashtable< T, Int, Math >	The concrete implementation of KeylessHashtable<T>. Do not use directly; instead, call KeylessHashtable<T>.New(int)
CLoyc.Collections.INegListSource< out out T >	This interface is the counterpart to IListSource<T> for lists whose minimum index is not (necessarily) zero
CLoyc.Collections.ISetImm< T >	An immutable set that supports numerous set operations
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
►CIReadOnlyCollection< KeyValuePair< K, V >>
CLoyc.Collections.MapOrMMap< K, V >	Common base class that contains code shared between Map<K,V> and MMap<K,V>
►CIReadOnlyDictionary
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.BMultiMap< K, V >	An sorted dictionary that allows multiple values to be associated with a single key
CLoyc.Collections.IDictionaryAndReadOnly< K, V >	This interface is meant to be implemented by read-only dictionary classes that originally implemented IDictionary<K, V> and now want to add its read-only version, IReadOnlyDictionary<K, V>
CLoyc.Collections.Impl.CPByteTrie< TValue >	A compact patricia trie that uses byte arrays as keys
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 >	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.MapOrMMap< K, V >	Common base class that contains code shared between Map<K,V> and MMap<K,V>
CLoyc.Collections.SelectDictionaryFromKeys< K, V >	An adapter that converts a collection of keys to an IReadOnlyDictionary. Used by EnumerableExt.AsReadOnlyDictionarybased on a function that can obtain a value for a given key
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
►CIReadOnlyList
CLoyc.Collections.IListAndReadOnly< T >	This interface is meant to be implemented by read-only sequence classes that originally implemented IList<T> and want to now implement IReadOnlyList<T> and IReadOnlyCollection<T>. It is recommended to implement IListAndListSource<T> instead, but the latter requires you to implement more methods
CLoyc.Collections.IListSource< out out T >	A read-only list indexed by an integer
CLoyc.Collections.Impl.AListLeafBase< K, T >
CLoyc.Collections.NumRange< Num, Math >	Represents a range of integers of a specified data type
►CLoyc.IReferenceEquatable	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
CLoyc.Collections.Impl.SetWrapper< T, TSet >	A simple base class that helps you use the decorator pattern on a set. By default, all it does is forward every method to the underlying collection (including GetHashCode, Equals and ToString). You can change its behavior by overriding methods
CLoyc.Collections.MSet< T >	A mutable set
CLoyc.Collections.ISetImm< T, SetT >	An immutable set of type SetT with elements of type T
►CLoyc.Collections.ISetImm< T >
CLoyc.Collections.MSet< T >	A mutable set
CLoyc.Collections.Set< T >	An immutable set
►CISetImm< T, 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"
►CISetImm< T, MSet< T >>
CLoyc.Collections.MSet< T >	A mutable set
►CISetImm< T, Set< T >>
CLoyc.Collections.Set< T >	An immutable set
CLoyc.Collections.ISetOperations< in in T, SetT >	Set-combining operations: With, Without, Union, Intersect, Except, Xor
►CISetOperations< KeyValuePair< K, V >, MapOrMMap< K, V >, Map< K, V >>
CLoyc.Collections.Map< K, V >	An immutable dictionary
►CISetOperations< KeyValuePair< K, V >, MapOrMMap< K, V >, MMap< K, V >>
CLoyc.Collections.MMap< K, V >	A dictionary class built on top of InternalSet<KeyValuePair<K,V>>
►CISetOperations< T, IEnumerable< T >, ISetImm< T >>
CLoyc.Collections.ISetImm< T >	An immutable set that supports numerous set operations
►CLoyc.Collections.ISetOperations< T, SetT >
CLoyc.Collections.ISetImm< T >	An immutable set that supports numerous set operations
►CLoyc.Collections.ISetOperations< T, SetT, SetT >
CLoyc.Collections.ISetOperations< in in T, in in InSetT, out out OutSetT >	Set-combining operations: With, Without, Union, Intersect, Except, Xor
►CLoyc.Collections.ISetTests< SetT >	Set testing operations
CLoyc.Collections.ISetImm< T >	An immutable set that supports numerous set operations
►CISetTests< IEnumerable< T >>
CLoyc.Collections.ISetImm< T >	An immutable set that supports numerous set operations
CLoyc.Syntax.Lexing.ISimpleToken< int >
►CLoyc.Syntax.Lexing.ISimpleToken< TT >
CLoyc.Syntax.Lexing.IToken< TT >	The methods of Token in the form of an interface
►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.IRectangle< T >	Represents a mutable 2D rectangle
CLoyc.Geometry.IRectangle3Base< T >	Represents a mutable 3D rectangular prism
►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.Syntax.ISourceRange	Represents a (contiguous) region of text in a source file
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.ITags< T >	Interface for an object that can have "tags" attached, which are arbitrary objects reached through a key Symbol
►CLoyc.ITags< 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
►CLoyc.Syntax.Lexing.IToken< int >
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.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.Collections.ITryGet< in in K, out out V >	Enables access to TryGet extension methods for retrieving items from a collection without risk of exceptions
►CLoyc.Collections.ITryGet< int, T >
CLoyc.Collections.AListBase< K, T >	Manages a collection of IAListTreeObserver<K, T>
CLoyc.Collections.IListSource< out out T >	A read-only list indexed by an integer
CLoyc.Collections.INegListSource< out out T >	This interface is the counterpart to IListSource<T> for lists whose minimum index is not (necessarily) zero
►CLoyc.Collections.ITryGet< K, V >
CLoyc.Collections.IDictionaryEx< K, V >	Combines IDictionary, IReadOnlyDictionary, and IDictonarySink with a few additional methods
CLoyc.Collections.MapOrMMap< K, V >	Common base class that contains code shared between Map<K,V> and MMap<K,V>
►CLoyc.Syntax.IUninterpretedLiteral	Represents the text form of a literal value, without its parsed value
CLoyc.Syntax.ILiteralValue	Bundles the optional original text of a value with an optional in-memory form of it
CLoyc.Syntax.ISerializedLiteral
CLoyc.Syntax.UninterpretedLiteral	A simple implementation of IUninterpretedLiteral which can also be turned into an LNode by calling LNode.Literal<UninterpretedLiteral>(SourceRange, UninterpretedLiteral, NodeStyle)
►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.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(int)
CLoyc.Collections.Impl.KeyWalker	Internal implementation class. Represents a pointer to a location within a byte array
CLoyc.LLParserGenerator.LLParserGenerator.KthSet	Holds information about the first set or kth set of a single arm of an Alts
CLoyc.Collections.MutableListExtensionMethods.LCExt
CLoyc.Collections.LCExt	Extension methods for Loyc Collection interfaces (such as IListSource<T>)
CLoyc.Collections.LCInterfaces	Extension methods for Loyc collection interfaces
►CLoyc.Syntax.Les.Les2PrecedenceMap	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 chosen by this class and cached for future reference
CLoyc.Syntax.Les.Les3PrecedenceMap
CLoyc.Syntax.Les.Les2Printer	Prints a Loyc tree in LES (Loyc Expression Syntax) format
►CLoyc.Syntax.Les.Les3Printer
CLoyc.Syntax.Les.Les3PrettyPrinter	A variant of Les3Printer that adds syntax highlighting in one of three ways: as console output, as HTML output, or as LesColorCode control codes
CLoyc.Syntax.Les.LesPrecedence	Contains Precedence objects that represent the precedence levels of LES
CLoyc.Syntax.Lexing.LexerSource< Loyc.UString >
CLoyc.Syntax.Lexing.LexerSourceFile< CharSrc >
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.Collections.MutableListExtensionMethods.LinqToLists
CLoyc.Collections.LinqToLists	This class enhances LINQ-to-Objects with extension methods that preserve the interface (e.g. Take(IList<int>) returns a struct that implements IList<int>) or have higher performance than the ones in System.Linq.Enumerable
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>
CLoyc.Collections.ListSlice< LogMessage >
►CLoyc.Collections.Impl.ListSourceBase< 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
►CLoyc.Collections.Impl.ListSourceBase< 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
►CLoyc.Collections.Impl.ListSourceBase< TResult >
CLoyc.Collections.SelectList< ListT, T, TResult >	Helper class: provides a modified view of an IList by transforming each element on-demand. Objects of this type are returned from MutableListExtensionMethods.LinqToLists.Select<T,TResult>(IList<T>,Func<T,TResult>)
►CLoyc.Collections.SelectReadOnlyList< ListT, T, TResult >	Helper class: provides a modified view of an IListSource by transforming each element on-demand. Objects of this type are returned from LinqToLists.Select<T,TResult>(IListSource<T>,Func<T,TResult>)
CLoyc.Collections.SelectListSource< ListT, T, TResult >	Helper class: provides a modified view of an IListSource by transforming each element on-demand. Objects of this type are returned from LinqToLists.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
►CListWithChangeEvents< T, IList< T >>
CLoyc.Collections.ListWithChangeEvents< T >	A list wrapper that provides ListChanging and ListChanged events. Shorthand for Loyc.Collections.Impl.ListWithChangeEvents<T,IList<T>>
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.Syntax.LNodePrinter	Standard extension methods for ILNodePrinter
CLoyc.Localize	Localize is a global hook into which a string-mapping localizer can be installed. It makes your program localization-ready with no effort. See article: http://core.loyc.net/essentials/localize.html
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
►CLeMP.Tests.MacroTesterBase
CLeMP.Tests.TestAlgebraicDataTypes
CLeMP.Tests.TestCodeContractMacros
CLeMP.Tests.TestCodeQuoteMacro
CLeMP.Tests.TestCompileTimeMacros
CLeMP.Tests.TestMacroCombinations
CLeMP.Tests.TestMatchCodeMacro
CLeMP.Tests.TestMatchMacro
CLeMP.Tests.TestOnFinallyReturnThrowMacros
CLeMP.Tests.TestReplaceAndDefineMacros
CLeMP.Tests.TestSetOrCreateMemberMacro
CLeMP.Tests.TestStaticDeconstructMacro
CLeMP.Tests.TestStaticMatchCodeMacro
CLeMP.Tests.TestUnrollMacro
CLeMP.Tests.TestUserDefinedMacroMacro
CLeMP.Tests.TestUseSequenceExpressionsMacro
CLeMP.Tests.TestUseSymbolsMacro
CLoyc.Collections.Map< object, Loyc.Syntax.Precedence >
CLoyc.Collections.Map< string, Loyc.Syntax.IParsingService >
CLoyc.Collections.MaxHeap< T, TList, TComparer >	Encapsulates algorithms for a max-heap, i.e. a priority queue that always knows the largest item and can remove it in O(log Count) time, or add a new item in O(log Count) time
►CMaxHeap< T, IList< T >, IComparer< T >>
CLoyc.Collections.MaxHeapInList< T >	This priority queue wrapper type is returned from the AsMaxHeap() extension method
►CMaxHeap< T, InternalList< T >, IComparer< T >>
CLoyc.Collections.MaxHeap< T >	This is a max-heap, i.e. a priority queue that always knows the smallest item and can remove it in O(log Count) time, or add a new item in O(log Count) time. The ToMaxHeap extension method returns this type
►CMaxHeap< T, TList, ReverseComparer< T, TComparer >>
CLoyc.Collections.MinHeap< T >	This is a min-heap, i.e. a priority queue that always knows the smallest item and can remove it in O(log Count) time, or add a new item in O(log Count) time. The ToMinHeap extension method returns this type
CLoyc.Maybe
CLoyc.Maybe< L >
CLoyc.Maybe< Loyc.Syntax.Lexing.Token >
CLoyc.Maybe< R >
CLoyc.Maybe< Token >
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	Keeps track of the default message sink (Default); contains a series of helper methods; and contains extension methods modeled after log4net: Fatal, Error, Warn, Info, Debug
CLoyc.Collections.MinHeap< T, TList, TComparer >	Encapsulates algorithms for a min-heap, i.e. a priority queue that always knows the smallest item and can remove it in O(log Count) time, or add a new item in O(log Count) time
►CMinHeap< T, IList< T >, IComparer< T >>
CLoyc.Collections.MinHeapInList< T >	This priority queue wrapper type is returned from the AsMinHeap() extension method
►CMinHeap< T, InternalList< T >, IComparer< T >>
CLoyc.Collections.MinHeap< T >	This is a min-heap, i.e. a priority queue that always knows the smallest item and can remove it in O(log Count) time, or add a new item in O(log Count) time. The ToMinHeap extension method returns this type
CLoyc.Collections.MMap< object, object >
CLoyc.Collections.MMap< string, Pair< string, string > >
CLoyc.Collections.MMap< Symbol, InternalList< InternalMacroInfo > >
CLoyc.Collections.MSet< int >
CLoyc.Collections.MSet< Loyc.LLParserGenerator.AndPred >
CLoyc.Collections.MSet< Loyc.LLParserGenerator.Pred >
CLoyc.Collections.MSet< Loyc.Symbol >
CLoyc.Collections.MSet< Symbol >
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.Pair< Loyc.Collections.Impl.AListInnerBase< K, T >, int >
CLoyc.Pair< Loyc.Collections.MMap< object, Loyc.Syntax.Precedence >, Loyc.Syntax.Precedence >
CLoyc.Syntax.ParseHelpers	Static methods that help with common parsing jobs, such as parsing integers, floats, and strings with C escape sequences
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, int >
CLoyc.Syntax.ParserSource< Token >	Alias for ParserSource{Token, int, IList{Token}}
►CParserSource< Token, MatchType, IList< Token >>
CLoyc.Syntax.ParserSource< Token >	Alias for ParserSource{Token, int, IList{Token}}
CLoyc.Syntax.ParsingService	Standard extension methods for IParsingService
CLoyc.LLParserGenerator.PGTerminalSet	Extension methods for IPGTerminalSet
►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
CLeMP.Tests.PreludeMacroTests_Les2
CLeMP.Tests.PreludeMacroTests_Les3
CLoyc.Syntax.Impl.PrinterState	A helper type for printer objects. Its primary purposes are to manage indentation and to "revoke" newlines; it also tracks the current line/column number
CLoyc.Syntax.PrintHelpers	Static methods that help to print literals, such as EscapeCStyle which escapes special characters with backslashes
CLoyc.LLParserGenerator.Program	Entry point of LLLPG.exe, with QuickRun() method to help invoke LLLPG programmatically
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.RangeExt	Extension/helper methods for ranges
►CLoyc.Collections.Impl.ReadOnlyCollectionBase< 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.Collections.Impl.ReadOnlyCollectionBase< TResult >
CLoyc.Collections.SelectCollection< ListT, T, TResult >	Helper class for LinqToLists
CLoyc.Collections.SelectReadOnlyCollection< ListT, T, TResult >	Helper class for LinqToLists
CLoyc.Collections.ReverseComparer< T >	Reverses the order used by an IComparer object
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.Threading.ScratchBuffer< byte[]>
CLoyc.Threading.ScratchBuffer< object[]>
CLoyc.Collections.SelectList< T[], T, TResult >
CLoyc.ServiceProvider	Adds extension methods to modernize .NET's simple built-in service locator
CLoyc.Collections.Set< Loyc.LLParserGenerator.AndPred >
CLoyc.Collections.SimpleCache< T >	A cache designed to save memory by sharing instances of identical strings and other immutable objects
CLoyc.Collections.SimpleCache< object >
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.SourcePosIsObsolete	This just helps end-users to discover the name change SourcePos.PosInLine => ILineAndColumn.Column during upgrades
CLoyc.Syntax.SourceRangeExt	Standard extension methods for ISourceRange
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.StringBuilderExt	Extension methods that add some functionality of string to StringBuilder
CLoyc.StringExt	Extension methods for strings, such as SplitAt, Left, Right, FormatCore and Slice
►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.SymbolPool< Loyc.Syntax.ParsingMode >
CLoyc.Ecs.Parser.EcsParser.TentativeResult
CLoyc.Ecs.Parser.EcsParser.TentativeState
CLeMP.Tests.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.ThreadLocalVariable< Func< Loyc.Syntax.Lexing.Token, Loyc.Collections.ICharSource, string > >
CLoyc.Threading.ThreadLocalVariable< Func< object, string > >
CLoyc.Threading.ThreadLocalVariable< Loyc.IMessageSink >
CLoyc.Threading.ThreadLocalVariable< Loyc.Syntax.ILNodePrinter >
CLoyc.Threading.ThreadLocalVariable< Loyc.Syntax.IParsingService >
CLoyc.Threading.ThreadLocalVariable< StopTestDelegate >
►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.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.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.Triplet< T1, T2, T3 >	A tuple of three values (A, B and C) in a struct
CLoyc.Triplet
CLoyc.Collections.TryGetExt	Standard extension methods for ITryGet<K, V>
CLoyc.TypeExt	Extension methods for Type
CLoyc.Utilities.UG	Contains global functions of Loyc.Utilities that don't belong in any specific class
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.Collections.VList< Loyc.LLParserGenerator.AndPred >
CLoyc.Collections.VList< Loyc.Syntax.LNode >
►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	@void.Value represents the sole value of System.Void (called "void" in C#)
CLoyc.Collections.WeakKeyComparer< TKey >
►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.Collections.WeakValueDictionary< Loyc.UString, Loyc.Symbol >
CLoyc.Syntax.Lexing.WhitespaceTag	WhitespaceTag.Value can be used as the Token.Value of whitespace tokens, to make whitespace easy to filter out
CLoyc.Collections.WList< LNode >
CLoyc.Collections.WList< Loyc.Syntax.LNode >
►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
►CWListProtected< KeyValuePair< Symbol, ValueT >>
CLoyc.Utilities.TagsInWList< ValueT >	An implementation of ITags designed for AstNode
CLoyc.WrapperBase< T >	Abstract class that helps you implement wrappers by automatically forwarding calls to Equals(), GetHashCode() and ToString()
►CWrapperBase< ICollection< T >>
CLoyc.Collections.CollectionAsReadOnly< T >	Adapter: a read-only wrapper that implements ICollection(T) and IReadOnlyCollection(T), returned from EnumerableExt.AsReadOnly<T>
►CWrapperBase< IList< T >>
CLoyc.Collections.ListAsListSource< T >	Helper type returned from LCExt.AsListSource<T>
►CWrapperBase< IListSource< T >>
CLoyc.Collections.ListSourceAsList< T >	Adapter: a read-only wrapper that implements IList(T) and IListSource(T), returned from LCExt.AsList<T>
►CWrapperBase< IReadOnlyCollection< T >>
CLoyc.Collections.ReadOnlyAsCollection< T >	A read-only wrapper that implements ICollection(T) and ISource(T), returned from LCExt.AsCollection<T>
►CWrapperBase< IReadOnlyList< T >>
CLoyc.Collections.ReadOnlyListAsListSource< T >	Helper type returned from LCExt.AsListSource<T>(IReadOnlyList<T>)
►CLoyc.WrapperBase< ISourceFile >
CLoyc.Syntax.SourceFileWithLineRemaps	An wrapper around ISourceFile that applies line remapping information (if the source file uses it)
►CLoyc.WrapperBase< TCollection >
CLoyc.Collections.Impl.CollectionWrapper< T, TCollection >	A simple base class that helps you use the decorator pattern on a collection. By default, all it does is forward every method to the underlying collection (including GetHashCode, Equals and ToString). You can change its behavior by overriding methods
►CLoyc.WrapperBase< TSet >
CLoyc.Collections.Impl.SetWrapper< T, TSet >	A simple base class that helps you use the decorator pattern on a set. By default, all it does is forward every method to the underlying collection (including GetHashCode, Equals and ToString). You can change its behavior by overriding methods