Class List

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

[detail level 12345]

►NLeMP	The lexical macro processor. Main classes: LeMP.Compiler and LeMP.MacroProcessor.
►NPrelude	Defines prelude macros, which are predefined macros that normally do not have to be explicitly imported before use (in LES or EC#).
CBuiltinMacros	Defines noMacro(...) for suppressing macro expansion and import macros your.namespace.name as an alias for #importMacros(your.namespace.name).
►NTests	Contains tests for the LeMP.MacroProcessor and for standard LeMP macros.
►NA
CAliasTest
►NB
CAliasTest
CMacroTesterBase
CPreludeMacroTests_Les2
CPreludeMacroTests_Les3
CTestAlgebraicDataTypes
CTestCodeContractMacros
CTestCodeQuoteMacro
CTestCompileTimeMacros
CTestFilterSyntaxMacros
CTestMacroCombinations
CTestMacros
CTestMapSyntaxMacro
CTestMatchCodeMacro
CTestMatchMacro
CTestOnFinallyReturnThrowMacros
CTestReplaceAndDefineMacros
CTestSetOrCreateMemberMacro
CTestStaticDeconstructMacro
CTestStaticMatchCodeAndSwitchMacro
CTestUnrollMacro
CTestUserDefinedMacroMacro
CTestUseSequenceExpressionsMacro
CTestUseSymbolsMacro
CCompiler	A class that helps you invoke MacroProcessor on on a set of source files, given a set of command-line options.
CContainsMacrosAttribute	Marks a class to be searched for macros.
CIMacroContext	This interface provides services offered by the lexical macro processor (LeMP).
CInputOutput	For LeMP: an input file plus per-file options (input and output language) and output code.
CLexicalMacroAttribute	Marks a method as a LeMP lexical macro.
CMacroContext	Standard extension methods for IMacroContext.
CMacroInfo	Data returned from IMacroContext.AllKnownMacros
CMacroProcessor	Encapsulates the LeMP engine, a simple LISP-style macro processor, suitable for running LLLPG and other lexical macros.
CTestCompiler	A simple version of Compiler that takes a single input and produces a StringBuilder. Pre-opens LeMP.Prelude namespaces.
►NLoyc	Main Loyc namespace. This namespace includes all general-purpose code in the Loyc megaproject. It includes the code of Loyc.Essentials.dll and Loyc.Collections.dll (collections, geometry, MiniTest, MessageSink, etc.), and also the code of Loyc.Syntax.dll.
►NCollections	Contains general-purpose interfaces (Loyc.Collections.IListSource{T}, ranges, etc.), collection implementations (Loyc.Collections.DList{T}, Loyc.Collections.WeakValueDictionary{K,V}, etc.), extension methods (Loyc.Collections.LCExt, Loyc.Collections.EnumerableExt, etc.), helper classes (Loyc.Collections.EmptyList{T}, (Loyc.Collections.Repeated{T}, etc.), and adapter classes (Loyc.Collections.ListSlice{T}, Loyc.Collections.BufferedSequence{T}, etc.).
►NImpl	Contains helper classes and base classes for implementing collections (Loyc.Collections.Impl.InternalList{T}, Loyc.Collections.Impl.ListExBase{T}, Loyc.Collections.Impl.ListSourceBase{T}, etc.) Also contains the AList and CPTrie node classes, which perhaps should not be public...
CAListIndexer< K, T >	Observes changes and builds a table of items in the tree.
CAListInnerBase< 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}.
CAListLeaf< K, T >	Internal implementation class. Shared code of non-sparse AList leaf nodes.
CAListLeafBase< K, T >
CAListNode< 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.
CAListTreeObserverExt	Helper methods for IAListTreeObserver{K,T}.
CBListLeaf< K, T >	Internal implementation class. Leaf node of BList{T} and BDictionary{K,V}.
CCollectionWithChangeEvents< T, TColl >	A collection wrapper that provides ListChanging and ListChanged events. You can also implement custom behavior by overriding its methods.
CCollectionWrapper< 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.
►CCPByteTrie< TValue >	A compact patricia trie that uses byte arrays as keys.
CEnumerator
CCPEnumerator< T >	Traverses a CPTrie{T}. Returned by CPTrie{T}.ValueEnumerator().
►CCPIntTrie< 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.
CIntEnumerator
CLongEnumerator
CDictionaryBase< TKey, TValue >	A base class for user-defined dictionaries that want to implement both IDictionary(K,V) and IReadOnlyDictionary(K, V).
CDictionaryWithChangeEvents< K, V, TDictionary >	A dictionary wrapper that provides ListChanging and ListChanged events. You can also implement custom behavior by overriding its methods.
CDictionaryWrapper< 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.
CEnumeratorFrame< T >	A standard base class for enumerator frames used by NestedEnumerator{EnumeratorFrame{T},T}.
CIAListTreeObserver< 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.
CIEnumeratorFrame< Frame, T >	Helper interface for NestedEnumerator{Frame, T}.
►CInternalDList< 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.
CEnumerator
►CInternalList	Contains static methods to help manage raw arrays with even less overhead than InternalList{T}.
CEnumerator< T >
CScanner< T >	Implements IScanner{T} for Memory{T}.
CInternalList< 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.
►CInternalSet< T >	A hash-trie data structure for use inside other data structures.
CEnumerator
CInternalSetStats	Statistics returned from InternalSet{T}.CountMemory.
CKeylessHashtable< 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.
CKeylessHashtable< T, Int, Math >	The concrete implementation of KeylessHashtable{T}. Do not use directly; instead, call KeylessHashtable{T}.New(int).
CKeyWalker	Internal implementation class. Represents a pointer to a location within a byte array.
CListExBase< T >	A base class for classes that wish to implement IListEx{T}. Provides default implementations for most of the methods.
CListSourceBase< 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.
CListWithChangeEvents< T, TList >	A list wrapper that provides ListChanging and ListChanged events. You can also implement custom behavior by overriding its methods.
CListWrapper< 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.
CReadOnlyCollectionBase< T >	Helps you implement read-only collections by providing default implementations for most methods of ICollection{T} and IReadOnlyCollection{T}.
CSCell	Standard cell, used to encode keys in a CPSNode
CSetWrapper< 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.
CSparseAListLeaf< T >	Internal implementation class. Leaf node of SparseAList{T}.
►NMutableListExtensionMethods	Contains extension methods for ICollection{T} and IList{T} that are possibly ambiguous when included in the same namespace as extension methods for IReadOnlyCollection{T} and IReadOnlyList{T}.
CICollectionExt	Extension methods for ICollection{T}.
CIListExt	Extension methods and helper methods for IList{T}.
CLCExt
CLinqToLists
CAddAdapter< T >
CAddAdapter< T, Context >
CAList< 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.
►CAListBase< K, T >	Base class for the indexed tree-based data structures known as AList{T} and BList{T}.
CEnumerator
CObserverMgr	A multiplexer that is only created for ALists that have two or more attached intances of IAListTreeObserver{K,T}.
CAListBase< 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.
CAListExt
CAListReverseView< K, T >	A reverse view of an AList.
CAListStatisticTracker< K, T >	This class incrementally updates a Statistic object based on changes to AList{T} and its variants (BList, BDictionary, and BMultiMap).
CAListStatisticTracker< 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).
CAListStatisticTracker< T >
CAListStatisticTrackerBase< 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}.
CAListSumTracker< K, T >	This class incrementally recomputes the sum of an AList{T} (or its variants - BList, BDictionary, and BMultiMap).
CAListSumTracker< T >
CArrayOf4< T >
CArraySlice< T >	Adapter: Provides access to a section of an array.
CBDictionary< K, V >	An sorted dictionary that is efficient for all operations and offers indexed access to its list of key-value pairs.
CBijection< 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.
CBList< T >	An sorted in-memory list that is efficient for all operations and offers indexed access to its list.
►CBMultiMap< K, V >	An sorted dictionary that allows multiple values to be associated with a single key.
CValueList	Represents the set of values associated with a particular key in a BMultiMap{K,V} collection.
►CBufferedSequence< T >	Adapter: This class wraps an IEnumerator{T} or IEnumerable{T} into an IListSource{T}, lazily reading the sequence as TryGet is called.
CScanner
CByteComparer
CCG	Contains global functions of Loyc.Collections that don't belong in any specific class.
CCollectionAsReadOnly< T >	Adapter: a read-only wrapper that implements ICollection(T) and IReadOnlyCollection(T), returned from EnumerableExt.AsReadOnly{T}.
CCollectionAsSink< T, List >	Helps implement extension method ListExt.AsSink{T}(ICollection{T}).
CCollectionDebugView< T >	This helper class gives a nice view of a custom collection within the debugger.
CCollectionSource
CCollectionWithChangeEvents< T >	A collection wrapper that provides ListChanging and ListChanged events. Shorthand for Loyc.Collections.Impl.CollectionWithChangeEvents{T,ICollection{T}}.
►CCPStringTrie< TValue >	A compact patricia trie that uses strings as keys.
CEnumerator	Enumerates key-value pairs in a CPStringTrie.
CKeyCollection	Return value of CPStringTrie{T}.Keys.
CKeyEnumerator	Enumerates keys of a CPStringTrie.
CCPTrie< 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.
CCPValueCollection< T >	Provides read-only access to the values of a CPTrie.
CDictionaryAsSink< K, V, Dict >	Helps implement extension method DictionaryExt.AsSink{K, V}(IDictionary{K, V}).
CDictionaryDebugView< 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}.
CDictionaryExt	Extension methods for Dictionary{K,V}, IDictionary{K,V} and IDictionaryEx{K, V}.
CDictionaryWithChangeEvents< K, V >	A dictionary wrapper that provides ListChanging and ListChanged events. Shorthand for Loyc.Collections.Impl.DictionaryWithChangeEvents{K,V,IDictionary{K,V}}.
CDList	This class is the same as DList{object} except that it also implements the IList interface.
CDList< T >	A compact auto-enlarging list, similar to List{T}, that efficiently supports supports insertions at the beginning or end of the list.
CEmpty< T >	A variety of empty lists.
CEmptyArray< T >	EmptyArray{T}.Value lets you avoid allocating an empty array on the heap.
CEmptyEnumerator< T >	Helper class: an empty enumerator.
CEmptyList< T >	Helper class: EmptyList{T}.Value is a read-only empty list.
CEmptySequenceException	An exception thrown by methods or properties that require a non-empty sequence but were provided with an empty sequence.
CEnumerableExt	Additional extension methods for IEnumerable{T}, IReadOnlyCollection{T}, and ICollection{T}, beyond what LINQ provides.
CEnumerationException	An exception thrown by an enumerator when it detects that the collection was modified after enumeration started but before it finished.
CEnumeratorBase< 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.
►CFVList< T >	A reference to a FVList, a so-called persistent list data structure.
CEnumerator	Enumerator for FVList; also used by FWList.
CFWList< T >	FWList is the mutable variant of the FVList data structure.
CHeap
CIAdd< in T >	An interface for depositing items. Includes only an Add(T) method.
CIAddRange< 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.
CIArray< T >	This interface models the capabilities of an array: getting and setting elements by index, but not adding or removing elements.
CIArraySink< in T >	Represents a write-only array.
CIAutoCreatePool< in TKey, out TValue >	Represents a pool of objects in which an object is automatically created when requested by its key.
CIAutoNegArray< T >	This is a tag interface indicating that the boundaries of the array can be expanded implcitly by writing to an index outside the range. However, the indexer may still throw when reading outside the current boundaries. To avoid exceptions, please use a TryGet extension method.
CIAutoSizeArray< 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.
CIBinumerable< T >	Interface for a collection that can return IBinumerator{T}s pointing to the beginning and end of the collection.
CIBinumerator< T >	Extends the "enumerator" concept to allow backward enumeration.
CIBRange< out T >	A bidirectional range. Allows you to read or remove the first or last element in a range.
CIBRangeEx< R, T >	A bidirectional range that can perform operations such as intersection and overlap tests on pairs of ranges of the same type.
CIBRangeEx< T >	A bidirectional range that can perform operations such as intersection and overlap tests on pairs of ranges.
CICharSource	A read-only list of characters plus a Slice(int,int) method.
CICollectionAndReadOnly< 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.
CICollectionAndSource< 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.)
CICollectionEx< T >	This interface is intended to be implemented by editable collection classes that are not indexable lists nor dictionaries.
CICollectionExWithChangeEvents< 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.
CICollectionImpl< 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.
CICollectionSink< in T >	Represents a write-only collection: you can modify it, but you cannot learn what it contains.
CICollectionSource< T >	A variation of IReadOnlyCollection that provides the Contains() and CopyTo() methods from ICollection.
CICollectionWithChangeEvents< T >	Combines ICollection{T} with INotifyListChanging{T, ICollection{T}}. and INotifyListChanged{T, ICollection{T}}.
CIContains< in T >
CICount	Holds the Count property found in nearly all collection interfaces.
CIDeque< T >	Represents a double-ended queue that allows items to be added or removed at the beginning or end.
CIDictionaryAndReadOnly< 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}.
CIDictionaryEx< K, V >	Combines IDictionary, IReadOnlyDictionary, and IDictonarySink with a few additional methods.
CIDictionaryExWithChangeEvents< K, V >
CIDictionaryImpl< 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}, as well as the trivial interface IMIndexed{K,V}.
CIDictionarySink< in K, in V >	Represents a write-only dictionary class.
CIDictionarySource< K, V >	Combines IReadOnlyDictionary{K, V} with related interfaces IIndexed{K, V}, ITryGet{K, V} and ISource{KeyValuePair{K,V}}.
CIDictionaryWithChangeEvents< K, V >
CIFRange< 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}.
CIHasFirst< out T >	Encapsulates a First property (for sequences).
CIHasLast< out T >	Encapsulates a Last property (for sequences).
CIHasMFirst< T >	Encapsulates a mutable First property.
CIHasMLast< T >	Encapsulates a mutable Last property.
CIIndexed< in K, out V >	Represents the essence of a dictionary, which returns a value given a key.
CIIndexedSink< in K, in V >	Represents a V this[K key] { set; } property.
CIIsEmpty	Holds the IsEmpty property that tells you if a collection is empty.
CIListAndListSource< 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.)
CIListAndReadOnly< 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.
CIListEx< 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).
CIListExWithChangeEvents< T >
CIListImpl< 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}.
CIListRangeMethods< in T >	The batch-operation methods of IListEx{T}, mainly for collection types that can add or remove multiple items in one method call.
CIListSink< in T >	Represents a write-only indexable list class.
CIListSource< out T >	A read-only list indexed by an integer.
CIListWithChangeEvents< T >
CIMBinumerator< 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.
CIMBRange< T >	A mutable bidirectional range.
CIMEnumerator< T >	A mutable enumerator interface. Provides a "Remove" method like Java iterators have, and allows you to modify the current item.
CIMFRange< T >	A mutable forward range.
CIMIndexed< in K, V >	Represents the essence of a mutable dictionary: the ability to get or set a value for a key.
CIMRange< T >	A mutable random-access range.
CIndexedAList< 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).
CINegArray< T >	This interface models the capabilities of an array: getting and setting elements by index, but not adding or removing elements. Implementing INegListSource{T} makes it slightly different from IArray{T}, in that indexes can be negative, so there are Min and Max properties.
CINegAutoSizeArray< 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.
CINegDeque< 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.
CINegListSource< out T >	This interface is the counterpart to IListSource{T} for lists whose minimum index is not (necessarily) zero.
CINotifyListChanged< T >	A version of INotifyListChanging{T, TCollection} in which TCollection is fixed at IListSource{T}.
CINotifyListChanged< 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.
CINotifyListChanging< T >	A version of INotifyListChanging{T, TCollection} in which TCollection is fixed at IListSource{T}.
CINotifyListChanging< 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.
CInternalDArray< T >
CInvertibleSet< 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".
CIOptimize	Interface for an Optimize() method.
CIPop< out T >
CIPopExt
CIPriorityQueue< T >	Represents a priority queue, in which Pop() always returns the largest or smallest item.
CIPush< in T >	Encapsulates a Push(T) method.
CIQueue< T >	Represents a FIFO (first-in-first-out) queue (or a priority queue if IPriorityQueue{ThisAssembly} is also implemented).
CIRange< 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}.
CIRangeEx< R, T >	A random-access range that can perform operations such as intersection and overlap tests on pairs of ranges of the same type.
CIRangeEx< T >	A random-access range that can perform operations such as intersection and overlap tests on pairs of ranges.
CIScan< T >	Same as IScannable{T} except that it does not implement IEnumerable{T}. In most cases IScannable{T} should be implemented instead.
CIScannable< T >	A sequence of T objects that is meant to be read in chunks. This interface is essentially a faster version of IEnumerable{T}: it allows the caller to scan a sequence faster by avoiding unnecessary interface calls.
CIScanner< T >	A data-reading object returned by IScannable{T} implementations. This interface is used for reading data, similar to IEnumerator{T}, but it reads blocks of data instead of single items. This can improve performance by reducing the number of interface calls necessary to scan a collection.
CISetImm< T >	An immutable set that supports numerous set operations.
CISetImm< T, SetT >	An immutable set of type SetT with elements of type T.
CISetOperations< in T, in InSetT, out OutSetT >	Set-combining operations: With, Without, Union, Intersect, Except, Xor.
CISetOperations< in T, SetT >	Set-combining operations: With, Without, Union, Intersect, Except, Xor.
CISource< out T >	Combines IReadOnlyCollection{T} with related interfaces ICount and IIsEmpty.
CISparseList< 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.
CISparseListEx< T >	A sparse list that supports additional methods including InsertRange(int, ISparseListSource{T}).
CISparseListSource< T >	Represents a read-only indexed list in which parts of the index space may be unused or "clear".
CIStack< T >	Represents a LIFO (last-in-first-out) stack.
CITryGet< in K, out V >	Enables access to TryGet extension methods for retrieving items from a collection without risk of exceptions. Unlike IReadOnlyDictionary{K, V}, this interface supports variance (e.g. ITryGet{object, string} can be assigned to ITryGet{string, object}) and it does not throw when the key is null.
CITryPop< out T >	Represents a collection that produces a sequence of items, and can return the next item without popping it (the Peek operation).
CKeyAlreadyExistsException	An exception thrown by dictionary objects when they are asked to "add" a key-value pair that already exists.
►CKeyCollection< 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.
CEnumerator
CLCExt	Extension methods for Loyc Collection interfaces (such as IListSource{T}).
CLCInterfaces	Core functionality for Loyc collection interfaces
CLinqToLists	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.
CListAsListSource< T >	Helper type returned from LCExt.AsListSource{T}.
CListAsSink< T, List >	Helps implement extension method ListExt.AsSink{T}(IList{T}).
CListChangeInfo< T >	Contains information about how a collection is about to change.
CListExt	Extension methods and helper methods for List{T}, IList{T}, IReadOnlyList{T}, arrays, IListSource{T}, and for related mutable interfaces such as IArray{T}.
CListSlice< 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}
CListSourceAsList< T >	Adapter: a read-only wrapper that implements IList(T) and IListSource(T), returned from LCExt.AsList{T}.
CListSourceAsSparse< T >	Adapter from IListSource{T} to ISparseListSource{T}.
CListSourceDebugView< T >	This helper class gives a nice view of a custom collection within the debugger.
CListWithChangeEvents< T >	A list wrapper that provides ListChanging and ListChanged events. Shorthand for Loyc.Collections.Impl.ListWithChangeEvents{T,IList{T}}.
CMap< K, V >	An immutable dictionary.
CMapOrMMap< K, V >	Common base class that contains code shared between Map{K,V} and MMap{K,V}.
CMaxHeap< 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, 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.
CMaxHeapInList< T >	This priority queue wrapper type is returned from the AsMaxHeap() extension method.
CMemoryComparer< T >
CMinHeap< 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.
CMinHeap< 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.
CMinHeapInList< T >	This priority queue wrapper type is returned from the AsMinHeap() extension method.
CMMap< K, V >	A dictionary class built on top of InternalSet<KeyValuePair<K,V>>.
CMSet< T >	A mutable set.
►CMultiMap< K, V >	A multimap is a dictionary that allows more than one value to be associated with each key. This is much more convenient than a Dictionary of Lists of values, because the indexer always returns a collection (empty if there are no values associated with a key) and its methods automatically create or destroy, as appropriate, the list associated with each key.
CValueList
CNegList< 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).
CNegListSlice< T >	Adapter: a random-access range for a slice of an INegListSource{T}.
CNegListSource< 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).
CNestedEnumerable< 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.
CNestedEnumerator< 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#.
►CNumRange< Num, Math >	Represents a range of integers of a specified data type.
CEnumerator
CRangeEnumerator< R, T >	Helper struct: enumerates through a forward range (IFRange{T}), calling the range methods through R instead of through IFRange{T}.
CRangeEnumerator< T >	Helper struct: enumerates through a forward range (IFRange{T}).
CRangeExt	Extension/helper methods for ranges.
CReadOnlyArraySlice< T >
CReadOnlyAsCollection< T >	A read-only wrapper that implements ICollection(T) and ISource(T), returned from LCExt.AsCollection{T}
CReadOnlyListAsListSource< T >	Helper type returned from LCExt.AsListSource{T}(IReadOnlyList{T}).
CRepeated< 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).
CReverseBinumerator< T >	Adapter: a IBinumerator{T} that swaps the MoveNext() and MovePrev() methods.
CReverseComparer< T >	Reverses the order used by an IComparer object.
CReverseComparer< T, TComparer >	Reverses the order used by an IComparer object.
CReversedList< T >	Adapter: a reversed of an IList{T}. TODO: unit tests.
CReversedListSource< T >	Adapter: reversed view of IListSource{T} returned from LinqToLists.Reverse{T}.
CROLSlice< T, TList >	Adapter: a random-access range for a slice of an IReadOnlyList{T}.
►CScannableEnumerable< T >	An adapter that implements IScannable{T} on any collection.
CScanner< TEnumerator >
CSelectCollection< ListT, T, TResult >	Helper class for LinqToLists.
CSelectDictionaryFromKeys< 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.
CSelectList< 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})
CSelectListSource< 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})
CSelectReadOnlyCollection< ListT, T, TResult >	Helper class for LinqToLists.
CSelectReadOnlyList< 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})
►CSet< T >	An immutable set.
CEnumerator	Enumerator for MSet{T}.
CSimpleCache< T >	A cache designed to save memory by sharing instances of identical strings and other immutable objects.
CSlice_< T >	Adapter: a random-access range for a slice of an IListSource{T}.
CSparseAList< T >	A sparse A-List that implements ISparseList{T}.
CSparseListSourceSlice< T, TList >
CTryGetExt	Standard extension methods for ITryGet{K, V}.
CTypeDictionaryWithBaseTypeLookups< Value >	A dictionary whose keys are Type objects. This dictionary behaves almost identically to a standard dictionary, except that the TryGetValue method will find matches on base types and interfaces, e.g. if you add a dictionary entry for IEnumerable, then TryGetValue(typeof(BitArray), out _) will return true.
CUpCastListSource< T, TOut >	Helper class for treating a collection of a derived type as a collection of a base type or interface.
CUpCastSource< T, TOut >	Helper class for treating a collection of a derived type as a collection of a base type or interface.
►CValueCollection< 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.
CEnumerator	Return type of GetEnumerator().
►CVList< T >	VList represents a reference to a reverse-order FVList.
CEnumerator	Enumerates through a VList from index 0 up to index Count-1.
CVListBlock< T >	VListBlock implements the core functionality of FVList, VList, FWList and WList. It is not intended to be used directly.
CVListBlockArray< 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.
CVListBlockOfTwo< 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.
CWeakKeyComparer< 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.
CWeakKeyDictionary< TKey, TValue >	A dictionary with weak keys.
CWeakKeyReference< T >	Provides a weak reference to an object of the given type to be used in a WeakDictionary along with the given comparer.
CWeakValueDictionary< 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.)
CWList< T >	WList is the mutable variant of the VList data structure.
CWListBase< T >	Shared base class of FWList and WList.
CWListProtected< T >	WList implementation in which the WList operations are only accessible to a derived class.
►NCompatibility	Important interfaces of newer .NET versions than the version for which Loyc was compiled
C__ThisEnsuresTheNamespaceIsNotEmpty	Ensure using Loyc.Compatibility is not an error
►NEcs	Classes related to Enhanced C# (mostly found in Loyc.Ecs.dll).
►NParser	Enhanced C# parser
CEcsLexer	Lexer for EC# source code (see ILexer{Token}).
CEcsLiteralHandlers
►CEcsParser	Parses Enhanced C# code into a sequence of Loyc trees (LNode), one per top-level statement.
CTentativeResult
CTentativeState
CEcsPreprocessor	Handles EC# processor directives.
CEcsTriviaInjector	Trivia injector customized for Enhanced C#.
CTokenExt	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.
CEcsCodeSymbols	A list of symbols that are very specific to C# or Enhanced C#. Note: many symbols in Loyc.Syntax.CodeSymbols should be in this class instead, but this class was created very belatedly.
CEcsFacts	A collection of miscellaneous information about the Enhanced C# language.
CEcsLanguageService	The Value property provides easy access to the lexer, parser and printer for Enhanced C#.
CEcsNodePrinter	Encapsulates the code for printing an LNode to EC# source code.
CEcsPrecedence	Contains Precedence objects that represent the precedence rules of EC#.
CEcsPrinterOptions	Options to control the way EcsNodePrinter's output is formatted.
CEcsValidators	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.
►NGeometry	Contains math code and data types for processing geometry (points, lines, polygons, etc.). Basic geometry stuff is in Loyc.Essentials.dll, while more advanced algorithms are found in Loyc.Utilities.dll.
CINewPoint3< Point, T >	This interface exists to work around a limitation of C#; see IPoint{T} and IPoint3{T}.
CINewPoint< Point, T >	This interface exists to work around a limitation of C#; see IPoint{T}.
CINewRectangle3< Rect, T >	This interface exists to work around a limitation of C#; see IRectangle3{T}.
CINewRectangle< Rect, T >	This interface exists to work around a limitation of C#; see IRectangle{T}.
CIPoint3< T >	A mutable 3D point with X, Y, and Z coordinates.
CIPoint3Base< T >	This interface exists to work around a limitation of C#; use IPoint{T} instead.
CIPoint3Reader< T >	Interface for reading the coordinates of a 3D point.
CIPoint< T >	A mutable 2D point with X and Y coordinates.
CIPointBase< T >	This interface exists to work around a limitation of C#; use IPoint{T} instead.
CIPointReader< T >	Interface for reading the coordinates of a 2D point.
CIRectangle3< T >	Represents a mutable 3D rectangle.
CIRectangle3Base< T >	Represents a mutable 3D rectangular prism.
CIRectangle3Reader< T >	Represents a read-only 3D rectangular prism.
CIRectangle< T >	Represents a mutable 2D rectangle.
CIRectangleBase< T >	Represents a mutable 2D rectangle.
CIRectangleReader< T >	Represents a read-only 2D rectangle.
CISize3Reader< T >	Interface for reading the size of a 3D object.
CISizeReader< T >	Interface for reading the size of a 2D object.
►NGraphs
CIEdge< out Node >	A directed edge in a graph.
CIEdge< out Node, out TCost >	A directed edge in a graph.
CIEdgeTo< out Node >	A directed edge in a graph (without the From property of IEdge{Node}).
CIEdgeTo< out Node, out TCost >	A directed edge in a graph (without the From property of IEdge{Node}).
CIGraph< out Node >	A directed graph, consisting of nodes and edges (using the default edge type IEdgeTo{Node}).
CIGraph< out Node, out Edge >	A directed graph, consisting of nodes and edges (using the default edge list type IEnumerable{Edge}).
CIGraph< out Node, out Edge, out EdgeList >	A directed graph, consisting of nodes and edges (using the default cost type, float).
CIGraph< out Node, out Edge, out EdgeList, out Cost >	A directed graph, consisting of nodes and edges.
CINode< out EdgeList >	A node in a graph.
CIOutbound< out EdgeList >	A node in a graph that only provides access to outbound edges.
CITo< out Node >	Something with a To property, usually a directed edge in a graph.
CLGExt
CLGInterfaces	Core functionaliity for graphs
►NLLParserGenerator	Code related to LLLPG, the Loyc LL(k) Parser Generator (LLLPG.exe).
CActionPred
CAlts	Describes a series of alternatives (branches), a kleene star (*), or an optional element (?).
CAndPred	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.
CAutoValueSaverVisitor	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.
CCodeGenHelperBase	Suggested base class for custom code generators. Each derived class is typically designed for a different kind of token.
CDefaultErrorBranch	A singleton to be used as the value of Alts.ErrorBranch, representing the default_error branch.
CEndOfRule	A container for the follow set of a Rule.
CGate	Represents a "gate" (p => m), which is a mechanism to separate prediction from matching in the context of branching (Alts).
CGeneralCodeGenHelper	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 {...}.
CIntRange	Represents a range of single characters (e.g. 'A'..'Z').
CIntSet	Represents a set of characters (e.g. 'A'..'Z' | 'a'..'z' | '_'), or a set of token IDs.
CIntStreamCodeGenHelper	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 {...}.
CIPGCodeGenHelper	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.
CIPGTerminalSet	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.
►CLLParserGenerator	Encapsulates LLLPG, the Loyc LL Parser Generator, which generates LL(k) recursive-descent parsers.
CComputeNext	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.
CGenerateCodeVisitor	Directs code generation using the visitor pattern to visit the predicates in a rule. The process starts with Generate(Rule).
CGetCanonical	Computes the "canonical" interpretation of a position for prediction purposes, so that ConsolidateDuplicatePositions can detect duplicates reliably. Call Do() to use.
CGrammarPos	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.
CKthSet	Holds information about the first set or kth set of a single arm of an Alts.
CPredictionAnalysisVisitor	Performs prediction analysis using the visitor pattern to visit the predicates in a rule. The process starts with Analyze(Rule).
CTransition	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.
CLlpgBugsAndSlugs	Tests for known slugs (slowness bugs) and fixed bugs (regressions)
►CLlpgGeneralTestsBase	Shared base class for "full-stack" LLLPG tests that use LeMP, the Ecs parser, and LLLPG macros in addition to the core engine.
CTestCompiler
CLlpgHelpers	Helper methods for making LLLPG grammar nodes. Used by LlpgCoreTests.
CLlpgTestLargerExamples
CPGIntSet	Represents a set of characters (e.g. 'A'..'Z' | 'a'..'z' | '_'), or a set of integers, used in the grammar of a parser.
CPGNodeSet	An immutable set that implements IPGTerminalSet so that it can be used by LLParserGenerator.
CPGTerminalSet	Extension methods for IPGTerminalSet.
CPred	Represents part of a grammar for the LLParserGenerator.
CPredVisitor	Base class for implementing a visitor that examines a tree of LLLPG Predicates.
CProgram	Entry point of LLLPG.exe, with QuickRun() method to help invoke LLLPG programmatically.
CRecursivePredVisitor	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.
CRecursiveReplacementPredVisitor	Base class for visitors that can replace predicates entirely.
CRule	Represents an LLLPG rule, which is a Predicate plus a Name and optional attributes (e.g. token, private, etc.).
CRuleRef	Represents a nonterminal, which is a reference to a rule.
CSeq	Represents a sequence of predicates (Preds).
CTerminalPred	Represents a terminal (which is a token or a character) or a set of possible terminals (e.g. 'A'..'Z').
CZeroWidthPred
►NLLPG	Contains macros for using LLLPG in LeMP.
CMacros	Macros for using LLLPG in LeMP.
►NMath	Contains general-purpose math algorithms beyond what is provided in the .NET BCL (Base Class Library). Notable class: Math.MathEx.
CIAdditionGroup< 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
CIBinaryMath< T >	Provides additional bit-oriented integer operations.
CIBitwise< T >	Provides the standard set of bitwise operators.
CIComplexMath< 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.
CIConvertTo< T >	Provides methods for converting common numeric types to another numeric type "T".
CIExp< T >	Provides power, logarithm, raise-e-to-exponent (Exp) and logarithm-of-e (Log) operations.
CIField< T >	This defines a Field with the operations +,-,*,/
CIFloatMath< T >	Provides operations available on floating-point types (float and double), including trigonometry and exponentiation.
CIHasRoot< T >	Provides the Sqrt operation and its inverse, Square.
CIIncrementer< T >	Provides increment, decrement, and next/previous-representable- value operations.
CIIntMath< T >	Provides operations available on all unsigned integer types (byte, uint, etc.); see also IMath{T}, IIntMath{T}, and IFloatMath{T}.
CIMath< T >	Provides operations available on all system numeric types (int, uint, double, etc.); see also ISignedMath{T}, IUIntMath{T}, IIntMath{T} and IFloatMath{T}.
CIMultiplicationGroup< 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.
CIMultiply< T >	Provides the multiplication operation and the multiplicative identity, one.
CINumTraits< T >	This interface provides information about a numeric type T.
CIOneProvider< T >	Provides the value of "one" for type T.
CIOrdered< T >	Provides comparison function for type T along with absolute value (Abs), and the minimum or maximum of two values (Min, Max).
CIOrderedExt	Extension methods for IOrdered{T}.
CIRationalMath< T >	Use this interface for floating-point, fixed-point, and rational types. Rational types support reciprocal and negation.
CIRing< T >	This defines a Ring with the operations +,*
CISignedMath< T >	Provides operations available on all signed numeric types (int, double, etc.); see also IUIntMath{T}, IIntMath{T} and IFloatMath{T}.
CITrigonometry< T >	Provides trigonometry operations.
CIUIntMath< T >	Provides operations available on all unsigned integer types (byte, uint, etc.); see also IMath{T}, IIntMath{T}, and IFloatMath{T}.
CIZeroProvider< T >	Provides the value of "zero" for type T.
►NMiniTest	A stripped-down NUnit lookalike which allows you to put simple unit tests in an assembly without having to add a reference to NUnit.Framework.dll.
CAssert	The Assert class contains a collection of static methods that mirror the most common assertions used in NUnit.
CAssertionException	Thrown when an assertion fails during a call to a method of Assert.
CBenchmarkAttribute	Marks a benchmark test, which exists to test performance. Benchmark tests are often run multiple times to obtain an average running time.
CExpectedExceptionAttribute	Marks a test that is expected to throw an exception of a particular type. The test fails if the expected exception is not thrown.
CIgnoreException	Thrown by Assert.Ignore().
CInconclusiveException	Thrown by Assert.Inconclusive().
CRunTests	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.
CSetUpAttribute	Marks a method that is to be called prior to each test in a test fixture.
CSuccessException	Thrown by Assert.Success().
CTearDownAttribute	Marks a method that is to be called after each test in a test fixture.
CTestAttribute	Identifies a method that contains a unit test, or that returns other tests or test fixtures.
CTestException	An exception thrown when a method of Assert fails.
CTestFixtureAttribute	Identifies a class that contains unit tests, or methods that return other tests or test fixtures.
►NSyncLib
►NImpl
CArrayBuilder< T >
CAsISyncField< SyncManager, T >	An adapter from SyncFieldFunc_Ref{S,T} to ISyncField{S,T}
CAsISyncObject< SyncManager, T >	An adapter from SyncObjectFunc{S,T} to ISyncObject{S,T}.
CCollectionBuilder< TList, T >	Helper type for reading ICollection{T} types.
CIListBuilder< out TList, T >	An interface implemented by adapters that help read and write lists of various types, e.g. ListBuilder{T}. The adapter can be used to read a collection once or write it once, but not both.
CListBuilder< T >
CListLoader< SyncManager, TList, T, ListBuilder, SyncItem >
CListSaver< SyncManager, List, T, SyncItem >	Contains a sync function for saving a IReadOnlyCollection{T}. Requires and assumes that IsSaving is true in the ISyncManager provided.
CListSaverC< SyncManager, List, T, SyncItem >	A variation of ListSaver<...> for lists that implement ICollection{T}.
CMemoryBuilder< T >
CObjectSyncher	A helper for reading/writing data using a SyncObjectFunc{SyncManager, T}.
►CObjectSyncher< SyncManager, SyncObj, T >	A helper for reading/writing objects and structs via ISyncObject{SyncManager, T}.
CDefaultTag
CScannerSaver< SyncManager, Scanner, T, SyncItem >	Contains a sync function for saving an IScanner{T}. Requires and assumes that IsWriting is true in the ISyncManager provided.
CSyncDateAsDayNumber< SyncManager >
CSyncEnumAsString< SyncManager, E >
CSyncLibStringBuilder	Helper type for reading StringBuilder. This is actually used to help read strings in case they don't have a length prefix.
CSyncList< SM, T, List, SyncItem >	Contains an implementation of ISyncField for any ICollection{T} type. The constructor requires a synchronizer that implements ISyncField{SM, T}.
CSyncList< SM, T, SyncItem >	Contains implementations of ISyncField for several types of lists. The constructor requires a synchronizer that implements ISyncField{SM, T}.
CSyncObjectList< SM, T >	Contains implementations of ISyncField for several types of lists. The constructor needs a SyncObjectFunc{SM, T} delegate to synchronize each list item.
CSyncObjectList< SM, T, SyncObj >	Contains implementations of ISyncField for several types of lists. The constructor requires a synchronizer that implements ISyncObject{SM, T}.
CSyncPrimitive< SyncManager >
CSyncTime< SM >	The default synchronizer for times and dates (DateTime, DateTimeOffset and TimeSpan), used by the Sync extension methods in SyncTimeExt. In plain-text formats, values are written as strings in the same way as Newtonsoft.Json (see SyncTimeAsString{SM}); otherwise they are written as integers (see SyncTimeAsTicks{SM}). When reading, the type of the field in the data stream (if available) determines which representation is parsed, so either representation can be read back.
CSyncTimeAsString< SM >	Synchronizes DateTime, DateTimeOffset and TimeSpan values as strings. By default the formats match Newtonsoft.Json: ISO-8601 for DateTime — written in one of three forms according to its DateTimeKind (see SyncDateTimeHelper.NewtonsoftDateFormat) — and for DateTimeOffset, and constant ("c") format for TimeSpan. A different format can be chosen via the constructor. All strings are written and parsed with the invariant culture.
CSyncTimeAsTicks< SM >	Synchronizes date/time values as integers: DateTime as the 64-bit value of DateTime.ToBinary (which equals Ticks when the DateTimeKind is Unspecified, and preserves the Kind otherwise), TimeSpan as TimeSpan.Ticks, and DateTimeOffset — the one type here that does not fit in 64 bits — as a tuple of two integers: Ticks, and the UTC offset in minutes.
CWriterStateBase
CFieldId	The data type of a field name in SyncLib, which can be implicitly converted from a string. It includes both a Name string and an Id integer, in order to support both string-keyed fields (e.g. JSON) and int-keyed fields (e.g. Protocol Buffers). By convention, an Id of int.MinValue indicates that int-keyed implementations of ISyncManager should choose an ID automatically based on the field order.
CISyncField< SyncManager, T >	Represents the low-level synchronization behavior for a single list item. SyncManagerHelper needs this.
CISyncManager	This is the central interface of Loyc.SyncLib. To learn more, please visit the web site: http://synclib.loyc.net/
CISyncObject< SyncManager, T >	This interface is equivalent to SyncObjectFunc{SyncManager,T}, reformulated as an interface. It only exists because the CLR (C# runtime) supports optimizations on generic parameters that are structs, but similar optimizations don't exist for delegates. For this reason it is possible to achieve higher performance by providing a synchronizer in the form of a struct rather than a delegate (see Remarks)
CISyncOptions	An interface for the options objects of ISyncManager implementations (e.g. SyncJson.Options), returned from ISyncManager.Options. It exposes settings whose meaning is not specific to a single data format.
►CSyncJson	Contains optimized ISyncManager implementations for reading and writing JSON data (SyncJson.Reader and SyncJson.Writer) plus an options type (SyncJson.Options) and convenience methods for reading and writing objects as JSON (Read, ReadI, Write, WriteI and WriteString methods.) The JSON format is designed to be compatible with Newtonsoft.Json.
CWriter
CSyncManagerExt	Standard extension methods for ISyncManager.
CSyncManagerExtBigInteger	The methods in this class belong in SyncManagerExt but they must be put in a different class to avoid C# compiler error CS0111, "Type 'SyncManagerExt' already defines a member called 'SyncList' with the same parameter types".
CSyncManagerExtBool	The methods in this class belong in SyncManagerExt but they must be put in a different class to avoid C# compiler error CS0111, "Type 'SyncManagerExt' already defines a member called 'SyncList' with the same parameter types".
CSyncManagerExtByte	The methods in this class belong in SyncManagerExt but they must be put in a different class to avoid C# compiler error CS0111, "Type 'SyncManagerExt' already defines a member called 'SyncList' with the same parameter types".
CSyncManagerExtChar	The methods in this class belong in SyncManagerExt but they must be put in a different class to avoid C# compiler error CS0111, "Type 'SyncManagerExt' already defines a member called 'SyncList' with the same parameter types".
CSyncManagerExtDecimal	The methods in this class belong in SyncManagerExt but they must be put in a different class to avoid C# compiler error CS0111, "Type 'SyncManagerExt' already defines a member called 'SyncList' with the same parameter types".
CSyncManagerExtDouble	The methods in this class belong in SyncManagerExt but they must be put in a different class to avoid C# compiler error CS0111, "Type 'SyncManagerExt' already defines a member called 'SyncList' with the same parameter types".
CSyncManagerExtFloat	The methods in this class belong in SyncManagerExt but they must be put in a different class to avoid C# compiler error CS0111, "Type 'SyncManagerExt' already defines a member called 'SyncList' with the same parameter types".
CSyncManagerExtInt	The methods in this class belong in SyncManagerExt but they must be put in a different class to avoid C# compiler error CS0111, "Type 'SyncManagerExt' already defines a member called 'SyncList' with the same parameter types".
CSyncManagerExtLong	The methods in this class belong in SyncManagerExt but they must be put in a different class to avoid C# compiler error CS0111, "Type 'SyncManagerExt' already defines a member called 'SyncList' with the same parameter types".
CSyncManagerExtSByte	The methods in this class belong in SyncManagerExt but they must be put in a different class to avoid C# compiler error CS0111, "Type 'SyncManagerExt' already defines a member called 'SyncList' with the same parameter types".
CSyncManagerExtShort	The methods in this class belong in SyncManagerExt but they must be put in a different class to avoid C# compiler error CS0111, "Type 'SyncManagerExt' already defines a member called 'SyncList' with the same parameter types".
CSyncManagerExtString	The methods in this class belong in SyncManagerExt but they must be put in a different class to avoid C# compiler error CS0111, "Type 'SyncManagerExt' already defines a member called 'SyncList' with the same parameter types".
CSyncManagerExtUInt	The methods in this class belong in SyncManagerExt but they must be put in a different class to avoid C# compiler error CS0111, "Type 'SyncManagerExt' already defines a member called 'SyncList' with the same parameter types".
CSyncManagerExtULong	The methods in this class belong in SyncManagerExt but they must be put in a different class to avoid C# compiler error CS0111, "Type 'SyncManagerExt' already defines a member called 'SyncList' with the same parameter types".
CSyncManagerExtUShort	The methods in this class belong in SyncManagerExt but they must be put in a different class to avoid C# compiler error CS0111, "Type 'SyncManagerExt' already defines a member called 'SyncList' with the same parameter types".
CSyncTimeExt	Extension methods of ISyncManager for synchronizing the date/time types DateTime, DateTimeOffset and TimeSpan (plus DateOnly and TimeOnly on .NET 6+, but no target framework of Loyc.Essentials is currently new enough to include them).
►NSyntax	Loyc.Syntax.dll: contains Loyc trees (Loyc.Syntax.LNode), lexing stuff, LLLPG base classes (BaseParser{T} and BaseLexer), the LES parser and printer, data types related to source code management (e.g. ISourceFile, SourceRange) and other general-purpose code related to the manipulation of syntax.
►NImpl
CILNodePrinterHelper	A version of ILNodePrinterHelper{Self} without a type parameter.
CILNodePrinterHelper< out Self >	A fluent interface for classes that help you print syntax trees (ILNodes).
CILNodePrinterHelperWithRevokableNewlines< Checkpoint >	Alias for ILNodePrinterHelperWithRevokableNewlines{Checkpoint,Self} without the second type parameter.
CILNodePrinterHelperWithRevokableNewlines< Checkpoint, out Self >	Enhances ILNodePrinterHelper{Self} with an ability to revoke newlines.
CIPrinterHelper< out Self >
CLNodePrinterHelper	A helper type for printer objects; for details, please see ILNodePrinterHelper{S}, its derived interface ILNodePrinterHelperWithRevokableNewlines{S,C}, and the documentation of the constructor LNodePrinterHelper(StringBuilder, string, string, bool, string, string).
CLNodePrinterHelperExt	Standard extension methods for ILNodePrinterHelper
CLNodePrinterHelperLocation	A location in the output stream of LNodePrinterHelper.
CPrinterIndentHint	Values used with ILNodePrinterHelper{Self}.Newline(Symbol).
►CPrinterState
CCheckpoint
►NLes	Contains classes related to Loyc Expression Syntax (LES), including the parser and printer (reachable through Loyc.Syntax.Les.LesLanguageService).
CCustomLiteral	A custom literal is a normal number or string paired with a (typically unrecognized) type prefix or suffix.
CINodePrinterWriter	This interface is implemented by helper objects that handle the low-level details of node printing. It is used by Les2Printer.
CLes2LanguageService	The Value property provides easy access to the lexer, parser and printer for Loyc Expression Syntax (LES).
CLes2Lexer	Lexer for EC# source code.
CLes2Parser	Parses LES (Loyc Expression Syntax) code into a sequence of Loyc trees (LNode), one per top-level statement.
CLes2PrecedenceMap
CLes2Printer	Prints a Loyc tree in LES (Loyc Expression Syntax) format.
CLes2PrinterOptions	Options to control the way Loyc trees are printed by Les2Printer.
CLes3LanguageService
CLes3Lexer
CLes3Parser
CLes3PrecedenceMap	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.
CLes3PrettyPrinter	A variant of Les3Printer that adds syntax highlighting in one of three ways: as console output, as HTML output, or as LesColorCode control codes.
CLes3Printer
CLes3PrinterOptions	A set of extended options supported when printing in LES3.
CLesLanguageService	Alternate name for Les2LanguageService (will change to Les3LanguageService in the future)
CLesPrecedence	Contains Precedence objects that represent the precedence levels of LES.
CNodePrinterWriterBase	Abstract base class for INodePrinterWriter. Has an protected _indentLevel field that is increased by Indent() and decreased by Dedent().
CTokenExt	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.
►NLexing	Contains classes related to lexical analysis, such as the universal token type (Loyc.Syntax.Lexing.Token) and Loyc.Syntax.Lexing.TokensToTree.
CBaseILexer< 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.
CBaseLexer	Alias for BaseLexer{C} where C is ICharSource.
►CBaseLexer< CharSrc >	The recommended base class for lexers generated by LLLPG, when not using the inputSource option.
CSavePosition	A helper class used by LLLPG for backtracking.
CCharCategory
CILexer< Token >	A standard interface for lexers.
CILllpgApi< 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.
CILllpgLexerApi< 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.
CIndentTokenGenerator	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.
CIndentTokenGenerator< 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.
CISimpleToken	Alias for ISimpleToken{int}.
CISimpleToken< 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.
CIToken	Alias for IToken{int}.
CIToken< TT >	The methods of Token in the form of an interface.
CLexerSource	A synonym for LexerSource{C} where C is ICharSource.
CLexerSource< CharSrc >	An implementation of the LLLPG Lexer API, used with the LLLPG options inputSource and inputClass.
CLexerSourceFile< CharSource >	Adds the AfterNewline method to SourceFile.
CLexerSourceWorkaround< CharSrc >	This class only exists to work around a limitation of the C# language: "cannot change access modifiers when overriding 'protected' inherited member Error(...)".
CLexerWrapper< Token >	A base class for wrappers that modify lexer behavior. Implements the ILexer interface, except for the NextToken() method.
CToken	A common token type recommended for Loyc languages that want to use features such as token literals or the TokensToTree class.
CTokenListAsLexer	Adapter: converts IEnumerable(Token) to the ILexer{Token} interface.
CTokensToTree	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.
CTokenTree	A list of Token structures along with the ISourceFile object that represents the source file that the tokens came from.
CTriviaSaver	A lexer wrapper that saves whitespace tokens into a list (TriviaList).
CWhitespaceFilter	Alias for WhitespaceFilter{Token}
CWhitespaceFilter< Token >	Filters out tokens whose Value is WhitespaceTag.Value.
CWhitespaceTag	WhitespaceTag.Value can be used as the Token.Value of whitespace tokens, to make whitespace easy to filter out.
CAbstractTriviaInjector< Trivia >	Encapsulates an algorithm that consumes trivia (comments and newlines) from a list and adds it as trivia attributes into LNodes.
CBaseParser< 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}.
►CBaseParser< 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.
CSavePosition	A helper class used by LLLPG for backtracking.
CBaseParserForList< Token, MatchType >	An base class designed for parsers that use LLLPG (Loyc LL(k) Parser Generator) and receive tokens from any IEnumerator{Token}.
CBaseParserForList< 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.)
CBaseParserNoBacktracking< Token >	An base class designed for parsers that use LLLPG (Loyc LL(k) Parser Generator) and receive tokens from an IEnumerator{Token}.
CBaseParserNoBacktracking< Token, Enumerator >	An base class designed for parsers that use LLLPG (Loyc LL(k) Parser Generator) and receive tokens from any IEnumerator{Token}.
CCallNode	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.
CCodeSymbols	A list of common symbols that, by convention, have special meaning: operators, built-in data types, keywords, trivia, etc.
CDescendantsFrame	Helper class used to enumerate LNode.Descendants().
CEmptySourceFile	A dummy implementation of ISourceFile that has only a filename, no source text. Used as the source file of synthetic syntax nodes.
CIdNode	Base class of all nodes that represent simple identifiers (including special symbols such as #foo).
CIFileName
CIHasFileName
CIIndexPositionMapper	This interface is for classes that can convert indexes to SourcePos structures and back.
CIIndexRange	Represents a pair of integers that represents a range of indices: either start & end or start & length. Invariant: Length == EndIndex-StartIndex.
CIIndexToLine	Contains an IndexToLine method.
CILineAndColumn	A line/column pair representing a location in a text file. Numbering starts at one for both Line and Column.
CILineColumnFile
CILineToIndex	Contains LineToIndex methods.
CILiteralParser	This interface for parsing text into objects is implemented by LiteralHandlerTable.
CILiteralPrinter	This interface for converting literals to text is implemented by LiteralHandlerTable.
CILiteralValue	Bundles the optional original text of a value with an optional in-memory form of it.
CILiteralValueProvider	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.
CILNode	A read-only interface for objects that act as Loyc trees.
CILNodePrinter	This interface allows serializing LNode objects into the syntax of a particular programming language.
CILNodePrinterOptions	A set of relatively universal printing options that LNodePrinters should understand.
CILNodeVisitor	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.
CIndexPositionMapper	Synonym for IndexPositionMapper<IListSource<char>>.
CIndexPositionMapper< CharSource >	Helper class for mapping from indexes to SourcePos and back.
CIndexRange	A mutable pair of (StartIndex, Length) that implements IIndexRange.
CIParsingOptions	A set of relatively universal parsing options that IParsingServices should understand.
CIParsingService	An interface that encapsulates the lexer and parser of a programming language, or a non-programming language that can be represented by Loyc trees.
CISerializedLiteral
CISourceFile	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.
CISourceRange	Represents a (contiguous) region of text in a source file.
CIUninterpretedLiteral	Represents the text form of a literal value, without its parsed value.
CLineAndCol	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.
CLineAndColumn	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.
CLineColumnFile	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.
CLineColumnFileAndIndex	This is a tuple of a FileName, Line, Column, and OriginalIndex.
CLineRemapper	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++)
CLiteralHandlerTable	A central class for keeping track of literal parsers and literal printers.
CLiteralNode	Base class of all nodes that represent literal values such as 123 and "foo".
CLiteralValue	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).
►CLNode	All nodes in a Loyc syntax tree share this base class.
CPushedPrinter	Returned by PushPrinter(ILNodePrinter).
CLNodeExt	Standard extension methods for LNode.
CLNodeFactory	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.
CLNodeList	A list of non-null references to LNode.
CLNodePrinter	Standard extension methods for ILNodePrinter.
CLNodePrinterOptions	A concrete class that users can pass to an LNodePrinter.
CLNodeRangeMapper	Helps map locations (such as error locations) from a file (usually an output file) to an LNode (see Remarks).
CLNodeVisitor	Base class for people that want to implement the visitor pattern with LNode.
CParseHelpers	Static methods that help with common parsing jobs, such as parsing integers, floats, and strings with C escape sequences.
CParserSource< Token >	Alias for ParserSource{Token, int, IList{Token}}.
CParserSource< Token, MatchType >	Alias for ParserSource{Token, int, IList{Token}}.
CParserSource< Token, MatchType, List >	An implementation of the LLLPG Parser API, used with the LLLPG options inputSource and inputClass.
CParsingMode	Standard parsing modes used with IParsingService and ILNodePrinterOptions.
CParsingOptions	A simple implementation of IParsingOptions.
►CParsingService	Standard extension methods for IParsingService.
CPushedCurrent	Returned by PushCurrent(IParsingService).
CPrecedence	A four-byte tuple that represents the precedence and miscibility of an operator.
CPrintHelpers	Static methods that help to print literals, such as EscapeCStyle which escapes special characters with backslashes.
CSourceFile
CSourceFile< CharSource >	A default implementation of ISourceFile based on IndexPositionMapper.
CSourceFileWithLineRemaps	An wrapper around ISourceFile that applies line remapping information (if the source file uses it).
CSourcePos	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.
CSourcePosAndIndex	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.
CSourcePosIsObsolete	This just helps end-users to discover the name change SourcePos.PosInLine => ILineAndColumn.Column during upgrades
CSourceRange	Holds a reference to a source file (ISourceFile<char>) and the beginning and end indices of a range in that file.
CSourceRangeExt	Standard extension methods for ISourceRange.
CStandardLiteralHandlers	A LiteralHandlerTable that is preinitialized with all standard literal parsers and printers.
CStandardTriviaInjector	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.
CStreamCharSource	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.
CUninterpretedLiteral	A simple implementation of IUninterpretedLiteral which can also be turned into an LNode by calling LNode.Literal{UninterpretedLiteral}(SourceRange, UninterpretedLiteral, NodeStyle).
►NThreading	Helper classes for multithreaded code.
►CAmbientService< T >	Holds the shared state behind an ambient service (the Ambient Service Pattern): a global default instance, plus an async-local override installed by Set in a using statement.
CSaved	Returned by Set; restores the previous ambient override (if any) when disposed.
CSavedThreadLocal< T >	Designed to be used in a "using" statement to temporarily alter a ThreadLocal{T}.
CSavedValue< T >	Designed to be used in a "using" statement to temporarily alter a ThreadLocalVariable{T} or Holder{T} or something else implementing IMValue{T}.
CScratchBuffer< T >	Holds a single Value that is associated with the thread that assigned it.
►CThreadEx	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.
CThreadDestructor	See PropagateVariables for more information.
CThreadLocalVariable< T >	Provides access to a thread-local variable through a dictionary that maps thread IDs to values.
CThreadLocalVariableBase	When used with ThreadEx, implementing this base class allows you to be notified when a child thread is created or terminates.
CThreadStartEventArgs	Used by the ThreadEx.ThreadStarting and ThreadEx.ThreadStopping events.
CTinyReaderWriterLock	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.
►NUtilities	Contains general-purpose classes that are not considered important enough to go directly into the Loyc namespace. Most of the classes in this namespace are defined in Loyc.Utilities.dll.
CBloomFilterM64K2	A bloom filter for very small sets.
CCo	Extension methods for Co{T}.
CCo< T >	A structure that helps you to write coroutines, or to avoid the performance penalty of nested iterators.
CGoAliasAttribute	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.
CGoDecoratorFieldAttribute	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.
CGoInterface	Mainly for internal use by the other GoInterface classes.
CGoInterface< 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.
CGoInterface< 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.
CIGoInterfaceWrapper	All GoInterface wrappers implement this interface.
CSimpleTimer	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.
CStatistic	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().
CTagsInWList< ValueT >	An implementation of ITags designed for AstNode.
CUG	Contains global functions of Loyc.Utilities that don't belong in any specific class.
CByteArrayInString	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.
CCheckParam	Helper methods for checking argument values that throw exceptions when an argument value is not acceptable.
CConcurrentModificationException	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.
CConsoleMessageSink	Sends all messages to System.Console.WriteLine(), with hard-coded colors for Error, Warning, Note, Verbose, and Detail.
CEither< L, R >	Holds a single value of one of two types (L or R).
CExceptionExt	Extension methods for exceptions.
CEzStopwatch	A wrapper around Stopwatch with a more convenient interface, currently oriented around measuring milliseconds (TODO: increase similarity to Stopwatch)
CG	Contains global functions that don't belong in any specific class.
CGSymbol	This class produces global symbols.
CHashTags< 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.
CHolder< T >	A trivial class that holds a single value of type T in the Value property.
CICloneable< out T >	Interface for types that can duplicate themselves.
CIEither< out A, out B, out C >
CIEither< out L, out R >	Represents a type that holds a single value of one of two types (L or R).
CIHasLocation
CIHasMutableValue< T >
CIHasValue< out T >
CILocation	This interface allows an object to declare its "location".
CILogMessage	A formatted message with an associated Context.
CIMaybe< out T >
CIMessageSink	Alias for IMessageSink<object>.
CIMessageSink< in TContext >	A general-purpose interface for a class that accepts formatted messages with context information.
CIMValue< T >	Interface for things that have a mutable Value property.
CInvalidStateException	An exception thrown when an object detects that its own state is invalid, or in other words, that an invariant has been violated.
CIReferenceEquatable	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.
CITags< T >	Interface for an object that can have "tags" attached, which are arbitrary objects reached through a key Symbol.
CIValue< out T >	Interface for things that have a Value property.
CLocalizableAttribute	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.
CLocalize	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
CLogException	An exception that includes a "context" object as part of a LogMessage structure, typically used to indicate where an error occurred.
CLogMessage	Holds an argument list compatible with IMessageSink{TContext}.Write(Severity,TContext,string). Typically used with MessageHolder.
CMaybe
CMaybe< 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}}.
CMemoizedTypeName	.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.
CMemoizedTypeName< T >	MemoizedTypeName<T>.Get() is an alternative to MemoizedTypeName.Get(typeof(T)).
CMessageFilter	A decorator that uses a delegate to accept or ignore messages.
CMessageHolder	A message sink that puts the messages it receives in a list.
CMessageMulticaster	Alias for MessageSplitter<object>.
CMessageMulticaster< TContext >	A message sink that sends its messages to a list of other sinks.
►CMessageSink	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.
CPushedCurrent	Returned by PushCurrent(IMessageSink).
CMessageSinkFromDelegate
CMessageSinkFromDelegate< TContext >	This helper class lets you implement IMessageSink with one or two delegates (a writer method, and an optional severity filter).
CMessageSinkWithContext	Alias for MessageSinkWithContext<object>.
CMessageSinkWithContext< 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.
CNoValue	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.
CNullMessageSink	Discards all messages. However, there is a Count property that increases by one with each message received, as well as an ErrorCount.
CPair	Pair.Create(a, b) is a helper method for making pairs.
CPair< T1, T2 >	A tuple of two values, A and B, in a struct.
CReadOnlyException	An exception thrown when an attempt is made to modify a read-only object.
CReferenceComparer< T >	An IEqualityComparer{T} based on reference equality
CServiceProvider	Adds extension methods to modernize .NET's simple built-in service locator.
CSeverityMessageFilter	Alias for SeverityMessageFilter<object>.
CSeverityMessageFilter< 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.
CStringBuilderExt	Extension methods that add some functionality of string to StringBuilder.
CStringExt	Extension methods for strings, such as SplitAt, Left, Right, FormatCore and Slice.
CSymbol	Represents a symbol, which is a singleton string that supports fast comparisons and extensible enums.
CSymbolPool	A collection of Symbols.
CSymbolPool< 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.
CSymbolSet	A set of symbols.
CTraceMessageSink	Sends all messages to System.Diagnostics.Trace.WriteLine(string).
CTraits< T >	Provides efficient access to non-numeric information about a type. For numeric traits, use Loyc.Math.Maths{T}.Traits in the Loyc.Math package.
CTriplet
CTriplet< T1, T2, T3 >	A tuple of three values (A, B and C) in a struct.
CTypeExt	Extension methods for Type.
CUString	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.
CValueComparer< 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).
Cvoid	.Value represents the sole value of System.Void (called "void" in C#).
CWeakReferenceExt	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.
CWrapperBase< T >	Abstract class that helps you implement wrappers by automatically forwarding calls to Equals(), GetHashCode() and ToString().
CDefaultSyncField< SyncManager, T >	An ISyncField{SM,T} that synchronizes via DefaultSynchronizer{SM,T}. It is used to build default synchronizers for collections (the items are synchronized recursively via their own default synchronizers) and can be used the same way in user code.
CDefaultSynchronizer	The "synchronize any T with zero configuration" dispatcher. Given a type T, Supports and Sync try to find some mechanism to serialize it.
CDefaultSynchronizer< SyncManager, T >
CDynamicSync< SM, T >	A synchronizer for dynamically-typed (polymorphic) fields: when writing, the runtime type of the value selects a synchronizer from a TypeSyncRegistry and its type tag (from a TypeTagRegistry) is recorded; when reading, the type tag read from the data stream selects the synchronizer. Being an ordinary ISyncField{SM, T}, it composes with the list/collection helpers (e.g. as the item synchronizer of a list).
CExtraSynchronizers< SyncManager >	Default synchronizers, beyond those provided by the SyncManager itself and by TupleSynchronizer{SM}, that DefaultSynchronizer{SM,T} discovers via reflection (once per closed generic pair): arrays, common collections, dictionaries, KeyValuePair, enums, DateTime and TimeSpan. Collection items are synchronized recursively via DefaultSyncField{SM,T}, so e.g. List<(int, Person[])> works as long as Person is registered in the ambient TypeSyncRegistry.
CPredefinedSynchronizer< SyncManager >	Gets synchronizer functions for types with built-in support, such as int, enums, tuples, or arrays of primitives – work in progress.
CStreamScanner	An implementation of IScanner{T} that reads from a Stream.
►CSyncBinary	f Convenience methods for a fast pair of ISyncManager implementations intended for binary files/streams. The binary format is very fast and compact because it stores no metadata, but it must be used with care to avoid data corruption (see remarks).
►COptions	Options that control general behavior of SyncBinary.Reader and SyncBinary.Writer. Note: some behaviors such as deduplication (including support for cyclic references) are controlled at the level of individual fields, and such options are not duplicated here.
CForReader
CForWriter
CReader	An implementation of ISyncManager for reading SyncLib's compact, high-performance data format. Note that while SupportsDeduplication is true, SupportsReordering and SupportsNextField are false, the binary format is not self-describing, and field names/IDs are not stored in the data stream, so you must be careful to read the data in the same order and with compatible types as what was written (for details and guidelines, see SyncBinary). Please call SyncBinary.Read or SyncBinary.ReadI if you just want to serialize something, or NewWriter to create one of these.
CWriter	The ISyncManager implementation for writing SyncLib's compact, high-performance binary data format (see SyncBinary for details and guidelines). Please call WriteI or Write if you just want to serialize something, or NewWriter to create one of these.
CSyncDynamicExt	Extension methods for dynamically-typed (polymorphic) synchronization. By default these use the ambient services TypeSyncRegistry.Default and TypeTagRegistry.Default; overloads that accept registry instances bypass the ambient services. See TypeSyncRegistry, TypeTagRegistry and TypeTagAttribute to learn how dynamic typing works.
►CSyncJson
►COptions	Options that control general behavior of SyncJson.Reader and SyncJson.Writer. Note: some behaviors such as deduplication (including support for cyclic references) are controlled at the level of individual fields, and such options are not duplicated here.
CForReader
CForWriter
CReader	An implementation of ISyncManager for reading JSON objects. Designed to be both fast and flexible, this implementation normally reads UTF8 directly into values without allocating intermediate strings, and without requiring the entire JSON file to be loaded into memory at once. SupportsReordering, SupportsDeduplication and SupportsNextField are all true, and non-strict JSON is allowed (e.g. comments are accepted but ignored, unless you turn off support in the Options.)
CSchemaWriter	An implementation of ISyncManager that produces a JSON Schema (draft 2020-12) describing the JSON that SyncJson.Writer would produce with the same synchronizer and Options — including the effects of options such as Options.NameConverter, Options.NewtonsoftCompatibility and Options.ByteArrayMode, and the "$id"/"$ref" markers used when ObjectMode.Deduplicate is used.
CWriter	An optimized implementation of ISyncManager for writing JSON objects. SupportsReordering and SupportsDeduplication are both true.
►CSyncProtobuf	Convenience methods and shared definitions for a pair of ISyncManager implementations (Reader and Writer) that read and write the Protocol Buffers wire format. Call Write{T}(T, SyncObjectFunc{Writer, T}, Options?) or Read{T}(ReadOnlyMemory{byte}, SyncObjectFunc{Reader, T}, Options?) to (de)serialize an object, NewWriter / NewReader(ReadOnlyMemory{byte}, Options?) to obtain a low-level (de)serializer, or WriteSchema{T}(SyncObjectFunc{SchemaWriter, T}, Options?) to generate a .proto schema describing the output.
►COptions	Options that control the behavior of SyncProtobuf.Reader and SyncProtobuf.Writer.
CForWriter
CReader	The ISyncManager implementation that reads the Protocol Buffers wire format (see SyncProtobuf). Because fields are keyed by integer ID, this reader supports reordering (SupportsReordering) and skips unknown fields. Call Read{T}(ReadOnlyMemory{byte}, SyncObjectFunc{Reader, T}, Options?) to deserialize, or NewReader(ReadOnlyMemory{byte}, Options?) to construct one directly.
CSchemaWriter	An implementation of ISyncManager that produces a Protocol Buffers proto3 .proto definition describing the output of SyncProtobuf.Writer.
CWriter	The ISyncManager implementation that writes the Protocol Buffers wire format (see SyncProtobuf for the format and guidelines). Call Write{T}(T, SyncObjectFunc{Writer, T}, Options?) to serialize an object, or NewWriter to construct one of these directly.
CTupleSynchronizer< SyncManager >	System.ValueTuple synchronizers - work in progress!
CTypeSyncRegistry	A registry that maps data types to synchronizers, to support dynamic typing (polymorphic serialization): writing an object whose runtime type is not known statically, and reading it back via the type tag stored in the data stream.
CTypeTagAttribute	Assigns a "type tag" to a synchronizer, which identifies the type of object it reads/writes within a data stream, enabling dynamic typing (polymorphic serialization and deserialization).
CTypeTagRegistry	The module that registers and resolves type tags: it encapsulates (1) the bidirectional dictionary between type tags and .NET types, (2) the convention by which tags are attached to synchronizers (the TypeTagAttribute), and (3) the policy for tags in a data stream that don't match anything registered or expected. All three are customizable: the dictionary via Add, and the convention and policies by overriding the virtual methods in a derived class and swapping it in with SetDefault (the Ambient Service Pattern).