Adaptive functions for handling directories.

Adaptive functions for handling files.

Core implementation of IAdaptiveObject containing tools for evaluation and locking

Functional operators for AdaptiveReduction.

AdaptiveReduction holds operators for reducing collections adaptively. Its main purpose is to simplify reductions on ASet/AMap/AList.

A SynchronizationContext properly handling FSharp.Data.Adaptive's internal ThreadLocals in presense of WPF/WinForms-style lock-interception (code being executed on the main thread while locks contend). Due to our use of thread-locals/statics this interception breaks some of the system's internal state and AdaptiveSynchronizationContext.Install() can be used to prevent this.

AdaptiveToken represents a token that can be passed to inner AdaptiveObjects for evaluation. when passing an AdaptiveToken to the evaluation-function of a cell the system will create a dependency edge internally and future marking of the inner cell will also cause the calling cell to be marked.

Functional operators for the alist<_> type.

Adaptive list datastructure.

Functional operators for amap<_,_>

Adaptive map datastructure.

Functional operators for aset<_>

Adaptive set datastructure.

Operators related to the aval<_> type

An abbreviation for AdaptiveValue

IAdaptiveObject extensions for creating/removing callbacks.

Changeable adaptive map that allows mutation by user-code and implements amap.

Changeable adaptive set that allows mutation by user-code and implements aset.

Changeable adaptive list that allows mutation by user-code and implements alist.

Represents an adaptive value that can be changed by application code and Used in dependency-aware computations.

Changeable adaptive list that allows mutation by user-code and implements alist.

Changeable adaptive map that allows mutation by user-code and implements amap.

Collection extensions for aset<_>, amap<_,_>, alist<_>

ComputationExpression builders for aval/aset/alist/amap.

internal list-diffing implementation.

Core implementation of IAdaptiveObject for constant objects. The main goal of this implementation is to save memory when IAdaptiveObjects are known to be constant.

An abbreviation for ChangeableHashSet

Represents an adaptive value that can be changed by application code and Used in dependency-aware computations.

Differentiation extensions for several immutable datastructures.

Reprensents a element operation (Set/Remove) without its key. Typically datastructures will hold (key * ElementOperation) tuples.

Functional operators for HashMapDelta.

Represents the difference of two HashMaps.

Functional operators for HashSetDelta.

Represents the difference of two HashSets. Internally uses reference counts to represent deltas and provides convenient combine functions.

Adaptive map datastructure.

Adaptive set datastructure.

Adaptive list datastructure.

Represents the core interface for all adaptive objects. Contains support for tracking OutOfDate flags, managing in-/outputs and lazy/eager evaluation in the dependency tree.

Represents a dependency-aware value that may change as changes are fed into the system. An AdaptiveValue cannot be changed directly but gets updated by the dependency graph.

Represents a dependency-aware value that may change as changes are fed into the system. An AdaptiveValue cannot be changed directly but gets updated by the dependency graph. For changeable inputs see cval<'T>

Visitor for "magically" summoning a type-argument.

An adaptive reader for amap that allows to pull operations and exposes its current state.

An adaptive reader for aset that allows to pull operations and exposes its current state.

An adaptive reader for alist that allows to pull operations and exposes its current state.

functional operators for the Index datastructure. supported operations are: Index.zero, Index.after(index), Index.before(index), Index.between(l, r).

datastructure representing an abstract index. this is a 'simple' solution to the order-maintenance problem that has insert in O(log N), delete in O(1) and compare in O(1). Note that the implementation is quite obfuscated due to concurrency.

Functional operators for IndexList.

A persitent array-like structure that allows lookup/insertion/deletion of entries in O(log N). Note that datastructure uses Index instead of int as index type which allows for these efficient implementations. However the datastructure also has accessors that allow getting/setting/deleting entries via an int-index in O(log N).

Functional operators for IndexListDelta.

Represents the difference of two IndexLists.

Enumerator for IndexList.

Represents a set of outputs for an AdaptiveObject. The references to all contained elements are weak and the datastructure allows to add/remove entries. the only other functionality is Consume which returns all the (currently alive) entries and clears the set.

When evaluating AdaptiveObjects inside a Transaction (aka eager evaluation) their level might be inconsistent when attempting to evaluate. Therefore the evaluation may raise this exception causing the evaluation to be delayed to a later time in the Transaction.

SetOperation extensions making them look like a union-type.

Functional operators for SetOperation<_>

Represents a set operation (Add/Remove) using a reference count. Note that internally SetOperations may have reference counts > 1 and < -1.

Module for transaction related functions. (e.g. transact)

Holds a set of adaptive objects which have been changed and shall therefore be marked as outOfDate. Committing the transaction propagates these changes into the dependency-graph, takes care of the correct execution-order and acquires appropriate locks for all objects affected.