FSharpPlus

Plus Type

Namespace: FSharpPlus.Control
Assembly: FSharpPlus.dll
Base Type: Default1

Static members

Static member Description

Plus.Invoke(x) (y)

Full Usage: Plus.Invoke(x) (y)

Parameters:
    x : ^Plus
    y : ^Plus

Returns: ^Plus
Modifiers: inline
Type parameters: ^Plus

x : ^Plus
y : ^Plus
Returns: ^Plus

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: NonEmptySeq<'a>
Modifiers: inline

x : NonEmptySeq<'a>
y : NonEmptySeq<'a>
?_mthd : Default3
Returns: NonEmptySeq<'a>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: IReadOnlyDictionary<'K, ^V>
Modifiers: inline
Type parameters: 'K, ^V

x : IReadOnlyDictionary<'K, ^V>
y : IReadOnlyDictionary<'K, ^V>
?_mthd : Default3
Returns: IReadOnlyDictionary<'K, ^V>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: IDictionary<'K, ^V>
Modifiers: inline
Type parameters: 'K, ^V

x : IDictionary<'K, ^V>
y : IDictionary<'K, ^V>
?_mthd : Default3
Returns: IDictionary<'K, ^V>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: IEnumerator<'a>

x : IEnumerator<'a>
y : IEnumerator<'a>
?_mthd : Default3
Returns: IEnumerator<'a>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : seq<'a>
    y : seq<'a>
    ?_mthd : Default3

Returns: seq<'a>

x : seq<'a>
y : seq<'a>
?_mthd : Default3
Returns: seq<'a>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: IObservable<'a>

x : IObservable<'a>
y : IObservable<'a>
?_mthd : Default3
Returns: IObservable<'a>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : ResizeArray<'a>
    y : ResizeArray<'a>
    ?_mthd : Plus

Returns: ResizeArray<'a>

x : ResizeArray<'a>
y : ResizeArray<'a>
?_mthd : Plus
Returns: ResizeArray<'a>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Lazy<^a>
Modifiers: inline
Type parameters: ^a

x : Lazy<^a>
y : Lazy<^a>
?_mthd : Plus
Returns: Lazy<^a>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Expr<^a>
Modifiers: inline
Type parameters: ^a

x : Expr<^a>
y : Expr<^a>
?_mthd : Plus
Returns: Expr<^a>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Async<^S>
Modifiers: inline
Type parameters: ^S

x : Async<^S>
y : Async<^S>
?_mthd : Plus
Returns: Async<^S>

Plus.``+``(f, g, ?_mthd)

Full Usage: Plus.``+``(f, g, ?_mthd)

Parameters:
    f : 'T -> ^Monoid
    g : 'T -> ^Monoid
    ?_mthd : Plus

Returns: 'T -> ^Monoid
Modifiers: inline
Type parameters: 'T, ^Monoid

f : 'T -> ^Monoid
g : 'T -> ^Monoid
?_mthd : Plus
Returns: 'T -> ^Monoid

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Dictionary<'Key, ^Value>
Modifiers: inline
Type parameters: 'Key, ^Value

x : Dictionary<'Key, ^Value>
y : Dictionary<'Key, ^Value>
?_mthd : Plus
Returns: Dictionary<'Key, ^Value>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Map<'a, ^b>
Modifiers: inline
Type parameters: 'a, ^b

x : Map<'a, ^b>
y : Map<'a, ^b>
?_mthd : Plus
Returns: Map<'a, ^b>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Task<^a>
Modifiers: inline
Type parameters: ^a

x : Task<^a>
y : Task<^a>
?_mthd : Plus
Returns: Task<^a>

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
    arg1 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d * ^e * ^f * ^g
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d, ^e, ^f, ^g

arg0 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
arg1 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d * ^e * ^f * ^g

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d * ^e * ^f
    arg1 : ^a * ^b * ^c * ^d * ^e * ^f
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d * ^e * ^f
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d, ^e, ^f

arg0 : ^a * ^b * ^c * ^d * ^e * ^f
arg1 : ^a * ^b * ^c * ^d * ^e * ^f
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d * ^e * ^f

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d * ^e
    arg1 : ^a * ^b * ^c * ^d * ^e
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d * ^e
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d, ^e

arg0 : ^a * ^b * ^c * ^d * ^e
arg1 : ^a * ^b * ^c * ^d * ^e
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d * ^e

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d
    arg1 : ^a * ^b * ^c * ^d
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d

arg0 : ^a * ^b * ^c * ^d
arg1 : ^a * ^b * ^c * ^d
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c
    arg1 : ^a * ^b * ^c
    ?_mthd : Plus

Returns: ^a * ^b * ^c
Modifiers: inline
Type parameters: ^a, ^b, ^c

arg0 : ^a * ^b * ^c
arg1 : ^a * ^b * ^c
?_mthd : Plus
Returns: ^a * ^b * ^c

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b
    arg1 : ^a * ^b
    ?_mthd : Plus

Returns: ^a * ^b
Modifiers: inline
Type parameters: ^a, ^b

arg0 : ^a * ^b
arg1 : ^a * ^b
?_mthd : Plus
Returns: ^a * ^b

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: ValueTuple<^a>
Modifiers: inline
Type parameters: ^a

x : ValueTuple<^a>
y : ValueTuple<^a>
?_mthd : Plus
Returns: ValueTuple<^a>

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
    arg1 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d * ^e * ^f * ^g
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d, ^e, ^f, ^g

arg0 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
arg1 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d * ^e * ^f * ^g

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d * ^e * ^f
    arg1 : ^a * ^b * ^c * ^d * ^e * ^f
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d * ^e * ^f
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d, ^e, ^f

arg0 : ^a * ^b * ^c * ^d * ^e * ^f
arg1 : ^a * ^b * ^c * ^d * ^e * ^f
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d * ^e * ^f

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d * ^e
    arg1 : ^a * ^b * ^c * ^d * ^e
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d * ^e
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d, ^e

arg0 : ^a * ^b * ^c * ^d * ^e
arg1 : ^a * ^b * ^c * ^d * ^e
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d * ^e

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d
    arg1 : ^a * ^b * ^c * ^d
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d

arg0 : ^a * ^b * ^c * ^d
arg1 : ^a * ^b * ^c * ^d
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c
    arg1 : ^a * ^b * ^c
    ?_mthd : Plus

Returns: ^a * ^b * ^c
Modifiers: inline
Type parameters: ^a, ^b, ^c

arg0 : ^a * ^b * ^c
arg1 : ^a * ^b * ^c
?_mthd : Plus
Returns: ^a * ^b * ^c

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b
    arg1 : ^a * ^b
    ?_mthd : Plus

Returns: ^a * ^b
Modifiers: inline
Type parameters: ^a, ^b

arg0 : ^a * ^b
arg1 : ^a * ^b
?_mthd : Plus
Returns: ^a * ^b

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Tuple<^a>
Modifiers: inline
Type parameters: ^a

x : Tuple<^a>
y : Tuple<^a>
?_mthd : Plus
Returns: Tuple<^a>

Plus.``+``(x, y, _mthd)

Full Usage: Plus.``+``(x, y, _mthd)

Parameters:
    x : ^t
    y : ^t
    _mthd : Plus

Returns: ^t
Modifiers: inline
Type parameters: ^t, ^tr, ^t7, ^t6, ^t5, ^t4, ^t3, ^t2, ^t1

x : ^t
y : ^t
_mthd : Plus
Returns: ^t

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Choice<^a, ^b>
Modifiers: inline

x : Choice<^a, ^b>
y : Choice<^a, ^b>
?_mthd : Plus
Returns: Choice<^a, ^b>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Result<^a, ^b>
Modifiers: inline

x : Result<^a, ^b>
y : Result<^a, ^b>
?_mthd : Plus
Returns: Result<^a, ^b>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : ^a voption
    y : ^a voption
    ?_mthd : Plus

Returns: ^a voption
Modifiers: inline

x : ^a voption
y : ^a voption
?_mthd : Plus
Returns: ^a voption

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : ^a option
    y : ^a option
    ?_mthd : Plus

Returns: ^a option
Modifiers: inline

x : ^a option
y : ^a option
?_mthd : Plus
Returns: ^a option

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : exn
    y : exn
    ?_mthd : Plus

Returns: exn

x : exn
y : exn
?_mthd : Plus
Returns: exn

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: AggregateException

x : AggregateException
y : AggregateException
?_mthd : Plus
Returns: AggregateException

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
Returns: Id0

arg0 : Id0
arg1 : Id0
?_mthd : Plus
Returns: Id0

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: StringBuilder

x : StringBuilder
y : StringBuilder
?_mthd : Plus
Returns: StringBuilder

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Set<'a>

x : Set<'a>
y : Set<'a>
?_mthd : Plus
Returns: Set<'a>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : bool
    y : bool
    ?_mthd : Plus

Returns: bool

x : bool
y : bool
?_mthd : Plus
Returns: bool

Plus.``+``((), (), ?_mthd)

Full Usage: Plus.``+``((), (), ?_mthd)

Parameters:
    () : unit
    () : unit
    ?_mthd : Plus

() : unit
() : unit
?_mthd : Plus

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : 'a array
    y : 'a[]
    ?_mthd : Plus

Returns: 'a[]

x : 'a array
y : 'a[]
?_mthd : Plus
Returns: 'a[]

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : 'a list
    y : 'a list
    ?_mthd : Plus

Returns: 'a list

x : 'a list
y : 'a list
?_mthd : Plus
Returns: 'a list

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
Returns: 'a -> 'a
Modifiers: inline

arg0 : ^t
arg1 : ^t
?_mthd : Default1
Returns: 'a -> 'a

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: ^Plus
Modifiers: inline
Type parameters: ^Plus

x : ^Plus
y : ^Plus
?_mthd : Default1
Returns: ^Plus

Plus.``+``(x, y, _mthd)

Full Usage: Plus.``+``(x, y, _mthd)

Parameters:
Returns: ^Plus
Modifiers: inline
Type parameters: ^Plus

x : ^Plus
y : ^Plus
_mthd : Default2
Returns: ^Plus