Logo Orsak

ScopeCreatingEffectBuilder<'Scope> Type

Namespace: Orsak.Scoped
Assembly: Orsak.dll
Base Type: EffBuilderBase

A computation expression for effects running in a scope of type . The effects bound in it are ordinary effects, of the environment the outer one grows into: running the expression begins the scope and grows the environment, so the result is an effect of the outer environment, without the scope.

Example 

 let progress = ScopeCreatingEffectBuilder<ProgressScope>()

 let importAll files = progress {
     for file in files do
         do! import file
         do! Progress.report file
 }
val progress: (obj -> obj)
val importAll: files: 'a -> obj
val files: 'a

Constructors

Constructor Description

ScopeCreatingEffectBuilder()

Full Usage: ScopeCreatingEffectBuilder()

Returns: ScopeCreatingEffectBuilder<'Scope>
Returns: ScopeCreatingEffectBuilder<'Scope>

EffBuilderBase()

Full Usage: EffBuilderBase()

Returns: EffBuilderBase
Returns: EffBuilderBase

Instance members

Instance member Description

this.Bind2

Full Usage: this.Bind2

Parameters:
    eff : Effect<'Env, 'TResult1, ^Err>
    eff2 : Effect<'Env, 'TResult2, ^Err>
    f : 'TResult1 * 'TResult2 -> EffectCode<'Env, 'TOverall, 'T, ^Err>

Returns: EffectCode<'Env, 'TOverall, 'T, ^Err>
Modifiers: inline
Type parameters: 'Env, 'T, 'TOverall, 'TResult1, 'TResult2, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
eff : Effect<'Env, 'TResult1, ^Err>
eff2 : Effect<'Env, 'TResult2, ^Err>
f : 'TResult1 * 'TResult2 -> EffectCode<'Env, 'TOverall, 'T, ^Err>
Returns: EffectCode<'Env, 'TOverall, 'T, ^Err>

this.Bind2Return

Full Usage: this.Bind2Return

Parameters:
    m1 : Effect<'a, 'b, ^c>
    m2 : Effect<'a, 'd, ^c>
    f : 'b * 'd -> 'e

Returns: EffectCode<'a, 'e, 'e, ^c>
Modifiers: inline
Type parameters: 'a, 'b, ^c, 'd, 'e (requires (static member op_Addition : ^c * ^c -> ^c))
m1 : Effect<'a, 'b, ^c>
m2 : Effect<'a, 'd, ^c>
f : 'b * 'd -> 'e
Returns: EffectCode<'a, 'e, 'e, ^c>

this.Bind3

Full Usage: this.Bind3

Parameters:
    eff : Effect<'Env, 'TResult1, ^Err>
    eff2 : Effect<'Env, 'TResult2, ^Err>
    eff3 : Effect<'Env, 'TResult3, ^Err>
    f : 'TResult1 * 'TResult2 * 'TResult3 -> EffectCode<'Env, 'TOverall, 'T, ^Err>

Returns: EffectCode<'Env, 'TOverall, 'T, ^Err>
Modifiers: inline
Type parameters: 'Env, 'T, 'TOverall, 'TResult1, 'TResult2, 'TResult3, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
eff : Effect<'Env, 'TResult1, ^Err>
eff2 : Effect<'Env, 'TResult2, ^Err>
eff3 : Effect<'Env, 'TResult3, ^Err>
f : 'TResult1 * 'TResult2 * 'TResult3 -> EffectCode<'Env, 'TOverall, 'T, ^Err>
Returns: EffectCode<'Env, 'TOverall, 'T, ^Err>

this.Bind3Return

Full Usage: this.Bind3Return

Parameters:
    m1 : Effect<'a, 'b, ^c>
    m2 : Effect<'a, 'd, ^c>
    m3 : Effect<'a, 'e, ^c>
    f : 'b * 'd * 'e -> 'f

Returns: EffectCode<'a, 'f, 'f, ^c>
Modifiers: inline
Type parameters: 'a, 'b, ^c, 'd, 'e, 'f (requires (static member op_Addition : ^c * ^c -> ^c))
m1 : Effect<'a, 'b, ^c>
m2 : Effect<'a, 'd, ^c>
m3 : Effect<'a, 'e, ^c>
f : 'b * 'd * 'e -> 'f
Returns: EffectCode<'a, 'f, 'f, ^c>

this.Bind4

Full Usage: this.Bind4

Parameters:
    eff1 : Effect<'Env, 'TResult1, ^Err>
    eff2 : Effect<'Env, 'TResult2, ^Err>
    eff3 : Effect<'Env, 'TResult3, ^Err>
    eff4 : Effect<'Env, 'TResult4, ^Err>
    f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 -> EffectCode<'Env, 'TOverall, 'T, ^Err>

Returns: EffectCode<'Env, 'TOverall, 'T, ^Err>
Modifiers: inline
Type parameters: 'Env, 'T, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
eff1 : Effect<'Env, 'TResult1, ^Err>
eff2 : Effect<'Env, 'TResult2, ^Err>
eff3 : Effect<'Env, 'TResult3, ^Err>
eff4 : Effect<'Env, 'TResult4, ^Err>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 -> EffectCode<'Env, 'TOverall, 'T, ^Err>
Returns: EffectCode<'Env, 'TOverall, 'T, ^Err>

this.Bind4Return

Full Usage: this.Bind4Return

Parameters:
    m1 : Effect<'a, 'b, ^c>
    m2 : Effect<'a, 'd, ^c>
    m3 : Effect<'a, 'e, ^c>
    m4 : Effect<'a, 'f, ^c>
    f : 'b * 'd * 'e * 'f -> 'g

Returns: EffectCode<'a, 'g, 'g, ^c>
Modifiers: inline
Type parameters: 'a, 'b, ^c, 'd, 'e, 'f, 'g (requires (static member op_Addition : ^c * ^c -> ^c))
m1 : Effect<'a, 'b, ^c>
m2 : Effect<'a, 'd, ^c>
m3 : Effect<'a, 'e, ^c>
m4 : Effect<'a, 'f, ^c>
f : 'b * 'd * 'e * 'f -> 'g
Returns: EffectCode<'a, 'g, 'g, ^c>

this.Bind5

Full Usage: this.Bind5

Parameters:
    eff1 : Effect<'Env, 'TResult1, ^Err>
    eff2 : Effect<'Env, 'TResult2, ^Err>
    eff3 : Effect<'Env, 'TResult3, ^Err>
    eff4 : Effect<'Env, 'TResult4, ^Err>
    eff5 : Effect<'Env, 'TResult5, ^Err>
    f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 -> EffectCode<'Env, 'TOverall, 'T, ^Err>

Returns: EffectCode<'Env, 'TOverall, 'T, ^Err>
Modifiers: inline
Type parameters: 'Env, 'T, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
eff1 : Effect<'Env, 'TResult1, ^Err>
eff2 : Effect<'Env, 'TResult2, ^Err>
eff3 : Effect<'Env, 'TResult3, ^Err>
eff4 : Effect<'Env, 'TResult4, ^Err>
eff5 : Effect<'Env, 'TResult5, ^Err>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 -> EffectCode<'Env, 'TOverall, 'T, ^Err>
Returns: EffectCode<'Env, 'TOverall, 'T, ^Err>

this.Bind5Return

Full Usage: this.Bind5Return

Parameters:
    m1 : Effect<'a, 'b, ^c>
    m2 : Effect<'a, 'd, ^c>
    m3 : Effect<'a, 'e, ^c>
    m4 : Effect<'a, 'f, ^c>
    m5 : Effect<'a, 'g, ^c>
    f : 'b * 'd * 'e * 'f * 'g -> 'h

Returns: EffectCode<'a, 'h, 'h, ^c>
Modifiers: inline
Type parameters: 'a, 'b, ^c, 'd, 'e, 'f, 'g, 'h (requires (static member op_Addition : ^c * ^c -> ^c))
m1 : Effect<'a, 'b, ^c>
m2 : Effect<'a, 'd, ^c>
m3 : Effect<'a, 'e, ^c>
m4 : Effect<'a, 'f, ^c>
m5 : Effect<'a, 'g, ^c>
f : 'b * 'd * 'e * 'f * 'g -> 'h
Returns: EffectCode<'a, 'h, 'h, ^c>

this.Bind6

Full Usage: this.Bind6

Parameters:
    eff1 : Effect<'Env, 'TResult1, ^Err>
    eff2 : Effect<'Env, 'TResult2, ^Err>
    eff3 : Effect<'Env, 'TResult3, ^Err>
    eff4 : Effect<'Env, 'TResult4, ^Err>
    eff5 : Effect<'Env, 'TResult5, ^Err>
    eff6 : Effect<'Env, 'TResult6, ^Err>
    f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 * 'TResult6 -> EffectCode<'Env, 'TOverall, 'T, ^Err>

Returns: EffectCode<'Env, 'TOverall, 'T, ^Err>
Modifiers: inline
Type parameters: 'Env, 'T, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, 'TResult6, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
eff1 : Effect<'Env, 'TResult1, ^Err>
eff2 : Effect<'Env, 'TResult2, ^Err>
eff3 : Effect<'Env, 'TResult3, ^Err>
eff4 : Effect<'Env, 'TResult4, ^Err>
eff5 : Effect<'Env, 'TResult5, ^Err>
eff6 : Effect<'Env, 'TResult6, ^Err>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 * 'TResult6 -> EffectCode<'Env, 'TOverall, 'T, ^Err>
Returns: EffectCode<'Env, 'TOverall, 'T, ^Err>

this.Bind6Return

Full Usage: this.Bind6Return

Parameters:
    m1 : Effect<'a, 'b, ^c>
    m2 : Effect<'a, 'd, ^c>
    m3 : Effect<'a, 'e, ^c>
    m4 : Effect<'a, 'f, ^c>
    m5 : Effect<'a, 'g, ^c>
    m6 : Effect<'a, 'h, ^c>
    f : 'b * 'd * 'e * 'f * 'g * 'h -> 'i

Returns: EffectCode<'a, 'i, 'i, ^c>
Modifiers: inline
Type parameters: 'a, 'b, ^c, 'd, 'e, 'f, 'g, 'h, 'i (requires (static member op_Addition : ^c * ^c -> ^c))
m1 : Effect<'a, 'b, ^c>
m2 : Effect<'a, 'd, ^c>
m3 : Effect<'a, 'e, ^c>
m4 : Effect<'a, 'f, ^c>
m5 : Effect<'a, 'g, ^c>
m6 : Effect<'a, 'h, ^c>
f : 'b * 'd * 'e * 'f * 'g * 'h -> 'i
Returns: EffectCode<'a, 'i, 'i, ^c>

this.Bind7

Full Usage: this.Bind7

Parameters:
    eff1 : Effect<'Env, 'TResult1, ^Err>
    eff2 : Effect<'Env, 'TResult2, ^Err>
    eff3 : Effect<'Env, 'TResult3, ^Err>
    eff4 : Effect<'Env, 'TResult4, ^Err>
    eff5 : Effect<'Env, 'TResult5, ^Err>
    eff6 : Effect<'Env, 'TResult6, ^Err>
    eff7 : Effect<'Env, 'TResult7, ^Err>
    f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 * 'TResult6 * 'TResult7 -> EffectCode<'Env, 'TOverall, 'T, ^Err>

Returns: EffectCode<'Env, 'TOverall, 'T, ^Err>
Modifiers: inline
Type parameters: 'Env, 'T, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, 'TResult6, 'TResult7, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
eff1 : Effect<'Env, 'TResult1, ^Err>
eff2 : Effect<'Env, 'TResult2, ^Err>
eff3 : Effect<'Env, 'TResult3, ^Err>
eff4 : Effect<'Env, 'TResult4, ^Err>
eff5 : Effect<'Env, 'TResult5, ^Err>
eff6 : Effect<'Env, 'TResult6, ^Err>
eff7 : Effect<'Env, 'TResult7, ^Err>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 * 'TResult6 * 'TResult7 -> EffectCode<'Env, 'TOverall, 'T, ^Err>
Returns: EffectCode<'Env, 'TOverall, 'T, ^Err>

this.Bind7Return

Full Usage: this.Bind7Return

Parameters:
    m1 : Effect<'a, 'b, ^c>
    m2 : Effect<'a, 'd, ^c>
    m3 : Effect<'a, 'e, ^c>
    m4 : Effect<'a, 'f, ^c>
    m5 : Effect<'a, 'g, ^c>
    m6 : Effect<'a, 'h, ^c>
    m7 : Effect<'a, 'i, ^c>
    f : 'b * 'd * 'e * 'f * 'g * 'h * 'i -> 'j

Returns: EffectCode<'a, 'j, 'j, ^c>
Modifiers: inline
Type parameters: 'a, 'b, ^c, 'd, 'e, 'f, 'g, 'h, 'i, 'j (requires (static member op_Addition : ^c * ^c -> ^c))
m1 : Effect<'a, 'b, ^c>
m2 : Effect<'a, 'd, ^c>
m3 : Effect<'a, 'e, ^c>
m4 : Effect<'a, 'f, ^c>
m5 : Effect<'a, 'g, ^c>
m6 : Effect<'a, 'h, ^c>
m7 : Effect<'a, 'i, ^c>
f : 'b * 'd * 'e * 'f * 'g * 'h * 'i -> 'j
Returns: EffectCode<'a, 'j, 'j, ^c>

this.ChangeError

Full Usage: this.ChangeError

Parameters:
    eff : Effect<'Env, 'TResult, 'Err1>
    f : 'Err1 -> 'Err2

Returns: EffectCode<'Env, 'TResult, 'TResult, 'Err2>
Modifiers: inline
Type parameters: 'Env, 'TResult, 'Err1, 'Err2
eff : Effect<'Env, 'TResult, 'Err1>
f : 'Err1 -> 'Err2
Returns: EffectCode<'Env, 'TResult, 'TResult, 'Err2>

this.Combine

Full Usage: this.Combine

Parameters:
Returns: EffectCode<'a, 'TOverall, 'T, 'Err>
Modifiers: inline
Type parameters: 'a, 'TOverall, 'Err, 'T
task1 : EffectCode<'a, 'TOverall, unit, 'Err>
task2 : EffectCode<'a, 'TOverall, 'T, 'Err>
Returns: EffectCode<'a, 'TOverall, 'T, 'Err>

this.Delay

Full Usage: this.Delay

Parameters:
    generator : unit -> EffectCode<'Env, 'TOverall, 'T, 'Err>

Returns: EffectCode<'Env, 'TOverall, 'T, 'Err>
Modifiers: inline
Type parameters: 'Env, 'TOverall, 'T, 'Err
generator : unit -> EffectCode<'Env, 'TOverall, 'T, 'Err>
Returns: EffectCode<'Env, 'TOverall, 'T, 'Err>

this.Recover

Full Usage: this.Recover

Parameters:
    eff : Effect<'Env, 'TResult, 'Err>
    continuation : 'Err -> 'TResult

Returns: EffectCode<'Env, 'TResult, 'TResult, 'Err>
Modifiers: inline
Type parameters: 'Env, 'TResult, 'Err
eff : Effect<'Env, 'TResult, 'Err>
continuation : 'Err -> 'TResult
Returns: EffectCode<'Env, 'TResult, 'TResult, 'Err>

this.Return

Full Usage: this.Return

Parameters:
    value : 'T

Returns: EffectCode<'Env, 'T, 'T, 'Err>
Modifiers: inline
Type parameters: 'T, 'Env, 'Err
value : 'T
Returns: EffectCode<'Env, 'T, 'T, 'Err>

this.Run

Full Usage: this.Run

Parameters:
Returns: Effect<'Outer, 'a, 'err>
Modifiers: inline
Type parameters: 'Inner, 'a, 'err

Runs the effects of the expression in a new scope, as Scope.Within does.

code : EffectCode<'Inner, 'a, 'a, 'err>
Returns: Effect<'Outer, 'a, 'err>

this.TryFinally

Full Usage: this.TryFinally

Parameters:
    body : EffectCode<'a, 'TOverall, 'T, 'b>
    compensation : unit -> unit

Returns: EffectCode<'a, 'TOverall, 'T, 'b>
Modifiers: inline
Type parameters: 'a, 'TOverall, 'T, 'b
body : EffectCode<'a, 'TOverall, 'T, 'b>
compensation : unit -> unit
Returns: EffectCode<'a, 'TOverall, 'T, 'b>

this.TryRecover

Full Usage: this.TryRecover

Parameters:
    eff : Effect<'Env, 'TResult, 'Err>
    continuation : 'Err -> Effect<'Env, 'TResult, 'Err>

Returns: EffectCode<'Env, 'TResult, 'TResult, 'Err>
Modifiers: inline
Type parameters: 'Env, 'TResult, 'Err
eff : Effect<'Env, 'TResult, 'Err>
continuation : 'Err -> Effect<'Env, 'TResult, 'Err>
Returns: EffectCode<'Env, 'TResult, 'TResult, 'Err>

this.TryRecover

Full Usage: this.TryRecover

Parameters:
    eff : Effect<'Env, 'TResult, 'Err>
    continuation : 'Err -> Result<'TResult, 'Err>

Returns: EffectCode<'Env, 'TResult, 'TResult, 'Err>
Modifiers: inline
Type parameters: 'Env, 'TResult, 'Err
eff : Effect<'Env, 'TResult, 'Err>
continuation : 'Err -> Result<'TResult, 'Err>
Returns: EffectCode<'Env, 'TResult, 'TResult, 'Err>

this.TryWith

Full Usage: this.TryWith

Parameters:
Returns: EffectCode<'a, 'TOverall, 'T, 'b>
Modifiers: inline
Type parameters: 'a, 'TOverall, 'T, 'b
body : EffectCode<'a, 'TOverall, 'T, 'b>
catch : exn -> EffectCode<'a, 'TOverall, 'T, 'b>
Returns: EffectCode<'a, 'TOverall, 'T, 'b>

this.Using

Full Usage: this.Using

Parameters:
    resource : 'Resource
    body : 'Resource -> EffectCode<'Env, 'TOverall, 'T, 'Err>

Returns: EffectCode<'Env, 'TOverall, 'T, 'Err>
Modifiers: inline
Type parameters: 'Resource, 'TOverall, 'T, 'Env, 'Err (requires :> System.IAsyncDisposable)
resource : 'Resource
body : 'Resource -> EffectCode<'Env, 'TOverall, 'T, 'Err>
Returns: EffectCode<'Env, 'TOverall, 'T, 'Err>

this.WhenAll

Full Usage: this.WhenAll

Parameters:
    effects : Effect<'Env, 'T, 'Err> seq

Returns: EffectCode<'Env, 'T array, 'T array, 'Err>
Modifiers: inline
Type parameters: 'Env, 'T, 'Err
effects : Effect<'Env, 'T, 'Err> seq
Returns: EffectCode<'Env, 'T array, 'T array, 'Err>

this.While

Full Usage: this.While

Parameters:
    condition : unit -> bool
    body : EffectCode<'Env, 'TOverall, unit, 'Err>

Returns: EffectCode<'Env, 'TOverall, unit, 'Err>
Modifiers: inline
Type parameters: 'Env, 'TOverall, 'Err
condition : unit -> bool
body : EffectCode<'Env, 'TOverall, unit, 'Err>
Returns: EffectCode<'Env, 'TOverall, unit, 'Err>

this.Zero

Full Usage: this.Zero

Returns: EffectCode<'Env, 'TOverall, unit, 'Err>
Modifiers: inline
Type parameters: 'Env, 'TOverall, 'Err
Returns: EffectCode<'Env, 'TOverall, unit, 'Err>

this.Zip

Full Usage: this.Zip

Parameters:
    eff1 : Effect<'Env, 'TResult1, ^Err>
    eff2 : Effect<'Env, 'TResult2, ^Err>
    eff3 : Effect<'Env, 'TResult3, ^Err>
    eff4 : Effect<'Env, 'TResult4, ^Err>
    eff5 : Effect<'Env, 'TResult5, ^Err>
    eff6 : Effect<'Env, 'TResult6, ^Err>
    eff7 : Effect<'Env, 'TResult7, ^Err>
    f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 * 'TResult6 * 'TResult7 -> 'TOverall

Returns: EffectCode<'Env, 'TOverall, 'TOverall, ^Err>
Modifiers: inline
Type parameters: 'Env, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, 'TResult6, 'TResult7, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
eff1 : Effect<'Env, 'TResult1, ^Err>
eff2 : Effect<'Env, 'TResult2, ^Err>
eff3 : Effect<'Env, 'TResult3, ^Err>
eff4 : Effect<'Env, 'TResult4, ^Err>
eff5 : Effect<'Env, 'TResult5, ^Err>
eff6 : Effect<'Env, 'TResult6, ^Err>
eff7 : Effect<'Env, 'TResult7, ^Err>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 * 'TResult6 * 'TResult7 -> 'TOverall
Returns: EffectCode<'Env, 'TOverall, 'TOverall, ^Err>

this.Zip

Full Usage: this.Zip

Parameters:
    eff1 : Effect<'Env, 'TResult1, ^Err>
    eff2 : Effect<'Env, 'TResult2, ^Err>
    eff3 : Effect<'Env, 'TResult3, ^Err>
    eff4 : Effect<'Env, 'TResult4, ^Err>
    eff5 : Effect<'Env, 'TResult5, ^Err>
    eff6 : Effect<'Env, 'TResult6, ^Err>
    f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 * 'TResult6 -> 'TOverall

Returns: EffectCode<'Env, 'TOverall, 'TOverall, ^Err>
Modifiers: inline
Type parameters: 'Env, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, 'TResult6, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
eff1 : Effect<'Env, 'TResult1, ^Err>
eff2 : Effect<'Env, 'TResult2, ^Err>
eff3 : Effect<'Env, 'TResult3, ^Err>
eff4 : Effect<'Env, 'TResult4, ^Err>
eff5 : Effect<'Env, 'TResult5, ^Err>
eff6 : Effect<'Env, 'TResult6, ^Err>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 * 'TResult6 -> 'TOverall
Returns: EffectCode<'Env, 'TOverall, 'TOverall, ^Err>

this.Zip

Full Usage: this.Zip

Parameters:
    eff1 : Effect<'Env, 'TResult1, ^Err>
    eff2 : Effect<'Env, 'TResult2, ^Err>
    eff3 : Effect<'Env, 'TResult3, ^Err>
    eff4 : Effect<'Env, 'TResult4, ^Err>
    eff5 : Effect<'Env, 'TResult5, ^Err>
    f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 -> 'TOverall

Returns: EffectCode<'Env, 'TOverall, 'TOverall, ^Err>
Modifiers: inline
Type parameters: 'Env, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
eff1 : Effect<'Env, 'TResult1, ^Err>
eff2 : Effect<'Env, 'TResult2, ^Err>
eff3 : Effect<'Env, 'TResult3, ^Err>
eff4 : Effect<'Env, 'TResult4, ^Err>
eff5 : Effect<'Env, 'TResult5, ^Err>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 -> 'TOverall
Returns: EffectCode<'Env, 'TOverall, 'TOverall, ^Err>

this.Zip

Full Usage: this.Zip

Parameters:
    eff1 : Effect<'Env, 'TResult1, ^Err>
    eff2 : Effect<'Env, 'TResult2, ^Err>
    eff3 : Effect<'Env, 'TResult3, ^Err>
    eff4 : Effect<'Env, 'TResult4, ^Err>
    f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 -> 'TOverall

Returns: EffectCode<'Env, 'TOverall, 'TOverall, ^Err>
Modifiers: inline
Type parameters: 'Env, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
eff1 : Effect<'Env, 'TResult1, ^Err>
eff2 : Effect<'Env, 'TResult2, ^Err>
eff3 : Effect<'Env, 'TResult3, ^Err>
eff4 : Effect<'Env, 'TResult4, ^Err>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 -> 'TOverall
Returns: EffectCode<'Env, 'TOverall, 'TOverall, ^Err>

this.Zip

Full Usage: this.Zip

Parameters:
    eff : Effect<'Env, 'TResult1, ^Err>
    eff2 : Effect<'Env, 'TResult2, ^Err>
    eff3 : Effect<'Env, 'TResult3, ^Err>
    f : 'TResult1 * 'TResult2 * 'TResult3 -> 'TOverall

Returns: EffectCode<'Env, 'TOverall, 'TOverall, ^Err>
Modifiers: inline
Type parameters: 'Env, 'TOverall, 'TResult1, 'TResult2, 'TResult3, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
eff : Effect<'Env, 'TResult1, ^Err>
eff2 : Effect<'Env, 'TResult2, ^Err>
eff3 : Effect<'Env, 'TResult3, ^Err>
f : 'TResult1 * 'TResult2 * 'TResult3 -> 'TOverall
Returns: EffectCode<'Env, 'TOverall, 'TOverall, ^Err>

this.Zip

Full Usage: this.Zip

Parameters:
    eff : Effect<'Env, 'TResult1, ^Err>
    eff2 : Effect<'Env, 'TResult2, ^Err>
    f : 'TResult1 * 'TResult2 -> 'TOverall

Returns: EffectCode<'Env, 'TOverall, 'TOverall, ^Err>
Modifiers: inline
Type parameters: 'Env, 'TOverall, 'TResult1, 'TResult2, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
eff : Effect<'Env, 'TResult1, ^Err>
eff2 : Effect<'Env, 'TResult2, ^Err>
f : 'TResult1 * 'TResult2 -> 'TOverall
Returns: EffectCode<'Env, 'TOverall, 'TOverall, ^Err>

Static members

Static member Description

EffBuilderBase.AwaiterNotComplete(v)

Full Usage: EffBuilderBase.AwaiterNotComplete(v)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'a
v : inref<ValueTaskAwaiter<'a>>
Returns: bool

EffBuilderBase.Bind2Dynamic(sm, task1, task2, f)

Full Usage: EffBuilderBase.Bind2Dynamic(sm, task1, task2, f)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'T, 'TOverall, 'TResult1, 'TResult2, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TOverall, ^Err>>>
task1 : ValueTask<Result<'TResult1, ^Err>>
task2 : ValueTask<Result<'TResult2, ^Err>>
f : 'TResult1 * 'TResult2 -> EffectCode<'Env, 'TOverall, 'T, ^Err>
Returns: bool

EffBuilderBase.Bind3Dynamic(sm, task1, task2, task3, f)

Full Usage: EffBuilderBase.Bind3Dynamic(sm, task1, task2, task3, f)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'T, 'TOverall, 'TResult1, 'TResult2, 'TResult3, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TOverall, ^Err>>>
task1 : ValueTask<Result<'TResult1, ^Err>>
task2 : ValueTask<Result<'TResult2, ^Err>>
task3 : ValueTask<Result<'TResult3, ^Err>>
f : 'TResult1 * 'TResult2 * 'TResult3 -> EffectCode<'Env, 'TOverall, 'T, ^Err>
Returns: bool

EffBuilderBase.Bind4Dynamic(sm, task1, task2, task3, task4, f)

Full Usage: EffBuilderBase.Bind4Dynamic(sm, task1, task2, task3, task4, f)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'T, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TOverall, ^Err>>>
task1 : ValueTask<Result<'TResult1, ^Err>>
task2 : ValueTask<Result<'TResult2, ^Err>>
task3 : ValueTask<Result<'TResult3, ^Err>>
task4 : ValueTask<Result<'TResult4, ^Err>>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 -> EffectCode<'Env, 'TOverall, 'T, ^Err>
Returns: bool

EffBuilderBase.Bind5Dynamic(sm, task1, task2, task3, task4, task5, f)

Full Usage: EffBuilderBase.Bind5Dynamic(sm, task1, task2, task3, task4, task5, f)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'T, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TOverall, ^Err>>>
task1 : ValueTask<Result<'TResult1, ^Err>>
task2 : ValueTask<Result<'TResult2, ^Err>>
task3 : ValueTask<Result<'TResult3, ^Err>>
task4 : ValueTask<Result<'TResult4, ^Err>>
task5 : ValueTask<Result<'TResult5, ^Err>>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 -> EffectCode<'Env, 'TOverall, 'T, ^Err>
Returns: bool

EffBuilderBase.Bind6Dynamic(sm, task1, task2, task3, task4, task5, task6, f)

Full Usage: EffBuilderBase.Bind6Dynamic(sm, task1, task2, task3, task4, task5, task6, f)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'T, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, 'TResult6, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TOverall, ^Err>>>
task1 : ValueTask<Result<'TResult1, ^Err>>
task2 : ValueTask<Result<'TResult2, ^Err>>
task3 : ValueTask<Result<'TResult3, ^Err>>
task4 : ValueTask<Result<'TResult4, ^Err>>
task5 : ValueTask<Result<'TResult5, ^Err>>
task6 : ValueTask<Result<'TResult6, ^Err>>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 * 'TResult6 -> EffectCode<'Env, 'TOverall, 'T, ^Err>
Returns: bool

EffBuilderBase.Bind7Dynamic(sm, task1, task2, task3, task4, task5, task6, task7, f)

Full Usage: EffBuilderBase.Bind7Dynamic(sm, task1, task2, task3, task4, task5, task6, task7, f)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'T, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, 'TResult6, 'TResult7, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TOverall, ^Err>>>
task1 : ValueTask<Result<'TResult1, ^Err>>
task2 : ValueTask<Result<'TResult2, ^Err>>
task3 : ValueTask<Result<'TResult3, ^Err>>
task4 : ValueTask<Result<'TResult4, ^Err>>
task5 : ValueTask<Result<'TResult5, ^Err>>
task6 : ValueTask<Result<'TResult6, ^Err>>
task7 : ValueTask<Result<'TResult7, ^Err>>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 * 'TResult6 * 'TResult7 -> EffectCode<'Env, 'TOverall, 'T, ^Err>
Returns: bool

EffBuilderBase.ChangeErrorDynamic(sm, task, f)

Full Usage: EffBuilderBase.ChangeErrorDynamic(sm, task, f)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'TResult, 'Err1, 'Err2
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TResult, 'Err2>>>
task : ValueTask<Result<'TResult, 'Err1>>
f : 'Err1 -> 'Err2
Returns: bool

EffBuilderBase.CombineDynamic(sm, code1, code2)

Full Usage: EffBuilderBase.CombineDynamic(sm, code1, code2)

Parameters:
Returns: bool
Type parameters: 'a, 'TOverall, 'Err, 'T
sm : byref<ResumableStateMachine<EffectStateMachineData<'a, 'TOverall, 'Err>>>
code1 : EffectCode<'a, 'TOverall, unit, 'Err>
code2 : EffectCode<'a, 'TOverall, 'T, 'Err>
Returns: bool

EffBuilderBase.CreateWaiters(effects) (env)

Full Usage: EffBuilderBase.CreateWaiters(effects) (env)

Parameters:
    effects : Effect<'Env, 'T, 'Err> seq
    env : 'Env

Returns: ValueTaskAwaiter<Result<'T, 'Err>>[] * int * bool
Modifiers: inline
Type parameters: 'Env, 'T, 'Err
effects : Effect<'Env, 'T, 'Err> seq
env : 'Env
Returns: ValueTaskAwaiter<Result<'T, 'Err>>[] * int * bool

EffBuilderBase.GetResumptionFunc(sm)

Full Usage: EffBuilderBase.GetResumptionFunc(sm)

Parameters:
Returns: ResumptionFunc<'Data>
Modifiers: inline
Type parameters: 'Data
sm : byref<ResumableStateMachine<'Data>>
Returns: ResumptionFunc<'Data>

EffBuilderBase.HandleResults(sm, result1, result2, result3, result4, result5, result6, result7, f)

Full Usage: EffBuilderBase.HandleResults(sm, result1, result2, result3, result4, result5, result6, result7, f)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'a, 'b, ^c, 'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, 'TResult6, 'TResult7 (requires (static member op_Addition : ^c * ^c -> ^c))
sm : byref<ResumableStateMachine<EffectStateMachineData<'a, 'b, ^c>>>
result1 : Result<'TResult1, ^c>
result2 : Result<'TResult2, ^c>
result3 : Result<'TResult3, ^c>
result4 : Result<'TResult4, ^c>
result5 : Result<'TResult5, ^c>
result6 : Result<'TResult6, ^c>
result7 : Result<'TResult7, ^c>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 * 'TResult6 * 'TResult7 -> 'b
Returns: bool

EffBuilderBase.HandleResultsBind(sm, result1, result2, result3, result4, result5, result6, result7, f)

Full Usage: EffBuilderBase.HandleResultsBind(sm, result1, result2, result3, result4, result5, result6, result7, f)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'a, 'b, ^c, 'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, 'TResult6, 'TResult7, 'd (requires (static member op_Addition : ^c * ^c -> ^c))
sm : byref<ResumableStateMachine<EffectStateMachineData<'a, 'b, ^c>>>
result1 : Result<'TResult1, ^c>
result2 : Result<'TResult2, ^c>
result3 : Result<'TResult3, ^c>
result4 : Result<'TResult4, ^c>
result5 : Result<'TResult5, ^c>
result6 : Result<'TResult6, ^c>
result7 : Result<'TResult7, ^c>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 * 'TResult6 * 'TResult7 -> EffectCode<'a, 'b, 'd, ^c>
Returns: bool

EffBuilderBase.RecoverDynamic(sm, task, continuation)

Full Usage: EffBuilderBase.RecoverDynamic(sm, task, continuation)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'TResult, 'Err
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TResult, 'Err>>>
task : ValueTask<Result<'TResult, 'Err>>
continuation : 'Err -> 'TResult
Returns: bool

EffBuilderBase.TryRecoverDynamic(sm, task, continuation)

Full Usage: EffBuilderBase.TryRecoverDynamic(sm, task, continuation)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'TResult, 'Err
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TResult, 'Err>>>
task : ValueTask<Result<'TResult, 'Err>>
continuation : 'Err -> Effect<'Env, 'TResult, 'Err>
Returns: bool

EffBuilderBase.TryRecoverDynamic(sm, task, continuation)

Full Usage: EffBuilderBase.TryRecoverDynamic(sm, task, continuation)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'TResult, 'Err
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TResult, 'Err>>>
task : ValueTask<Result<'TResult, 'Err>>
continuation : 'Err -> Result<'TResult, 'Err>
Returns: bool

EffBuilderBase.WhenAllDynamic(sm, waits, results)

Full Usage: EffBuilderBase.WhenAllDynamic(sm, waits, results)

Parameters:
Returns: bool
Type parameters: 'a, 'b, 'c
sm : byref<EffectStateMachine<'a, 'b array, 'c>>
waits : Memory<ValueTaskAwaiter<Result<'b, 'c>>>
results : ResizeArray<Result<'b, 'c>>
Returns: bool

EffBuilderBase.WhileBodyDynamicAux(sm, condition, body, rf)

Full Usage: EffBuilderBase.WhileBodyDynamicAux(sm, condition, body, rf)

Parameters:
Returns: bool
Type parameters: 'Env, 'TOverall, 'Err
sm : byref<EffectStateMachine<'Env, 'TOverall, 'Err>>
condition : unit -> bool
body : EffectCode<'Env, 'TOverall, unit, 'Err>
rf : ResumptionFunc<EffectStateMachineData<'Env, 'TOverall, 'Err>>
Returns: bool

EffBuilderBase.WhileDynamic(sm, condition, body)

Full Usage: EffBuilderBase.WhileDynamic(sm, condition, body)

Parameters:
Returns: bool
Type parameters: 'Env, 'TOverall, 'Err
sm : byref<EffectStateMachine<'Env, 'TOverall, 'Err>>
condition : unit -> bool
body : EffectCode<'Env, 'TOverall, unit, 'Err>
Returns: bool

EffBuilderBase.ZipDynamic(sm, task1, task2, task3, task4, task5, task6, task7, f)

Full Usage: EffBuilderBase.ZipDynamic(sm, task1, task2, task3, task4, task5, task6, task7, f)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, 'TResult6, 'TResult7, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TOverall, ^Err>>>
task1 : ValueTask<Result<'TResult1, ^Err>>
task2 : ValueTask<Result<'TResult2, ^Err>>
task3 : ValueTask<Result<'TResult3, ^Err>>
task4 : ValueTask<Result<'TResult4, ^Err>>
task5 : ValueTask<Result<'TResult5, ^Err>>
task6 : ValueTask<Result<'TResult6, ^Err>>
task7 : ValueTask<Result<'TResult7, ^Err>>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 * 'TResult6 * 'TResult7 -> 'TOverall
Returns: bool

EffBuilderBase.ZipDynamic(sm, task1, task2, task3, task4, task5, task6, f)

Full Usage: EffBuilderBase.ZipDynamic(sm, task1, task2, task3, task4, task5, task6, f)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, 'TResult6, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TOverall, ^Err>>>
task1 : ValueTask<Result<'TResult1, ^Err>>
task2 : ValueTask<Result<'TResult2, ^Err>>
task3 : ValueTask<Result<'TResult3, ^Err>>
task4 : ValueTask<Result<'TResult4, ^Err>>
task5 : ValueTask<Result<'TResult5, ^Err>>
task6 : ValueTask<Result<'TResult6, ^Err>>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 * 'TResult6 -> 'TOverall
Returns: bool

EffBuilderBase.ZipDynamic(sm, task1, task2, task3, task4, task5, f)

Full Usage: EffBuilderBase.ZipDynamic(sm, task1, task2, task3, task4, task5, f)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TOverall, ^Err>>>
task1 : ValueTask<Result<'TResult1, ^Err>>
task2 : ValueTask<Result<'TResult2, ^Err>>
task3 : ValueTask<Result<'TResult3, ^Err>>
task4 : ValueTask<Result<'TResult4, ^Err>>
task5 : ValueTask<Result<'TResult5, ^Err>>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 * 'TResult5 -> 'TOverall
Returns: bool

EffBuilderBase.ZipDynamic(sm, task1, task2, task3, task4, f)

Full Usage: EffBuilderBase.ZipDynamic(sm, task1, task2, task3, task4, f)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'TOverall, 'TResult1, 'TResult2, 'TResult3, 'TResult4, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TOverall, ^Err>>>
task1 : ValueTask<Result<'TResult1, ^Err>>
task2 : ValueTask<Result<'TResult2, ^Err>>
task3 : ValueTask<Result<'TResult3, ^Err>>
task4 : ValueTask<Result<'TResult4, ^Err>>
f : 'TResult1 * 'TResult2 * 'TResult3 * 'TResult4 -> 'TOverall
Returns: bool

EffBuilderBase.ZipDynamic(sm, task1, task2, task3, f)

Full Usage: EffBuilderBase.ZipDynamic(sm, task1, task2, task3, f)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'TOverall, 'TResult1, 'TResult2, 'TResult3, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TOverall, ^Err>>>
task1 : ValueTask<Result<'TResult1, ^Err>>
task2 : ValueTask<Result<'TResult2, ^Err>>
task3 : ValueTask<Result<'TResult3, ^Err>>
f : 'TResult1 * 'TResult2 * 'TResult3 -> 'TOverall
Returns: bool

EffBuilderBase.ZipDynamic(sm, task1, task2, f)

Full Usage: EffBuilderBase.ZipDynamic(sm, task1, task2, f)

Parameters:
Returns: bool
Modifiers: inline
Type parameters: 'Env, 'TOverall, 'TResult1, 'TResult2, ^Err (requires (static member op_Addition : ^Err * ^Err -> ^Err))
sm : byref<ResumableStateMachine<EffectStateMachineData<'Env, 'TOverall, ^Err>>>
task1 : ValueTask<Result<'TResult1, ^Err>>
task2 : ValueTask<Result<'TResult2, ^Err>>
f : 'TResult1 * 'TResult2 -> 'TOverall
Returns: bool

Type something to start searching.