f : 'T -> 'U -> aval<'V>

a : aval<'T>

b : aval<'U>

Returns: aval<'V>

f : 'T -> 'U -> 'V -> aval<'W>

a : aval<'T>

b : aval<'U>

c : aval<'V>

Returns: aval<'W>

Constant values have zero overhead - they never recompute and don't track dependencies. Use this for values that are known at creation time and will never change.

value : 'T

The constant value.

Returns: aval<'T>

An adaptive value that always returns the given value.

Example

 let pi = AVal.constant 3.14159
 let doubled = AVal.map (fun x -> x * 2.0) pi

compute : unit -> 'T

Returns: aval<'T>

create : unit -> 'T

Returns: aval<'T>

Example

 let v = AVal.delay (fun () -> expensiveComputation ())

value : aval<'T>

Returns: 'T

value : 'T

Returns: cval<'T>

The function is called lazily - only when the result is read and the source has changed. The result is cached until the source changes.

f : 'T -> 'U

The function to apply to the value.

value : aval<'T>

The source adaptive value.

Returns: aval<'U>

A new adaptive value that applies the function to the source.

Example

 let celsius = CVal.create 20.0
 let fahrenheit = AVal.map (fun c -> c * 9.0/5.0 + 32.0) (CVal.value celsius)

Recomputes only when either input changes. Both inputs are read in a single evaluation.

f : 'T -> 'U -> 'V

The function to combine the two values.

left : aval<'T>

The first adaptive value.

right : aval<'U>

The second adaptive value.

Returns: aval<'V>

A new adaptive value that combines both inputs.

Example

 let width = CVal.create 10.0
 let height = CVal.create 20.0
 let area = AVal.map2 (*) (CVal.value width) (CVal.value height)

f : 'A -> 'B -> 'C -> 'T

The function to combine the three values.

a : aval<'A>

The first adaptive value.

b : aval<'B>

The second adaptive value.

c : aval<'C>

The third adaptive value.

Returns: aval<'T>

A new adaptive value that combines all three inputs.

Example

 let r = CVal.create 255
 let g = CVal.create 128
 let b = CVal.create 64
 let color = AVal.map3 (fun r g b -> sprintf "#%02X%02X%02X" r g b)
                       (CVal.value r) (CVal.value g) (CVal.value b)

f : 'A -> 'B -> 'C -> 'D -> 'T

The function to combine the four values.

a : aval<'A>

The first adaptive value.

b : aval<'B>

The second adaptive value.

c : aval<'C>

The third adaptive value.

d : aval<'D>

The fourth adaptive value.

Returns: aval<'T>

A new adaptive value that combines all four inputs.

Example

 let x = CVal.create 0.0
 let y = CVal.create 0.0
 let width = CVal.create 100.0
 let height = CVal.create 50.0
 let rect = AVal.map4 (fun x y w h -> { X = x; Y = y; Width = w; Height = h })
                      (CVal.value x) (CVal.value y) (CVal.value width) (CVal.value height)

When to use: Use mapN when you need to combine 5+ values of the same type, or when you need access to all values as an array (e.g., for aggregation, filtering).

Performance: Uses a single node instead of O(N) nodes from chained map2 calls. This provides 3-100× speedup for wide fan-in patterns (10-500 inputs). Memory usage is constant regardless of input count.

Note: The array passed to the compute function is reused by the node and is valid only during the call. Do not retain it. If you only need a reduction (sum, min, max, etc.), prefer reduce for better performance.

compute : 'T[] -> 'U

A function that receives an array of all current values and produces the result.

deps : aval<'T>[]

An array of adaptive values to combine.

Returns: aval<'U>

A new adaptive value that combines all inputs.

Example

 // Combine 10 sensor readings into their average
 let sensors = Array.init 10 (fun i -> CVal.create (float i))
 let deps = sensors |> Array.map (fun s -> CVal.value s :> IAdaptiveValue<float>)
 let average = AVal.mapN (fun values -> Array.average values) deps

f : 'T -> Task<'U>

The async function to apply.

value : aval<'T>

The source adaptive value.

Returns: aval<Task<'U>>

An adaptive value containing Tasks of the result type.

read : unit -> 'T

Returns: aval<'T> * (unit -> unit)

Example

 let mutable current = 0
 let value, invalidate = AVal.ofExternal (fun () -> current)
 current <- 42
 invalidate ()
 printfn "%d" (AVal.getValue value)  // 42

When to use: Use reduce for aggregations like sum, product, min, max, string concatenation, or any fold-like operation over adaptive values.

Performance: More efficient than mapN for reductions because it doesn't allocate an intermediate array. Uses a single node instead of O(N) nodes from chained map2. Provides 3-100× speedup for wide fan-in patterns.

Empty array behavior: Returns the init value when deps is empty.

init : 'T

The initial/identity value for the reduction (e.g., 0 for sum, 1 for product).

reduce : 'T -> 'T -> 'T

A binary function to combine values (must be associative for correct results).

deps : aval<'T>[]

An array of adaptive values to reduce.

Returns: aval<'T>

A new adaptive value containing the reduction result.

Example

 // Sum of prices
 let prices = [| CVal.create 10.0; CVal.create 20.0; CVal.create 15.0 |]
 let deps = prices |> Array.map (fun p -> CVal.value p :> IAdaptiveValue<float>)
 let total = AVal.reduce 0.0 (+) deps

 // Product
 let product = AVal.reduce 1.0 (*) deps

 // Maximum (using System.Double.MinValue as identity)
 let maxPrice = AVal.reduce System.Double.MinValue max deps

Performance: Uses a single node instead of O(N) nodes from chained additions. Provides 3-100× speedup for summing many values (10-500 inputs).

Empty array behavior: Returns 0 when deps is empty.

deps : aval<int>[]

An array of adaptive integer values to sum.

Returns: aval<int>

A new adaptive value containing the sum.

Example

 let scores = [| CVal.create 85; CVal.create 92; CVal.create 78 |]
 let deps = scores |> Array.map (fun s -> CVal.value s :> IAdaptiveValue<int>)
 let totalScore = AVal.sum deps

 scores.[0].Set(90)
 printfn "Total: %d" (AVal.getValue totalScore)  // Total: 260