Represents a token that indicates execution on any of several potential user threads calling the F# compiler services.

Represents a synchronous, cold-start, cancellable computation with explicit representation of a cancelled result. A cancellable computation may be cancelled via a CancellationToken, which is propagated implicitly. If cancellation occurs, it is propagated as data rather than by raising an OperationCanceledException.

 Represents a token that indicates execution on the compilation thread, i.e.
   - we have full access to the (partially mutable) TAST and TcImports data structures
   - compiler execution may result in type provider invocations when resolving types and members
   - we can access various caches in the SourceCodeServices

 Like other execution tokens this should be passed via argument passing and not captured/stored beyond
 the lifetime of stack-based calls. This is not checked, it is a discipline within the compiler code.

Represents a permission active at this point in execution

Interface that defines methods for comparing objects using partial equality relation

Interface that defines methods for comparing objects using partial equality relation

Immutable map collection, with explicit flattening to a backing dictionary

Just like "Lazy" but EVERY forcer must provide an instance of "ctxt", e.g. to help track errors on forcing back to at least one sensible user location

Encapsulates a lock associated with a particular token-type representing the acquisition of that lock.

A base type for various types of tokens that must be passed when a lock is taken. Each different static lock should declare a new subtype of this type.

Memoize tables (all entries cached, never collected unless whole table is collected)

A thread-safe lookup table which is assigning an auto-increment stamp with each insert

Intern tables to save space.

Generates unique stamps