Header menu logo FSharp.Data.Adaptive

FSharp.Data.Adaptive Namespace

Type/Module Description

AdadptiveObjectExtensions

AdaptiveDirectory

Adaptive functions for handling directories.

AdaptiveFile

Adaptive functions for handling files.

AdaptiveObject

Core implementation of IAdaptiveObject containing tools for evaluation and locking

AdaptiveReduction

Functional operators for AdaptiveReduction.

AdaptiveReduction<'a, 's, 'v>

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

AdaptiveSynchronizationContext

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

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.

AList

Functional operators for the alist<_> type.

alist<'T>

Adaptive list datastructure.

AMap

Functional operators for amap<_,_>

amap<'Key, 'Value>

Adaptive map datastructure.

ASet

Functional operators for aset<_>

aset<'T>

Adaptive set datastructure.

AVal

Operators related to the aval<_> type

aval<'T>

An abbreviation for AdaptiveValue

CallbackExtensions

IAdaptiveObject extensions for creating/removing callbacks.

ChangeableHashMap<'Key, 'Value>

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

ChangeableHashSet<'T>

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

ChangeableIndexList<'T>

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

ChangeableValue<'T>

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

clist<'T>

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

cmap<'Key, 'Value>

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

CollectionExtensions

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

ComputationExpressions

ComputationExpression builders for aval/aset/alist/amap.

ComputeListDeltaHelpers

internal list-diffing implementation.

ConstantObject

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

cset<'T>

An abbreviation for ChangeableHashSet

cval<'T>

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

DecoratorObject

DefaultDictionary

DefaultEquality

DefaultEqualityComparer

DefaultEqualityComparer<'T>

DefaultHashSet

DifferentiationExtensions

Differentiation extensions for several immutable datastructures.

DynamicMethod Extensions

ElementOperation<'T>

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

EvaluationCallbackExtensions

HashMap

HashMapDelta

Functional operators for HashMapDelta.

HashMapDelta<'K, 'V>

Represents the difference of two HashMaps.

HashMapEnumerator<'K, 'V, 'T>

HashSet

HashSetDelta

Functional operators for HashSetDelta.

HashSetDelta<'T>

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

HashSetEnumerator<'K>

IAdaptiveHashMap<'Key, 'Value>

Adaptive map datastructure.

IAdaptiveHashSet<'T>

Adaptive set datastructure.

IAdaptiveIndexList<'T>

Adaptive list datastructure.

IAdaptiveObject

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.

IAdaptiveValue

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.

IAdaptiveValue<'T>

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>

IAdaptiveValueVisitor<'R>

Visitor for "magically" summoning a type-argument.

IEqualityProvider

IHashMapReader<'Key, 'Value>

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

IHashSetReader<'T>

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

IIndexListReader<'T>

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

Index (Module)

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

Index (Type)

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.

IndexList

Functional operators for IndexList.

IndexList<'T>

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).

IndexListDelta

Functional operators for IndexListDelta.

IndexListDelta<'T>

Represents the difference of two IndexLists.

IndexListDeltaEnumerator<'T>

IndexListEnumerator<'Value>

Enumerator for IndexList.

IWeakOutputSet

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.

LevelChangedException

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.

ReferenceEqualityComparer<'T>

ReferenceHashSet

SetDeltaExtensions

SetOperation extensions making them look like a union-type.

SetOperation

Functional operators for SetOperation<_>

SetOperation<'T>

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

ShallowEqualityComparer<'a>

Transaction (Module)

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

Transaction (Type)

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.

Type something to start searching.