Enhanced C#
Language of your choice: library documentation
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123456]
 CLoyc.Syntax.AbstractTriviaInjector< Trivia >Encapsulates an algorithm that consumes trivia (comments and newlines) from a list and adds it as trivia attributes into LNodes
 CLoyc.Syntax.AbstractTriviaInjector< Token >
 CLeMP.Tests.A.AliasTest
 CLeMP.Tests.B.AliasTest
 CLoyc.Collections.AListBase< T >Common base class of AList<T> and SparseAList<T>. Most of the functionality of the two types is identical, so this class is used to share code between them
 CLoyc.Collections.AListBase< K, T >Base class for the indexed tree-based data structures known as AList<T> and BList<T>
 CLoyc.Collections.AListBase< int, T >
 CAListBase< K, KeyValuePair< K, V >>
 CLoyc.Collections.AListBase< K, T >
 CLoyc.Collections.AListBase< T, T >
 CLoyc.Collections.AListExt
 CLoyc.Collections.Impl.AListIndexer< int, T >
 CLoyc.Collections.Impl.AListInnerBase< int, T >
 CLoyc.Collections.Impl.AListLeaf< K, T >Internal implementation class. Shared code of non-sparse AList leaf nodes
 CLoyc.Collections.Impl.AListLeaf< int, T >
 CLoyc.Collections.Impl.AListLeafBase< int, T >
 CLoyc.Collections.Impl.AListNode< K, T >Internal implementation class. Base class for tree nodes in a list class derived from AListBase<T>. These nodes basically form an in-memory B+tree, not necessarily sorted, but structured like a B+tree. That means there are two node types: leaf and inner (internal) nodes
 CLoyc.Collections.AListStatisticTracker< K, T, TSummary >This class efficiently lets you keep track of simple commutative statistics (such as total, average, sum of squares, and min/max) derived from the items of AList<T> and its variants (BList, BDictionary, and BMultiMap)
 CLoyc.Collections.AListStatisticTracker< K, T >This class incrementally updates a Statistic object based on changes to AList<T> and its variants (BList, BDictionary, and BMultiMap)
 CLoyc.Collections.AListStatisticTracker< int, T >
 CLoyc.Collections.AListStatisticTracker< K, T, double >
 CLoyc.Collections.AListStatisticTracker< K, T, TStatistic >
 CLoyc.Collections.AListStatisticTrackerBase< K, T, Statistic >
 CLoyc.Collections.AListSumTracker< K, T >This class incrementally recomputes the sum of an AList<T> (or its variants - BList, BDictionary, and BMultiMap)
 CLoyc.Collections.AListSumTracker< int, T >
 CLoyc.Collections.Impl.AListTreeObserverExtHelper methods for IAListTreeObserver<K,T>
 CLoyc.Collections.ArrayOf4< T >
 CLoyc.MiniTest.AssertThe Assert class contains a collection of static methods that mirror the most common assertions used in NUnit
 CAttribute
 CAttribute
 CLoyc.Syntax.Lexing.BaseILexer< ICharSource, Token >
 CLoyc.Syntax.BaseParser< Token, MatchType >An base class designed for parsers that use LLLPG (Loyc LL(k) Parser Generator). Note: this is the old (harder to use) base class design. You should use BaseParserForList<Token,MatchType> instead
 CLoyc.Syntax.BaseParser< Token >
 CLoyc.Syntax.BaseParser< Token, Int32 >
 CLoyc.Syntax.BaseParserForList< Token, MatchType, List >An base class designed for parsers that use LLLPG (Loyc LL(k) Parser Generator) and receive tokens from any IEnumerator<Token>. (Potentially also useful for parsers written by hand.)
 CLoyc.Syntax.BaseParserForList< Token, int >
 CBaseParserForList< Token, MatchType, IList< Token >>
 CLoyc.Syntax.BaseParserNoBacktracking< Token, Enumerator >An base class designed for parsers that use LLLPG (Loyc LL(k) Parser Generator) and receive tokens from any IEnumerator<Token>
 CBaseParserNoBacktracking< Token, IEnumerator< Token >>
 CLoyc.Collections.BDictionary< int, Loyc.Pair< int, string > >
 CLoyc.Collections.Bijection< K2, K1 >
 CBList< KeyValuePair< K, V >>
 CLoyc.Utilities.BloomFilterM64K2A bloom filter for very small sets
 CLoyc.Collections.BMultiMap< Loyc.Collections.Impl.AListNode< K, T >, Loyc.Collections.Impl.AListInnerBase< K, T > >
 CLoyc.Collections.BMultiMap< T, Loyc.Collections.Impl.AListLeafBase< K, T > >
 CLeMP.Prelude.BuiltinMacrosDefines noMacro(...) for suppressing macro expansion and import macros your.namespace.name as an alias for #importMacros(your.namespace.name)
 CLoyc.ByteArrayInStringEncodes and decodes BAIS (Byte Array In String) encoding, which preserves runs of ASCII characters unchanged. This encoding is useful for debugging (since ASCII runs are visible) and for conversion of bytes to JSON
 CLoyc.Collections.CGContains global functions of Loyc.Collections that don't belong in any specific class
 CLoyc.Syntax.Lexing.CharCategory
 CLoyc.CheckParamHelper methods for checking argument values that throw exceptions when an argument value is not acceptable
 CLoyc.Syntax.Impl.PrinterState.Checkpoint
 CLoyc.Syntax.CodeSymbolsA list of common symbols that, by convention, have special meaning: operators, built-in data types, keywords, trivia, etc
 CLoyc.Collections.CollectionDebugView< T >This helper class gives a nice view of a custom collection within the debugger
 CLoyc.Collections.CollectionSource
 CCollectionWithChangeEvents< T, ICollection< T >>
 CLoyc.Collections.Impl.CollectionWrapper< KeyValuePair< K, V >, TDictionary >
 CLoyc.Collections.Impl.CollectionWrapper< T, TColl >
 CLoyc.Collections.Impl.CollectionWrapper< T, TList >
 CLeMP.CompilerA class that helps you invoke MacroProcessor on on a set of source files, given a set of command-line options
 CLoyc.Collections.Impl.CPEnumerator< TValue >
 CLoyc.Collections.CPTrie< T >Compact patricia tree class that stores keys as byte arrays. This class is intended to be use as a base class; a derived class can give meaning to the byte arrays, e.g. CPStringTrie encodes strings into byte arrays so they can be placed in the trie
 CLoyc.Collections.CPTrie< TValue >
 CLoyc.Collections.Impl.DictionaryBase< K, V >
 CLoyc.Collections.DictionaryDebugView< K, V >Workaround for a limitation of the debugger: it doesn't support CollectionDebugView<T> when T is KeyValuePair<K,V>. This class is identical, except that T is replaced with KeyValuePair{K,V}
 CLoyc.Collections.DictionaryExtExtension methods for Dictionary<K,V>, IDictionary<K,V> and IDictionaryEx<K, V>
 CDictionaryWithChangeEvents< K, V, IDictionary< K, V >>
 CLoyc.Ecs.EcsNodePrinterEncapsulates the code for printing an LNode to EC# source code
 CLoyc.Ecs.EcsPrecedenceContains Precedence objects that represent the precedence rules of EC#
 CLoyc.Ecs.EcsValidatorsA class filled with methods for checking whether a node has the correct LNode.Name and structure. For example, IsPropertyDefinition(node) checks whether node meets the requirements for being a property definition, such as having a Name equal to #property, and having name and return value that are complex identifiers
 CLoyc.Collections.EmptyArray< T >EmptyArray<T>.Value lets you avoid allocating an empty array on the heap
 CLoyc.Collections.EmptyList< T >Helper class: EmptyList<T>.Value is a read-only empty list
 CLoyc.Collections.EnumerableExtAdditional extension methods for IEnumerable<T>, IReadOnlyCollection<T>, and ICollection<T>, beyond what LINQ provides
 CLoyc.Compatibility.EnumStaticImplements Enum.TryParse in .NET 3.5
 CEqualityComparer
 CEventArgs
 CException
 CLoyc.ExceptionExtExtension methods for exceptions
 CLoyc.EzStopwatchA wrapper around Stopwatch with a more convenient interface, currently oriented around measuring milliseconds (TODO: increase similarity to Stopwatch)
 CLoyc.GContains global functions that don't belong in any specific class
 CLoyc.Utilities.GoInterfaceMainly for internal use by the other GoInterface classes
 CLoyc.Utilities.GoInterface< Interface >GoInterface<Interface> creates wrappers around objects of your choosing that implement the specified Interface, forwarding calls to methods in the wrapped object. It is inspired by the duck-typed interfaces in the Go programming language
 CLoyc.Utilities.GoInterface< Interface, T >GoInterface<Interface,T> creates a wrapper that implements the specified Interface, forwarding calls to methods in T. It is inspired by the duck-typed interfaces in the Go programming language
 CLoyc.GSymbolThis class produces global symbols
 CLoyc.Collections.Heap
 CLoyc.Collections.IAdd< in in T >An interface for depositing items. Includes only an Add(T) method
 CLoyc.Collections.IAdd< T >
 CIAddRange< KeyValuePair< K, V >>
 CLoyc.Collections.IAddRange< T >
 CLoyc.Collections.Impl.IAListTreeObserver< K, T >An interface that is called to notify observers when items or nodes in the tree of a class derived from AListBase<K,T> (e.g. AList or BList) are added or removed
 CLoyc.Collections.Impl.IAListTreeObserver< int, T >
 CLoyc.Collections.IArraySink< in in T >Represents a write-only array
 CLoyc.Collections.IArraySink< T >
 CLoyc.Collections.IAutoCreatePool< UString, Symbol >
 CLoyc.Collections.IBinumerable< T >Interface for a collection that can return IBinumerator<T>s pointing to the beginning and end of the collection
 CLoyc.Collections.IBRange< char >
 CLoyc.Collections.IBRange< T >
 CLoyc.Collections.IBRange< uchar >
 CLoyc.Collections.IBRangeEx< R, T >A bidirectional range that can perform operations such as intersection and overlap tests on pairs of ranges of the same type
 CLoyc.Collections.IBRangeEx< IBRangeEx< T >, T >
 CLoyc.ICloneable< out out T >Interface for types that can duplicate themselves
 CICloneable< AList< T >>
 CICloneable< AListBase< T >>
 CICloneable< ArraySlice< T >>
 CICloneable< BDictionary< K, V >>
 CICloneable< BList< T >>
 CLoyc.ICloneable< DescendantsFrame >
 CICloneable< DList< T >>
 CICloneable< FVList< T >>
 CICloneable< FWList< T >>
 CICloneable< IBRange< T >>
 CICloneable< IBRangeEx< T >>
 CICloneable< IDictionaryEx< K, V >>
 CICloneable< IFRange< T >>
 CICloneable< InternalDList< T >>
 CICloneable< InternalList< T >>
 CICloneable< IRange< T >>
 CICloneable< IRangeEx< T >>
 CICloneable< IToken< TT >>
 CLoyc.ICloneable< Les2Lexer >
 CICloneable< ListSlice< T >>
 CLoyc.ICloneable< LNode >
 CLoyc.ICloneable< LNodeList >
 CLoyc.ICloneable< MessageHolder >
 CICloneable< MMap< K, V >>
 CICloneable< MSet< T >>
 CICloneable< NegListSlice< T >>
 CLoyc.ICloneable< Pred >
 CICloneable< ROLSlice< TList, T >>
 CLoyc.ICloneable< Scope >
 CICloneable< Slice_< T >>
 CICloneable< SparseAList< T >>
 CLoyc.ICloneable< TokenTree >
 CLoyc.ICloneable< Transition >
 CLoyc.ICloneable< UString >
 CICloneable< VList< T >>
 CICloneable< WeakValueDictionary< K, V >>
 CICloneable< WList< T >>
 CICollection
 CICollection< KeyValuePair< K, V >>
 CLoyc.Collections.ICollectionAndReadOnly< TKey >
 CLoyc.Collections.ICollectionAndReadOnly< TValue >
 CICollectionEx< KeyValuePair< K, V >>
 CLoyc.Collections.MutableListExtensionMethods.ICollectionExtExtension methods for ICollection<T>
 CLoyc.Collections.ICollectionSink< T >
 CIComparable
 CIComparable< Pair< T1, T2 >>
 CIComparer
 CLoyc.Collections.IContains< in in T >
 CLoyc.Collections.IContains< T >
 CLoyc.Math.IConvertTo< T >Provides methods for converting common numeric types to another numeric type "T"
 CIDictionary
 CLoyc.Collections.IDictionaryAndReadOnly< TKey, TValue >
 CLoyc.Collections.IDictionaryImpl< K1, K2 >
 CLoyc.Collections.IDictionarySink< in in K, in in V >Represents a write-only dictionary class
 CLoyc.Collections.IDictionarySink< K, V >
 CIDisposable
 CLoyc.IEither< out out L, out out R >Represents a type that holds a single value of one of two types (L or R)
 CLoyc.IEither< L, R >
 CIEnumerable
 CIEnumerator
 CIEnumerator< KeyValuePair< byte[], TValue >>
 CIEnumerator< KeyValuePair< int, TValue >>
 CIEnumerator< KeyValuePair< long, TValue >>
 CIEnumerator< KeyValuePair< string, TValue >>
 CLoyc.Collections.Impl.IEnumeratorFrame< Frame, T >Helper interface for NestedEnumerator<Frame, T>
 CLoyc.Collections.Impl.IEnumeratorFrame< DescendantsFrame, LNode >
 CLoyc.Collections.Impl.IEnumeratorFrame< EnumeratorFrame< T >, T >
 CIEqualityComparer
 CIEqualityComparer< KeyValuePair< K, V >>
 CIEquatable
 CIEquatable< InvertibleSet< T >>
 CIEquatable< MSet< T >>
 CIEquatable< NegList< T >>
 CIEquatable< NegListSource< T >>
 CIEquatable< Pair< T1, T2 >>
 CIEquatable< ReversedList< T >>
 CIEquatable< Set< T >>
 CLoyc.Math.IExp< T >Provides power, logarithm, raise-e-to-exponent (Exp) and logarithm-of-e (Log) operations
 CLoyc.Collections.IFRange< char >
 CLoyc.Collections.IFRange< T >
 CLoyc.Utilities.IGoInterfaceWrapperAll GoInterface wrappers implement this interface
 CLoyc.Syntax.IHasFileName
 CLoyc.IHasLocationThis interface allows an object to declare its "location"
 CLoyc.Math.IHasRoot< T >Provides the Sqrt operation and its inverse, Square
 CLoyc.IHasValue< out out T >Interface for things that have a Value property
 CLoyc.IHasValue< object >
 CLoyc.IHasValue< T >
 CLoyc.IHasValue< T2 >
 CLoyc.Math.IIncrementer< T >Provides increment, decrement, and next/previous-representable- value operations
 CLoyc.Collections.IIndexed< in in K, out out V >Represents the essence of a dictionary, which returns a value given a key
 CLoyc.Collections.IIndexed< byte[], TValue >
 CLoyc.Collections.IIndexed< int, T >
 CLoyc.Collections.IIndexed< int, TValue >
 CLoyc.Collections.IIndexed< K, BMultiMap< K, V >.ValueList >
 CLoyc.Collections.IIndexed< K, V >
 CLoyc.Collections.IIndexed< long, TValue >
 CLoyc.Collections.IIndexed< string, TValue >
 CLoyc.Collections.IIsEmptyHolds the IsEmpty property that tells you if a collection is empty
 CLoyc.Syntax.ILineAndColumnA line/column pair representing a location in a text file. Numbering starts at one for both Line and Column
 CIList
 CLoyc.Collections.IListAndListSource< LNode >
 CLoyc.Collections.MutableListExtensionMethods.IListExtExtension methods and helper methods for IList<T>
 CLoyc.Collections.IListRangeMethods< T >
 CLoyc.Collections.IListSink< T >
 CLoyc.Collections.IListSource< char >
 CLoyc.Collections.IListSource< IntRange >
 CIListSource< IToken< int >>
 CLoyc.Collections.IListSource< LNode >
 CLoyc.Collections.IListSource< T >
 CLoyc.Collections.IListSource< Token >
 CLoyc.Syntax.ILiteralParserThis interface for parsing text into objects is implemented by LiteralHandlerTable
 CLoyc.Syntax.ILiteralPrinterThis interface for converting literals to text is implemented by LiteralHandlerTable
 CLoyc.Syntax.ILiteralValueProviderThe intention of this interface is that a struct implementing it can be embedded inside a LiteralNode in order to lazily obtain the text of a literal, or even parse it lazily
 CLoyc.Syntax.Lexing.ILllpgApi< Token, MatchType, LaType >For reference purposes, this interface is a list of the non-static methods that LLLPG expects to be able to call when it is generating code. LLLPG does not actually need lexers and parsers to implement this interface; they simply need to implement the same set of methods as this interface contains
 CLoyc.Syntax.Lexing.ILllpgApi< Token, int, int >
 CLoyc.Syntax.Lexing.ILllpgApi< Token, MatchType, MatchType >
 CLoyc.Syntax.Lexing.ILllpgLexerApi< int >
 CLoyc.Syntax.ILNodePrinterThis interface allows serializing LNode objects into the syntax of a particular programming language
 CLoyc.Syntax.ILNodePrinterOptionsA set of relatively universal printing options that LNodePrinters should understand
 CLoyc.Syntax.ILNodeVisitorInterface for people that want to implement the visitor pattern with LNode. If your visitor does not need a base class, use LNodeVisitor as the base class
 CLoyc.ILogMessageA formatted message with an associated Context
 CLoyc.IMaybe< L >
 CLoyc.IMaybe< R >
 CLoyc.IMaybe< T >
 CLoyc.IMessageSink< in in TContext >A general-purpose interface for a class that accepts formatted messages with context information
 CLoyc.IMessageSink< Loyc.Syntax.LNode >
 CLoyc.IMessageSink< TContext >
 CLoyc.Collections.INegListSource< ILNode >
 CLoyc.Collections.INegListSource< LNode >
 CLoyc.Collections.INegListSource< T >
 CLoyc.Geometry.INewPoint< Point, T >This interface exists to work around a limitation of C#; see IPoint<T>
 CLoyc.Geometry.INewPoint3< Point, T >This interface exists to work around a limitation of C#; see IPoint<T> and IPoint3<T>
 CLoyc.Geometry.INewPoint3< IPoint3< T >, T >
 CLoyc.Geometry.INewPoint< IPoint< T >, T >
 CLoyc.Geometry.INewRectangle< Rect, T >This interface exists to work around a limitation of C#; see IRectangle<T>
 CLoyc.Geometry.INewRectangle3< Rect, T >This interface exists to work around a limitation of C#; see IRectangle3<T>
 CLoyc.Geometry.INewRectangle3< IRectangle< T >, T >
 CLoyc.Geometry.INewRectangle< IRectangle< T >, T >
 CLoyc.Syntax.Les.INodePrinterWriterThis interface is implemented by helper objects that handle the low-level details of node printing. It is used by Les2Printer
 CLoyc.Collections.INotifyListChanged< T, TCollection >Encapsulates a ListChanged event that notifies listeners that a list has changed, such as when items are added or removed or the whole list is refreshed
 CINotifyListChanged< KeyValuePair< K, V >, IDictionary< K, V >>
 CLoyc.Collections.INotifyListChanged< T >
 CINotifyListChanged< T, ICollection< T >>
 CINotifyListChanged< T, IListSource< T >>
 CLoyc.Collections.INotifyListChanging< T, TCollection >Encapsulates the ListChanging event that notifies listeners of dynamic changes to a collection, such as when items are about to be added and removed or the whole list is about to be refreshed
 CINotifyListChanging< KeyValuePair< K, V >, IDictionary< K, V >>
 CLoyc.Collections.INotifyListChanging< T >
 CINotifyListChanging< T, ICollection< T >>
 CINotifyListChanging< T, IListSource< T >>
 CLeMP.InputOutputFor LeMP: an input file plus per-file options (input and output language) and output code
 CLoyc.Collections.Impl.InternalDList< Loyc.Syntax.Lexing.Token >
 CLoyc.Collections.Impl.InternalDList< Token >
 CLoyc.Collections.Impl.InternalList< Division >
 CLoyc.Collections.Impl.InternalList< Entry >
 CLoyc.Collections.Impl.InternalList< Frame >
 CLoyc.Collections.Impl.InternalList< int >
 CLoyc.Collections.Impl.InternalList< Loyc.Collections.Impl.IAListTreeObserver< K, T > >
 CLoyc.Collections.Impl.InternalList< Loyc.LLParserGenerator.IntRange >
 CLoyc.Collections.Impl.InternalList< Loyc.Symbol >
 CLoyc.Collections.Impl.InternalList< MacroResult >
 CLoyc.Collections.Impl.InternalList< Node >
 CLoyc.Collections.Impl.InternalList< PredictionBranch >
 CLoyc.Collections.Impl.InternalList< Revokable >
 CLoyc.Collections.Impl.InternalList< Scope >
 CLoyc.Collections.Impl.InternalList< Symbol >
 CLoyc.Collections.Impl.InternalList< TokenType >
 CLoyc.Collections.Impl.InternalSet< KeyValuePair< K, V > >
 CLoyc.Collections.Impl.InternalSetStatsStatistics returned from InternalSet<T>.CountMemory
 CInvalidOperationException
 CLoyc.Collections.InvertibleSet< LNode >
 CLoyc.Collections.InvertibleSet< string >
 CLoyc.Math.IOneProvider< T >Provides the value of "one" for type T
 CLoyc.Collections.IOptimizeInterface for an Optimize() method
 CLoyc.Math.IOrderedExtExtension methods for IOrdered<T>
 CLoyc.Syntax.IParsingOptionsA set of relatively universal parsing options that IParsingServices should understand
 CLoyc.Syntax.IParsingServiceAn interface that encapsulates the lexer and parser of a programming language, or a non-programming language that can be represented by Loyc trees
 CLoyc.LLParserGenerator.IPGCodeGenHelperA class that implements this interface will generate small bits of code that the parser generator will use. The default implementation is IntStreamCodeGenHelper. To install a new code generator, set the LLParserGenerator.CodeGenHelper property or supply the generator in the constructor of LLParserGenerator
 CLoyc.Geometry.IPointReader< T >Interface for reading the coordinates of a 2D point
 CLoyc.Collections.IPop< out out T >Represents a collection that produces a sequence of items, and can return the next item without popping it (the Peek operation)
 CLoyc.Collections.IPop< T >
 CLoyc.Collections.IPopExt
 CLoyc.Collections.IPush< in in T >Represents a collection that accepts a sequence of items
 CLoyc.Collections.IPush< T >
 CLoyc.Collections.IRange< char >
 CLoyc.Collections.IRange< T >
 CLoyc.Collections.IRangeEx< R, T >A random-access range that can perform operations such as intersection and overlap tests on pairs of ranges of the same type
 CLoyc.Collections.IRangeEx< IRangeEx< T >, T >
 CIReadOnlyCollection
 CIReadOnlyCollection< KeyValuePair< K, V >>
 CIReadOnlyDictionary
 CIReadOnlyList
 CLoyc.IReferenceEquatableThis 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
 CISet
 CLoyc.Collections.ISetImm< T, SetT >An immutable set of type SetT with elements of type T
 CLoyc.Collections.ISetImm< T >
 CISetImm< T, InvertibleSet< T >>
 CISetImm< T, MSet< T >>
 CISetImm< T, Set< T >>
 CLoyc.Collections.ISetOperations< in in T, SetT >Set-combining operations: With, Without, Union, Intersect, Except, Xor
 CISetOperations< KeyValuePair< K, V >, MapOrMMap< K, V >, Map< K, V >>
 CISetOperations< KeyValuePair< K, V >, MapOrMMap< K, V >, MMap< K, V >>
 CISetOperations< T, IEnumerable< T >, ISetImm< T >>
 CLoyc.Collections.ISetOperations< T, SetT >
 CLoyc.Collections.ISetOperations< T, SetT, SetT >
 CLoyc.Collections.ISetTests< SetT >Set testing operations
 CISetTests< IEnumerable< T >>
 CLoyc.Syntax.Lexing.ISimpleToken< int >
 CLoyc.Syntax.Lexing.ISimpleToken< TT >
 CLoyc.Geometry.ISizeReader< T >Interface for reading the size of a 2D object
 CLoyc.Syntax.ISourceRangeRepresents a (contiguous) region of text in a source file
 CLoyc.ITags< T >Interface for an object that can have "tags" attached, which are arbitrary objects reached through a key Symbol
 CLoyc.ITags< ValueT >
 CLoyc.Syntax.Lexing.IToken< int >
 CLoyc.Math.ITrigonometry< T >Provides trigonometry operations
 CLoyc.Collections.ITryGet< in in K, out out V >Enables access to TryGet extension methods for retrieving items from a collection without risk of exceptions
 CLoyc.Collections.ITryGet< int, T >
 CLoyc.Collections.ITryGet< K, V >
 CLoyc.Syntax.IUninterpretedLiteralRepresents the text form of a literal value, without its parsed value
 CLoyc.Math.IZeroProvider< T >Provides the value of "zero" for type T
 CLoyc.Collections.Impl.KeylessHashtable< T >A fairly obscure space-saving hashtable that offers no built-in way to store keys, only values. Because there are no keys, the hashtable cannot be rehashed when it is full, and searching for a given key finds all values in the same bucket, some of which may be unrelated
 CLoyc.Collections.Impl.KeyWalkerInternal implementation class. Represents a pointer to a location within a byte array
 CLoyc.LLParserGenerator.LLParserGenerator.KthSetHolds information about the first set or kth set of a single arm of an Alts
 CLoyc.Collections.MutableListExtensionMethods.LCExt
 CLoyc.Collections.LCExtExtension methods for Loyc Collection interfaces (such as IListSource<T>)
 CLoyc.Collections.LCInterfacesExtension methods for Loyc collection interfaces
 CLoyc.Syntax.Les.Les2PrecedenceMapThis class's main job is to maintain a table of Precedence values for LES operators. When you ask about a new operator, its precedence is chosen by this class and cached for future reference
 CLoyc.Syntax.Les.Les2PrinterPrints a Loyc tree in LES (Loyc Expression Syntax) format
 CLoyc.Syntax.Les.Les3Printer
 CLoyc.Syntax.Les.LesPrecedenceContains Precedence objects that represent the precedence levels of LES
 CLoyc.Syntax.Lexing.LexerSource< Loyc.UString >
 CLoyc.Syntax.Lexing.LexerSourceFile< CharSrc >
 CLoyc.Syntax.LineRemapperA small helper class for languages such as C# and C++ that permit the locations reported by error messages to be remapped. This class stores and applies such commands (#line in C#/C++)
 CLoyc.Collections.MutableListExtensionMethods.LinqToLists
 CLoyc.Collections.LinqToListsThis class enhances LINQ-to-Objects with extension methods that preserve the interface (e.g. Take(IList<int>) returns a struct that implements IList<int>) or have higher performance than the ones in System.Linq.Enumerable
 CLoyc.Collections.ListChangeInfo< T >Contains information about how a collection is about to change
 CLoyc.Collections.ListExtExtension methods and helper methods for List<T>, IList<T>, IReadOnlyList<T>, arrays, IListSource<T>, and for related mutable interfaces such as IArray<T>
 CLoyc.Collections.ListSlice< LogMessage >
 CLoyc.Collections.Impl.ListSourceBase< char >
 CLoyc.Collections.Impl.ListSourceBase< TOut >
 CLoyc.Collections.Impl.ListSourceBase< TResult >
 CLoyc.Collections.ListSourceDebugView< T >This helper class gives a nice view of a custom collection within the debugger
 CListWithChangeEvents< T, IList< T >>
 CLoyc.LLParserGenerator.LLParserGeneratorEncapsulates LLLPG, the Loyc LL Parser Generator, which generates LL(k) recursive-descent parsers
 CLoyc.LLParserGenerator.LlpgGeneralTestsBaseShared base class for "full-stack" LLLPG tests that use LeMP, the Ecs parser, and LLLPG macros in addition to the core engine
 CLoyc.LLParserGenerator.LlpgHelpersHelper methods for making LLLPG grammar nodes. Used by LlpgCoreTests
 CLoyc.Syntax.LNodeExtStandard extension methods for LNode
 CLoyc.Syntax.LNodeFactoryContains helper methods for creating LNodes. An LNodeFactory holds a reference to the current source file (File) so that it does not need to be repeated every time you create a node
 CLoyc.Syntax.LNodePrinterStandard extension methods for ILNodePrinter
 CLoyc.LocalizeLocalize is a global hook into which a string-mapping localizer can be installed. It makes your program localization-ready with no effort. See article: http://core.loyc.net/essentials/localize.html
 CLeMP.MacroContextStandard extension methods for IMacroContext
 CLeMP.MacroProcessorEncapsulates the LeMP engine, a simple LISP-style macro processor, suitable for running LLLPG and other lexical macros
 CLoyc.LLPG.MacrosMacros for using LLLPG in LeMP
 CLeMP.Tests.MacroTesterBase
 CLoyc.Collections.Map< object, Loyc.Syntax.Precedence >
 CLoyc.Collections.Map< string, Loyc.Syntax.IParsingService >
 CLoyc.Collections.MaxHeap< T, TList, TComparer >Encapsulates algorithms for a max-heap, i.e. a priority queue that always knows the largest item and can remove it in O(log Count) time, or add a new item in O(log Count) time
 CMaxHeap< T, IList< T >, IComparer< T >>
 CMaxHeap< T, InternalList< T >, IComparer< T >>
 CMaxHeap< T, TList, ReverseComparer< T, TComparer >>
 CLoyc.Maybe
 CLoyc.Maybe< L >
 CLoyc.Maybe< Loyc.Syntax.Lexing.Token >
 CLoyc.Maybe< R >
 CLoyc.Maybe< Token >
 CLoyc.MemoizedTypeName.NET Framework reflection doesn't offer complete type names for generic types such as "List&lt;int>" (the Type.Name value of that class is "List`1"). Get fills in the gap, and also saves the computed name for fast repeated lookups
 CLoyc.MemoizedTypeName< T >MemoizedTypeName<T>.Get() is an alternative to MemoizedTypeName.Get(typeof(T))
 CLoyc.MessageSinkKeeps track of the default message sink (Default); contains a series of helper methods; and contains extension methods modeled after log4net: Fatal, Error, Warn, Info, Debug
 CLoyc.Collections.MinHeap< T, TList, TComparer >Encapsulates algorithms for a min-heap, i.e. a priority queue that always knows the smallest item and can remove it in O(log Count) time, or add a new item in O(log Count) time
 CMinHeap< T, IList< T >, IComparer< T >>
 CMinHeap< T, InternalList< T >, IComparer< T >>
 CLoyc.Collections.MMap< object, object >
 CLoyc.Collections.MMap< string, Pair< string, string > >
 CLoyc.Collections.MMap< Symbol, InternalList< InternalMacroInfo > >
 CLoyc.Collections.MSet< int >
 CLoyc.Collections.MSet< Loyc.LLParserGenerator.AndPred >
 CLoyc.Collections.MSet< Loyc.LLParserGenerator.Pred >
 CLoyc.Collections.MSet< Loyc.Symbol >
 CLoyc.Collections.MSet< Symbol >
 CLoyc.NoValueNoValue.Value is meant to be used as the value of a property that has "no value", meaning no value is assigned or that the property is meaningless at the current time or in the current context
 CLoyc.PairPair.Create(a, b) is a helper method for making pairs
 CLoyc.Pair< Loyc.Collections.Impl.AListInnerBase< K, T >, int >
 CLoyc.Pair< Loyc.Collections.MMap< object, Loyc.Syntax.Precedence >, Loyc.Syntax.Precedence >
 CLoyc.Syntax.ParseHelpersStatic methods that help with common parsing jobs, such as parsing integers, floats, and strings with C escape sequences
 CLoyc.Syntax.ParserSource< Token, MatchType, List >An implementation of the LLLPG Parser API, used with the LLLPG options inputSource and inputClass
 CLoyc.Syntax.ParserSource< Token, MatchType >Alias for ParserSource{Token, int, IList{Token}}
 CLoyc.Syntax.ParserSource< Token, int >
 CParserSource< Token, MatchType, IList< Token >>
 CLoyc.Syntax.ParsingServiceStandard extension methods for IParsingService
 CLoyc.LLParserGenerator.PGTerminalSetExtension methods for IPGTerminalSet
 CLoyc.LLParserGenerator.PredVisitorBase class for implementing a visitor that examines a tree of LLLPG Predicates
 CLeMP.Tests.PreludeMacroTests_Les2
 CLeMP.Tests.PreludeMacroTests_Les3
 CLoyc.Syntax.Impl.PrinterStateA helper type for printer objects. Its primary purposes are to manage indentation and to "revoke" newlines; it also tracks the current line/column number
 CLoyc.Syntax.PrintHelpersStatic methods that help to print literals, such as EscapeCStyle which escapes special characters with backslashes
 CLoyc.LLParserGenerator.ProgramEntry point of LLLPG.exe, with QuickRun() method to help invoke LLLPG programmatically
 CLoyc.Collections.RangeEnumerator< R, T >Helper struct: enumerates through a forward range (IFRange<T>), calling the range methods through R instead of through IFRange<T>
 CLoyc.Collections.RangeExtExtension/helper methods for ranges
 CLoyc.Collections.Impl.ReadOnlyCollectionBase< TOut >
 CLoyc.Collections.Impl.ReadOnlyCollectionBase< TResult >
 CLoyc.Collections.ReverseComparer< T >Reverses the order used by an IComparer object
 CLoyc.LLParserGenerator.RuleRepresents an LLLPG rule, which is a Predicate plus a Name and optional attributes (e.g. token, private, etc.)
 CLoyc.MiniTest.RunTestsSearches for test methods and runs them, printing the name of each test to the console followed by errors (if any) produced by the test
 CLoyc.Collections.Impl.SCellStandard cell, used to encode keys in a CPSNode
 CLoyc.Threading.ScratchBuffer< byte[]>
 CLoyc.Threading.ScratchBuffer< object[]>
 CLoyc.Collections.SelectList< T[], T, TResult >
 CLoyc.ServiceProviderAdds extension methods to modernize .NET's simple built-in service locator
 CLoyc.Collections.Set< Loyc.LLParserGenerator.AndPred >
 CLoyc.Collections.SimpleCache< T >A cache designed to save memory by sharing instances of identical strings and other immutable objects
 CLoyc.Collections.SimpleCache< object >
 CLoyc.Utilities.SimpleTimerA fast, simple timer class with a more convenient interface than System.Diagnostics.Stopwatch. Its resolution is typically 10-16 ms on desktop Windows systems
 CLoyc.Syntax.SourcePosIsObsoleteThis just helps end-users to discover the name change SourcePos.PosInLine => ILineAndColumn.Column during upgrades
 CLoyc.Syntax.SourceRangeExtStandard extension methods for ISourceRange
 CLoyc.Utilities.StatisticA lightweight class to help you compute the minimum, maximum, average and standard deviation of a set of values. Call Clear(), then Add(each value); you can compute the average and standard deviation at any time by calling Avg() and StdDeviation()
 CLoyc.StringBuilderExtExtension methods that add some functionality of string to StringBuilder
 CLoyc.StringExtExtension methods for strings, such as SplitAt, Left, Right, FormatCore and Slice
 CLoyc.SymbolPoolA collection of Symbols
 CLoyc.SymbolPool< Loyc.Syntax.ParsingMode >
 CLoyc.Ecs.Parser.EcsParser.TentativeResult
 CLoyc.Ecs.Parser.EcsParser.TentativeState
 CLeMP.Tests.TestMacros
 CLoyc.Threading.ThreadExCreates and controls a thread, and fills in a gap in the .NET framework by propagating thread-local variables from parent to child threads, and by providing a ThreadStarting event
 CLoyc.Threading.ThreadLocalVariable< Func< Loyc.Syntax.Lexing.Token, Loyc.Collections.ICharSource, string > >
 CLoyc.Threading.ThreadLocalVariable< Func< object, string > >
 CLoyc.Threading.ThreadLocalVariable< Loyc.IMessageSink >
 CLoyc.Threading.ThreadLocalVariable< Loyc.Syntax.ILNodePrinter >
 CLoyc.Threading.ThreadLocalVariable< Loyc.Syntax.IParsingService >
 CLoyc.Threading.ThreadLocalVariable< StopTestDelegate >
 CLoyc.Threading.ThreadLocalVariableBaseWhen used with ThreadEx, implementing this base class allows you to be notified when a child thread is created or terminates
 CLoyc.Threading.TinyReaderWriterLockA fast, tiny 4-byte lock to support multiple readers or a single writer. Designed for low-contention, high-performance scenarios where reading is common and writing is rare
 CLoyc.Ecs.Parser.TokenExtProvides the Type() extension method required by Token and the ToString(Token) method to express an EC# token as a string, for tokens that contain sufficient information to do so
 CLoyc.Syntax.Les.TokenExtProvides the Type() extension method required by Token and the ToString(Token) method to express an LES token as a string, for tokens that contain sufficient information to do so
 CLoyc.Triplet< T1, T2, T3 >A tuple of three values (A, B and C) in a struct
 CLoyc.Triplet
 CLoyc.Collections.TryGetExtStandard extension methods for ITryGet<K, V>
 CLoyc.TypeExtExtension methods for Type
 CLoyc.Utilities.UGContains global functions of Loyc.Utilities that don't belong in any specific class
 CLoyc.ValueComparer< T >You'd think the .NET framework would have a built-in method–even a CIL opcode–to bitwise-compare two values. Not supporting bitwise compare is, in my opinion, one of several mind-bogglingly dumb decisions in the CLR. Instead, all you can do is call ValueComparer.Default.Equals(a, b)
 CLoyc.Collections.VList< Loyc.LLParserGenerator.AndPred >
 CLoyc.Collections.VList< Loyc.Syntax.LNode >
 CLoyc.Collections.VListBlock< T >VListBlock implements the core functionality of FVList, VList, FWList and WList. It is not intended to be used directly
 CLoyc.void@void.Value represents the sole value of System.Void (called "void" in C#)
 CLoyc.Collections.WeakKeyComparer< TKey >
 CWeakReference
 CLoyc.WeakReferenceExtThe new WeakReference<T> type in .NET 4.5 removes the Target and IsAlive properties. These extension methods restore that traditional functionality, making it easier to transition from the old WeakReference to the new one
 CLoyc.Collections.WeakValueDictionary< Loyc.UString, Loyc.Symbol >
 CLoyc.Syntax.Lexing.WhitespaceTagWhitespaceTag.Value can be used as the Token.Value of whitespace tokens, to make whitespace easy to filter out
 CLoyc.Collections.WList< LNode >
 CLoyc.Collections.WList< Loyc.Syntax.LNode >
 CLoyc.Collections.WListProtected< T >WList implementation in which the WList operations are only accessible to a derived class
 CWListProtected< KeyValuePair< Symbol, ValueT >>
 CLoyc.WrapperBase< T >Abstract class that helps you implement wrappers by automatically forwarding calls to Equals(), GetHashCode() and ToString()
 CWrapperBase< ICollection< T >>
 CWrapperBase< IList< T >>
 CWrapperBase< IListSource< T >>
 CWrapperBase< IReadOnlyCollection< T >>
 CWrapperBase< IReadOnlyList< T >>
 CLoyc.WrapperBase< ISourceFile >
 CLoyc.WrapperBase< TCollection >
 CLoyc.WrapperBase< TSet >