Here are some other abstractions, not present in the diagram.
(see the examples)
#r @"../../src/FSharpPlus/bin/Release/net45/FSharpPlus.dll"
open System
open FSharpPlus
open FSharpPlus.Data
// Indexable
let namesWithNdx = mapi (fun k v -> "(" + string k + ")" + v ) (Map.ofSeq ['f',"Fred";'p',"Paul"])
let namesAction = iteri (printfn "(%A)%s") (Map.ofSeq ['f',"Fred";'p',"Paul"])
let res119 = foldi (fun s i t -> t * s - i) 10 [3;4]
let res113 = foldi (fun s i t -> t * s - i) 2 [|3;4;5|]
let resSomeId20 = traversei (fun k t -> Some (10 + t)) (Tuple 10)
// ZipFunctor
let (x, y) = zip (async { return 1 }) (async { return '2' }) |> Async.RunSynchronously
// Collection
let a = skip 3 [1..10]
let b = chunkBy fst [1, "a"; 1, "b"; 2, "c"; 1, "d"]
// Reducibles
let c = nelist {1; 2; 3}
let d = reduce (+) c
let resultList = nelist {Error "1"; Error "2"; Ok 3; Ok 4; Error "5"}
let firstOk = choice resultList
// Invariant Functor
type StringConverter<'t> = StringConverter of (string -> 't) * ('t -> string) with
static member Invmap (StringConverter (f, g), f',g') = StringConverter (f' << f, g << g')
let ofString (StringConverter (f, _)) = f
let toString (StringConverter (_, f)) = f
let floatConv = StringConverter (float<string>, string<float>)
let floatParsed = ofString floatConv "1.8"
let floatEncoded = toString floatConv 1.5
let intConv = invmap int<float> float<int> floatConv
let oneParsed = ofString intConv "1"
let tenEncoded = toString intConv 10
namespace System
namespace FSharpPlus
namespace FSharpPlus.Data
val namesWithNdx: Map<char,string>
val mapi: mapping: ('K -> 'T -> 'U) -> source: 'FunctorWithIndex<'T> -> 'FunctorWithIndex<'U> (requires member MapIndexed)
<summary>
Maps with access to the index.
</summary>
<category index="16">Indexable</category>
val k: char
val v: string
Multiple items
val string: value: 'T -> string
<summary>Converts the argument to a string using <c>ToString</c>.</summary>
<remarks>For standard integer and floating point values the and any type that implements <c>IFormattable</c><c>ToString</c> conversion uses <c>CultureInfo.InvariantCulture</c>. </remarks>
<param name="value">The input value.</param>
<returns>The converted string.</returns>
<example id="string-example"><code lang="fsharp"></code></example>
--------------------
type string = String
<summary>An abbreviation for the CLI type <see cref="T:System.String" />.</summary>
<category>Basic Types</category>
Multiple items
module Map
from FSharpPlus
<summary>
Additional operations on Map<'Key, 'Value>
</summary>
--------------------
module Map
from Microsoft.FSharp.Collections
<summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.FSharpMap`2" />.</summary>
--------------------
type Map<'Key,'Value (requires comparison)> =
interface IReadOnlyDictionary<'Key,'Value>
interface IReadOnlyCollection<KeyValuePair<'Key,'Value>>
interface IEnumerable
interface IComparable
interface IEnumerable<KeyValuePair<'Key,'Value>>
interface ICollection<KeyValuePair<'Key,'Value>>
interface IDictionary<'Key,'Value>
new: elements: seq<'Key * 'Value> -> Map<'Key,'Value>
member Add: key: 'Key * value: 'Value -> Map<'Key,'Value>
member Change: key: 'Key * f: ('Value option -> 'Value option) -> Map<'Key,'Value>
...
<summary>Immutable maps based on binary trees, where keys are ordered by F# generic comparison. By default
comparison is the F# structural comparison function or uses implementations of the IComparable interface on key values.</summary>
<remarks>See the <see cref="T:Microsoft.FSharp.Collections.MapModule" /> module for further operations on maps.
All members of this class are thread-safe and may be used concurrently from multiple threads.</remarks>
--------------------
new: elements: seq<'Key * 'Value> -> Map<'Key,'Value>
val ofSeq: elements: seq<'Key * 'T> -> Map<'Key,'T> (requires comparison)
<summary>Returns a new map made from the given bindings.</summary>
<param name="elements">The input sequence of key/value pairs.</param>
<returns>The resulting map.</returns>
<example id="ofseq-1"><code lang="fsharp">
let input = seq { (1, "a"); (2, "b") }
input |> Map.ofSeq // evaluates to map [(1, "a"); (2, "b")]
</code></example>
val namesAction: unit
val iteri: action: ('K -> 'T -> unit) -> source: 'FunctorWithIndex<'T> -> unit (requires member IterateIndexed)
<summary>
Maps an action with access to an index.
</summary>
<category index="16">Indexable</category>
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
<summary>Print to <c>stdout</c> using the given format, and add a newline.</summary>
<param name="format">The formatter.</param>
<returns>The formatted result.</returns>
<example>See <c>Printf.printfn</c> (link: <see cref="M:Microsoft.FSharp.Core.PrintfModule.PrintFormatLine``1" />) for examples.</example>
val res119: int
val foldi: folder: ('State -> 'K -> 'T -> 'State) -> state: 'State -> source: 'FoldableWithIndex<'T> -> 'State (requires member FoldIndexed)
<summary>
Left-associative fold of an indexed container with access to the index i.
</summary>
<category index="16">Indexable</category>
val s: int
val i: int
val t: int
val res113: int
val resSomeId20: Tuple<int> option
val traversei: f: ('K -> 'T -> 'Applicative<'U>) -> t: 'Traversable<'T>> -> 'Applicative<'Traversable<'U>> (requires member TraverseIndexed)
<summary>
Traverses an indexed container. Behaves exactly like a regular traverse except that the traversing function also has access to the key associated with a value.
</summary>
<category index="16">Indexable</category>
val k: unit
union case Option.Some: Value: 'T -> Option<'T>
<summary>The representation of "Value of type 'T"</summary>
<param name="Value">The input value.</param>
<returns>An option representing the value.</returns>
Multiple items
type Tuple =
static member Create<'T1> : item1: 'T1 -> Tuple<'T1> + 7 overloads
<summary>Provides static methods for creating tuple objects.</summary>
--------------------
type Tuple<'T1> =
interface IStructuralComparable
interface IStructuralEquatable
interface IComparable
interface ITuple
new: item1: 'T1 -> unit
member Equals: obj: obj -> bool
member GetHashCode: unit -> int
member ToString: unit -> string
member Item1: 'T1
<summary>Represents a 1-tuple, or singleton.</summary>
<typeparam name="T1">The type of the tuple's only component.</typeparam>
--------------------
--------------------
--------------------
--------------------
--------------------
--------------------
--------------------
type Tuple<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'TRest> =
interface IStructuralComparable
interface IStructuralEquatable
interface IComparable
interface ITuple
new: item1: 'T1 * item2: 'T2 * item3: 'T3 * item4: 'T4 * item5: 'T5 * item6: 'T6 * item7: 'T7 * rest: 'TRest -> unit
member Equals: obj: obj -> bool
member GetHashCode: unit -> int
member ToString: unit -> string
member Item1: 'T1
member Item2: 'T2
...
<summary>Represents an n-tuple, where n is 8 or greater.</summary>
<typeparam name="T1">The type of the tuple's first component.</typeparam>
<typeparam name="T2">The type of the tuple's second component.</typeparam>
<typeparam name="T3">The type of the tuple's third component.</typeparam>
<typeparam name="T4">The type of the tuple's fourth component.</typeparam>
<typeparam name="T5">The type of the tuple's fifth component.</typeparam>
<typeparam name="T6">The type of the tuple's sixth component.</typeparam>
<typeparam name="T7">The type of the tuple's seventh component.</typeparam>
<typeparam name="TRest">Any generic <see langword="Tuple" /> object that defines the types of the tuple's remaining components.</typeparam>
--------------------
Tuple(item1: 'T1) : Tuple<'T1>
--------------------
Tuple(item1: 'T1, item2: 'T2) : 'T1 * 'T2
--------------------
Tuple(item1: 'T1, item2: 'T2, item3: 'T3) : 'T1 * 'T2 * 'T3
--------------------
Tuple(item1: 'T1, item2: 'T2, item3: 'T3, item4: 'T4) : 'T1 * 'T2 * 'T3 * 'T4
--------------------
Tuple(item1: 'T1, item2: 'T2, item3: 'T3, item4: 'T4, item5: 'T5) : 'T1 * 'T2 * 'T3 * 'T4 * 'T5
--------------------
Tuple(item1: 'T1, item2: 'T2, item3: 'T3, item4: 'T4, item5: 'T5, item6: 'T6) : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6
--------------------
Tuple(item1: 'T1, item2: 'T2, item3: 'T3, item4: 'T4, item5: 'T5, item6: 'T6, item7: 'T7) : 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7
--------------------
Tuple(item1: 'T1, item2: 'T2, item3: 'T3, item4: 'T4, item5: 'T5, item6: 'T6, item7: 'T7, rest: 'TRest) : Tuple<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'TRest>
val x: int
val y: char
val zip: source1: 'ZipFunctor<'T1> -> source2: 'ZipFunctor<'T2> -> 'ZipFunctor<'T1 * 'T2> (requires member Zip)
<summary>
Zips (tuple) two functors.
</summary>
<remarks>
For collections, if one collection is shorter, excess elements are discarded from the right end of the longer collection.
</remarks>
<category index="1">Functor</category>
val async: AsyncBuilder
<summary>Builds an asynchronous workflow using computation expression syntax.</summary>
<example id="async-1"><code lang="fsharp">
let sleepExample() =
async {
printfn "sleeping"
do! Async.Sleep 10
printfn "waking up"
return 6
}
sleepExample() |> Async.RunSynchronously
</code></example>
Multiple items
module Async
from FSharpPlus
<summary>
Additional operations on Async
</summary>--------------------
type Async =
static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)
static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate)
static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool>
static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload
static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool>
static member CancelDefaultToken: unit -> unit
static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>>
static member Choice: computations: seq<Async<'T option>> -> Async<'T option>
static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads
static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
...
<summary>Holds static members for creating and manipulating asynchronous computations.</summary>
<remarks>
See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">F# Language Guide - Async Workflows</a>.
</remarks>
<category index="1">Async Programming</category>--------------------
type Async<'T>
<summary>
An asynchronous computation, which, when run, will eventually produce a value of type T, or else raises an exception.
</summary>
<remarks>
This type has no members. Asynchronous computations are normally specified either by using an async expression
or the static methods in the <see cref="T:Microsoft.FSharp.Control.FSharpAsync`1" /> type.
See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">F# Language Guide - Async Workflows</a>.
</remarks>
<namespacedoc><summary>
Library functionality for asynchronous programming, events and agents. See also
<a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">Asynchronous Programming</a>,
<a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/members/events">Events</a> and
<a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/lazy-expressions">Lazy Expressions</a> in the
F# Language Guide.
</summary></namespacedoc>
<category index="1">Async Programming</category>static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: Threading.CancellationToken -> 'T
val a: int list
val skip: count: int -> source: 'Collection<'T> -> 'Collection<'T> (requires member Skip)
<summary>Returns a collection that skips N elements of the original collection and then yields the
remaining elements of the collection.</summary>
<category index="19">Collection</category>
<remarks>Throws <c>InvalidOperationException</c>
when count exceeds the number of elements in the collection. <c>drop</c>
returns an empty collection instead of throwing an exception.</remarks>
<param name="count">The number of items to skip.</param>
<param name="source">The input collection.</param>
<returns>The result collection.</returns>
<exception cref="System.ArgumentNullException">Thrown when the input collection is null.</exception>
<exception cref="System.InvalidOperationException">Thrown when count exceeds the number of elements
in the collection.</exception>
val b: (int * (int * string) list) list
val chunkBy: projection: ('T -> 'Key) -> source: 'Collection<'T> -> 'Collection<'Key * 'Collection<'T>> (requires equality and member ChunkBy)
<summary>Applies a key-generating function to each element of a collection and yields a collection of
keys tupled with values. Each key contains a collection of all adjacent elements that match
to this key, therefore keys are not unique but they can't be adjacent
as each time the key changes, a new group is yield.</summary>
<category index="19">Collection</category>
<remarks>The ordering of the original collection is respected.</remarks>
<param name="projection">A function that transforms an element of the collection into a comparable key.</param>
<param name="source">The input collection.</param>
<returns>The result collection.</returns>
val fst: tuple: ('T1 * 'T2) -> 'T1
<summary>Return the first element of a tuple, <c>fst (a,b) = a</c>.</summary>
<param name="tuple">The input tuple.</param>
<returns>The first value.</returns>
<example id="fst-example"><code lang="fsharp">
fst ("first", 2) // Evaluates to "first"
</code></example>
val c: NonEmptyList<int>
Multiple items
val nelist: NelBuilder
--------------------
type nelist<'t> = NonEmptyList<'t>
<summary>
A type alias for NonEmptyList<'t>
</summary>
val d: int
val reduce: reduction: ('T -> 'T -> 'T) -> source: 'Reducible<'T> -> 'T (requires member Reduce)
<summary>Applies a function to each element of the reducible, threading an accumulator argument
through the computation. Apply the function to the first two elements of the reducible.
Then feed this result into the function along with the third element and so on.
Return the final result. If the input function is <c>f</c> and the elements are <c>i0...iN</c> then computes
<c>f (... (f i0 i1) i2 ...) iN</c>.</summary>
<category index="12">Reducible</category>
<param name="reduction">The function to reduce two reducible elements to a single element.</param>
<param name="source">The input reducible.</param>
<returns>The final reduced value.</returns>
val resultList: NonEmptyList<Result<int,string>>
union case Result.Error: ErrorValue: 'TError -> Result<'T,'TError>
<summary>
Represents an Error or a Failure. The code failed with a value of 'TError representing what went wrong.
</summary>
union case Result.Ok: ResultValue: 'T -> Result<'T,'TError>
<summary>
Represents an OK or a Successful result. The code succeeded with a value of 'T.
</summary>
val firstOk: Result<int,string>
val choice: x: 'Foldable<'Alternative<'T>> -> 'Alternative<'T>> (requires member Choice)
<summary>
Reduces using alternative operator `<|>`.
</summary>
<category index="23">Additional Functions</category>
Multiple items
union case StringConverter.StringConverter: (string -> 't) * ('t -> string) -> StringConverter<'t>
--------------------
type StringConverter<'t> =
| StringConverter of (string -> 't) * ('t -> string)
static member Invmap: StringConverter<'a> * f': ('a -> 'b) * g': ('b -> 'a) -> StringConverter<'b>
val f: (string -> 'a)
val g: ('a -> string)
val f': ('a -> 'b)
val g': ('b -> 'a)
val ofString: StringConverter<'a> -> (string -> 'a)
val toString: StringConverter<'a> -> ('a -> string)
val f: ('a -> string)
val floatConv: StringConverter<float>
Multiple items
val float: value: 'T -> float (requires member op_Explicit)
<summary>Converts the argument to 64-bit float. This is a direct conversion for all
primitive numeric types. For strings, the input is converted using <c>Double.Parse()</c>
with InvariantCulture settings. Otherwise the operation requires an appropriate
static conversion method on the input type.</summary>
<param name="value">The input value.</param>
<returns>The converted float</returns>
<example id="float-example"><code lang="fsharp"></code></example>
--------------------
[<Struct>]
type float = Double
<summary>An abbreviation for the CLI type <see cref="T:System.Double" />.</summary>
<category>Basic Types</category>
--------------------
type float<'Measure> =
float
<summary>The type of double-precision floating point numbers, annotated with a unit of measure.
The unit of measure is erased in compiled code and when values of this type
are analyzed using reflection. The type is representationally equivalent to
<see cref="T:System.Double" />.</summary>
<category index="6">Basic Types with Units of Measure</category>
val floatParsed: float
val floatEncoded: string
val intConv: StringConverter<int>
val invmap: f: ('T -> 'U) -> g: ('U -> 'T) -> source: 'InvariantFunctor<'T> -> 'InvariantFunctor<'U> (requires member Invmap)
<summary>
Maps a pair of functions over an Invariant Functor
</summary>
<category index="6">Contravariant/Bifunctor/Profunctor/Invariant</category>
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
<summary>Converts the argument to signed 32-bit integer. This is a direct conversion for all
primitive numeric types. For strings, the input is converted using <c>Int32.Parse()</c>
with InvariantCulture settings. Otherwise the operation requires an appropriate
static conversion method on the input type.</summary>
<param name="value">The input value.</param>
<returns>The converted int</returns>
<example id="int-example"><code lang="fsharp"></code></example>
--------------------
[<Struct>]
type int = int32
<summary>An abbreviation for the CLI type <see cref="T:System.Int32" />.</summary>
<category>Basic Types</category>
--------------------
type int<'Measure> =
int
<summary>The type of 32-bit signed integer numbers, annotated with a unit of measure. The unit
of measure is erased in compiled code and when values of this type
are analyzed using reflection. The type is representationally equivalent to
<see cref="T:System.Int32" />.</summary>
<category>Basic Types with Units of Measure</category>
val oneParsed: int
val tenEncoded: string