Update docs

Author: gusty

docsrc/content/abstraction-alternative.fsx

@@ -10,16 +10,16 @@ Applicative Functors which also have a monoid structure.
 ___
 Minimal complete definition
 ---------------------------
- * ``return x``/``result x`` 
+ * ``return x``   /   ``result x``
  * ``(<*>) f x``
  * ``empty``
- * ``append x y``/``(<|>) x y``
+ * ``append x y`` &nbsp; / &nbsp; ``(<|>) x y``
 *)
 (**
-    static member Return (x:'T) : 'Alternative<'T>
-    static member (<*>) (f:'T->'U, x:Alternative<'T>) : Alternative<'U>
-    static member get_Empty () :'Alternative
-    static member (<|>) (x:'Alternative<'T>, y:'Alternative<'T>) :'Alternative<'T>
+    static member Return (x: 'T) : 'Alternative<'T>
+    static member (<*>) (f: 'T -> 'U, x: 'Alternative<'T>) : 'Alternative<'U>
+    static member get_Empty () : 'Alternative
+    static member (<|>) (x: 'Alternative<'T>, y: 'Alternative<'T>) : 'Alternative<'T>
 *)
 (**
 Note: ``return`` can't be used outside computation expressions, use ``result`` instead.
@@ -56,13 +56,16 @@ Concrete implementations
 From .Net/F#
  
  -  ``list<'T>``
- -  ``option<'T>``
  -  ``array<'T>``
  -  ``seq<'T>``
+ -  ``option<'T>``
+ -  ``voption<'T>``
+ -  ``Result<'T, 'Monoid>``
+ -  ``Choice<'T, 'Monoid>``
  -  ``'T -> 'Alternative``
- 
+
 From F#+
- 
+
  -  [``ReaderT<'R, 'MonadPlus<'T>>``](type-readert.html)
  -  [``WriterT<'MonadPlus<'T * 'Monoid>>``](type-writert.html)
  -  [``StateT<'S,'MonadPlus<'T * 'S>>``](type-statet.html)
@@ -73,7 +76,12 @@ From F#+
  -  [``Compose<'AlternativeF<'AlternativeG<'T>>>``](type-compose.html)
  -  [``DList<'T>``](type-dlist.html)
  -  [``ZipList<'S>``](type-ziplist.html)
- 
+ -  [``NonEmptySeq<'T>``](type-nonemptyseq.html) ``*``
+ -  [``Validation<'Error, 'T>``](type-validation.html) ``*``
+
+``*`` Only ``<|>`` operation
+
+
  [Suggest another](https://github.com/fsprojects/FSharpPlus/issues/new) concrete implementation
 
 Examples

docsrc/content/abstraction-applicative.fsx

@@ -10,12 +10,12 @@ A functor with application, providing operations to embed pure expressions (``re
 ___
 Minimal complete definition
 ---------------------------
- * ``return x``/``result x`` 
+ * ``return x``   /   ``result x``
  * ``(<*>) f x``
 *)
 (**
-    static member Return (x:'T) : 'Applicative<'T>
-    static member (<*>) (f: 'Applicative<'T->'U>, x: 'Applicative<'T>) : 'Applicative<'U>
+    static member Return (x: 'T) : 'Applicative<'T>
+    static member (<*>) (f: 'Applicative<'T -> 'U>, x: 'Applicative<'T>) : 'Applicative<'U>
 *)
 (**
 Note: ``return`` can't be used outside computation expressions, use ``result`` instead.
@@ -27,7 +27,7 @@ Other operations
 * ``lift2``
 *)
 (**
-   static member Lift2 (f: 'T1->'T2->'T, x1: 'Applicative<'T1>, x2: 'Applicative<'T2>) : 'Applicative<'T>
+   static member Lift2 (f: 'T1 -> 'T2 -> 'T, x1: 'Applicative<'T1>, x2: 'Applicative<'T2>) : 'Applicative<'T>
 *)
 (**
 
@@ -131,13 +131,13 @@ open FSharpPlus
 open FSharpPlus.Data
 
 // Apply +4 to a list
-let lst5n6  = map ((+) 4) [ 1;2 ]
+let lst5n6  = map ((+) 4) [ 1; 2 ]
 
 // Apply +4 to an array
-let arr5n6  = map ((+) 4) [|1;2|]
+let arr5n6  = map ((+) 4) [|1; 2|]
 
 // I could have written this
-let arr5n6' = (+) <!> [|4|] <*> [|1;2|]
+let arr5n6' = (+) <!> [|4|] <*> [|1; 2|]
 
 // Add two options
 let opt120  = (+) <!> Some 20 <*> tryParse "100"
@@ -198,7 +198,7 @@ open FSharpPlus.Math.Applicative
 let opt121'  = Some 21 .+. tryParse "100"
 let optTrue  = 30 >. tryParse "29"
 let optFalse = tryParse "30" .< 29
-let m1m2m3 = -.[1;2;3]
+let m1m2m3 = -.[1; 2; 3]
 
 
 // Using applicative computation expression
@@ -245,7 +245,7 @@ let person6 = applicative2 {
 // A Monad is automatically an Applicative
 
 type MyList<'s> = MyList of 's seq with
-    static member Return (x:'a)     = MyList (Seq.singleton x)
+    static member Return (x: 'a) = MyList (Seq.singleton x)
     static member (>>=)  (MyList x: MyList<'T>, f) = MyList (Seq.collect (f >> (fun (MyList x) -> x)) x)
 
-let mappedMyList : MyList<_> = (MyList [(+) 1;(+) 2;(+) 3]) <*> (MyList [1;2;3])
+let mappedMyList : MyList<_> = (MyList [(+) 1; (+) 2; (+) 3]) <*> (MyList [1; 2; 3])

docsrc/content/abstraction-bifoldable.fsx

@@ -79,14 +79,14 @@ From .Net/F#
  
  -  ``'T * 'U``
  -  ``struct ('T * 'U)``
- -  ``Result<'T,'U>``
- -  ``Choice<'T,'U>``
+ -  ``Result<'T, 'U>``
+ -  ``Choice<'T, 'U>``
 
  
 From F#+
 
- -  [``Const<'C,'T>``](type-const.html)
- -  [``Validation<'err,'a>``](type-validation.html)
+ -  [``Const<'C, 'T>``](type-const.html)
+ -  [``Validation<'Error, 'T>``](type-validation.html)
 
  [Suggest another](https://github.com/fsprojects/FSharpPlus/issues/new) concrete implementation
 

docsrc/content/abstraction-bifunctor.fsx

@@ -68,15 +68,15 @@ From .Net/F#
  
  -  ``'T1 * 'T2``
  -  ``struct ('T1 * 'T2)``
- -  ``Result<'T2,'T1>``
- -  ``Choice<'T2,'T1>``
- -  ``KeyValuePair<'T1,'T2>``
+ -  ``Result<'T2, 'T1>``
+ -  ``Choice<'T2, 'T1>``
+ -  ``KeyValuePair<'T1, 'T2>``
 
  
 From F#+
 
- -  [``Const<'C,'T>``](type-const.html)
- -  [``Validation<'Error,'T>``](type-validation.html)
+ -  [``Const<'C, 'T>``](type-const.html)
+ -  [``Validation<'Error, 'T>``](type-validation.html)
 
  [Suggest another](https://github.com/fsprojects/FSharpPlus/issues/new) concrete implementation
 

docsrc/content/abstraction-bitraversable.fsx

@@ -54,14 +54,14 @@ From .Net/F#
 
 -  ``'T * 'U``
 -  ``struct ('T * 'U)``
--  ``Result<'T,'U>``
--  ``Choice<'T,'U>``
+-  ``Result<'T, 'U>``
+-  ``Choice<'T, 'U>``
 
 
 From F#+
 
- -  [``Const<'C,'T>``](type-const.html)
- -  [``Validation<'Error,'T>``](type-validation.html)
+ -  [``Const<'C, 'T>``](type-const.html)
+ -  [``Validation<'Error, 'T>``](type-validation.html)
 
 
  [Suggest another](https://github.com/fsprojects/FSharpPlus/issues/new) concrete implementation

docsrc/content/abstraction-category.fsx

@@ -55,8 +55,8 @@ Concrete implementations
 
 From .Net/F#
  
- -  ``'T->'U``
- -  ``Func<'T,'U>``
+ -  ``'T -> 'U``
+ -  ``Func<'T, 'U>``
 
  
 From F#+

docsrc/content/abstraction-functor.fsx

@@ -10,18 +10,18 @@ The Functor abstraction is used for types that can be mapped over.
 ___
 Minimal complete definition
 ---------------------------
- * ``map f x``/``(|>>) x f``/``(<<|) f x``/``(<!>) f x``
+ * ``map f x`` &nbsp; / &nbsp; ``(|>>) x f`` &nbsp; / &nbsp; ``(<<|) f x`` &nbsp; / &nbsp; ``(<!>) f x``
 *)
 (**
-    static member Map (x:'Functor<'T>, f:'T->'U) :'Functor<'U>
+    static member Map (x: 'Functor<'T>, f: 'T -> 'U) : 'Functor<'U>
 *)
 (**
 Other operations
 ----------------
  * ``unzip x``
 *)
 (**
-    static member Unzip (x:Functor<'T * 'U>) :'Functor<'T> * 'Functor<'U>
+    static member Unzip (x: 'Functor<'T * 'U>) : 'Functor<'T> * 'Functor<'U>
 *)
 (**
 Rules
@@ -54,49 +54,49 @@ From F#
  -  ``Async<'T>``
  -  ``Result<'T,'U>``
  -  ``Choice<'T,'U>``
- -  ``KeyValuePair<'Key,'T>``
+ -  ``KeyValuePair<'Key, 'T>``
  -  ``Map<'Key,'T>``
  -  ``'Monoid * 'T``
  -  ``'struct ('Monoid * 'T)``
  -  ``Task<'T>``
  -  ``ValueTask<'T>``
  -  ``'R->'T``
  -  ``Expr<'T>``
- -  ``Dictionary<'Key,'T>``
- -  ``IDictionary<'Key,'T>``
- -  ``IReadOnlyDictionary<'Key,'T>``
+ -  ``Dictionary<'Key, 'T>``
+ -  ``IDictionary<'Key,' T>``
+ -  ``IReadOnlyDictionary<'Key, 'T>``
  -  ``ResizeArray<'T>``
  
 From F#+
 
- -  [``Cont<'R,'T>``](type-cont.html)
- -  [``ContT<'R,'T>``](type-contt.html)
- -  [``Reader<'R,'T>``](type-reader.html)
- -  [``ReaderT<'R,'Monad<'T>>``](type-readert.html)
- -  [``Writer<'Monoid,'T>``](type-writer.html)
+ -  [``Cont<'R, 'T>``](type-cont.html)
+ -  [``ContT<'R, 'T>``](type-contt.html)
+ -  [``Reader<'R, 'T>``](type-reader.html)
+ -  [``ReaderT<'R, 'Monad<'T>>``](type-readert.html)
+ -  [``Writer<'Monoid, 'T>``](type-writer.html)
  -  [``WriterT<'Monad<'T * 'Monoid>>``](type-writert.html)
- -  [``State<'S,'T * 'S>``](type-state.html)
- -  [``StateT<'S,'Monad<'T * 'S>>``](type-statet.html)
+ -  [``State<'S, 'T * 'S>``](type-state.html)
+ -  [``StateT<'S, 'Monad<'T * 'S>>``](type-statet.html)
  -  [``OptionT<'Monad<option<'T>>``](type-optiont.html)
  -  [``ValueOptionT<'Monad<voption<'T>>``](type-valueoptiont.html)
  -  [``SeqT<'Monad<seq<'T>>``](type-seqt.html)
  -  [``ListT<'Monad<list<'T>>``](type-listt.html)
- -  [``ResultT<'Monad<Result<'T,'TError>>``](type-resultt.html)
- -  [``ChoiceT<'Monad<Choice<'T,'TError>>``](type-choicet.html)
- -  [``Free<'Functor<'T>,'T>``](type-free.html)
+ -  [``ResultT<'Monad<Result<'T, 'TError>>``](type-resultt.html)
+ -  [``ChoiceT<'Monad<Choice<'T, 'TError>>``](type-choicet.html)
+ -  [``Free<'Functor<'T>, 'T>``](type-free.html)
  -  [``NonEmptyList<'T>``](type-nonempty.html)
  -  [``NonEmptySet<'T>``](type-nonempty-set.html)
  -  [``NonEmptyMap<'Key, 'T>``](type-nonempty-map.html)
- -  [``Validation<'Error,'T>``](type-validation.html)
+ -  [``Validation<'Error, 'T>``](type-validation.html)
  -  [``ZipList<'T>``](type-ziplist.html)
  -  [``ParallelArray<'T>``](type-parallelarray.html)
- -  [``Const<'C,'T>``](type-const.html)
+ -  [``Const<'C, 'T>``](type-const.html)
  -  [``Compose<'AlternativeF<'AlternativeG<'T>>>``](type-compose.html)
  -  [``DList<'T>``](type-dlist.html)
  -  [``Kleisli<'T, 'Monad<'U>>``](type-kleisli.html)
- -  [``Coproduct<'FunctorL<'T>,'FunctorR<'T>>``](type-coproduct.html)
- -  [``Vector<'T,'Dimension>``](type-vector.html)
- -  [``Matrix<'T,'Rows,'Columns>``](type-matrix.html)
+ -  [``Coproduct<'FunctorL<'T>, 'FunctorR<'T>>``](type-coproduct.html)
+ -  [``Vector<'T, 'Dimension>``](type-vector.html)
+ -  [``Matrix<'T, 'Rows, 'Columns>``](type-matrix.html)
 
 Restricted:
  -  ``string``
@@ -153,8 +153,8 @@ type Tree<'a> =
     | Leaf of 'a
     static member map f (t:Tree<'a>  )  =
         match t with
-        | Leaf x -> Leaf (f x)
-        | Tree(x,t1,t2) -> Tree(f x, Tree.map f t1, Tree.map f t2)
+        | Leaf  x        -> Leaf (f x)
+        | Tree (x,t1,t2) -> Tree(f x, Tree.map f t1, Tree.map f t2)
 
 // add instance for Functor class
     static member Map (x:Tree<_>, f) = Tree.map f x
@@ -179,4 +179,4 @@ type MyList<'s> = MyList of 's seq with
     static member Return (x:'a)     = MyList x
     static member (>>=)  (MyList x: MyList<'T>, f) = MyList (Seq.collect (f >> (fun (MyList x) -> x)) x)
 
-let mappedMyList = map string (MyList [1;2;3])
+let mappedMyList = map string (MyList [1; 2; 3])

docsrc/content/abstraction-monad.fsx

@@ -17,7 +17,7 @@ Minimal complete definition
 ---------------------------
 
 
- * ``return x``/``result x``
+ * ``return x``   /   ``result x``
  * ``(>>=) x f``
 *)
 (**
@@ -281,14 +281,6 @@ module Suave =
     type WebPart<'a> = 'a -> OptionT<Async<'a option>>
     let inline succeed x = async.Return (Some x)
 
-    module WebPart =
-        /// Comment from <a href="https://github.com/SuaveIO/suave/blob/v2.4.3/src/Suave/WebPart.fsi#L39-L42">WebPart.fsi</a>
-        /// Entry-point for composing the applicative routes of the http application,
-        /// by iterating the options, applying the context, arg, to the predicate
-        /// from the list of options, until there's a match/a Some(x) which can be
-        /// run.
-        let choose (options: WebPart<'a> list) = fun x -> choice (List.map ((|>) x) options)
-
     module Http =
         type HttpResponse = { status: int; content: string }
         type HttpRequest  = { url: Uri; ``method``: string }
@@ -351,6 +343,8 @@ module Suave =
                   | Error msg -> 
                       return! BAD_REQUEST msg ctx
                 })
-        WebPart.choose [ path "/" >=> (OK "/")
-                         path "/note" >=> register
-                         path "/notes" >=> overview ]
+        choice [
+            path "/" >=> (OK "/")
+            path "/note" >=> register
+            path "/notes" >=> overview
+        ]

docsrc/content/abstraction-semigroup.fsx

@@ -9,10 +9,10 @@ In mathematics, a semigroup is an algebraic structure consisting of a set togeth
 ___
 Minimal complete definition
 ---------------------------
- * ``(+)``/``(++)``
+ * ``(+)``   /   ``(++)``
 *)
 (**
-    static member (+) (x:'Semigroup, y:'Semigroup) :'Semigroup
+    static member (+) (x: 'Semigroup, y: 'Semigroup) : 'Semigroup
 *)
 (**
 Rules
@@ -34,25 +34,26 @@ From .Net/F#
  
  -  ``list<'T>``
  -  ``option<'T>``
+ -  ``voption<'T>``
  -  ``array<'T>``
  -  ``string``
  -  ``StringBuilder``
  -  ``unit``
  -  ``Set<'T>``
- -  ``Map<'T,'U>``
+ -  ``Map<'T, 'U>``
  -  ``TimeSpan`` 
  -  ``Tuple<*>``
  -  ``ValueTuple<*> ( * up to 7 elements)``
  -  ``'T1* ... *'Tn``
  -  ``Task<'T>``
  -  ``ValueTask<'T>``
- -  ``'T->'Semigroup``
+ -  ``'T -> 'Semigroup``
  -  ``Async<'T>``
  -  ``Expr<'T>``
  -  ``Lazy<'T>``
- -  ``Dictionary<'T,'U>``
- -  ``IDictionary<'T,'U>``
- -  ``IReadOnlyDictionary<'T,'U>``
+ -  ``Dictionary<'T, 'U>``
+ -  ``IDictionary<'T, 'U>``
+ -  ``IReadOnlyDictionary<'T, 'U>``
  -  ``ResizeArray<'T>``
  -  ``seq<'T>``
  -  ``IEnumerator<'T>``
@@ -67,12 +68,12 @@ From F#+
  -  [``Endo<'T>``](type-endo.html)
  -  [``All``](type-all.html)
  -  [``Any``](type-any.html)
- -  [``Const<'C,'T>``](type-const.html)
+ -  [``Const<'C, 'T>``](type-const.html)
  -  [``First<'T>``](type-first.html)
  -  [``Last<'T>``](type-last.html)
  -  [``DList<'T>``](type-dlist.html)
- -  [``Vector<'T,'Dimension>``](type-vector.html)
- -  [``Matrix<'T,'Rows,'Columns>``](type-matrix.html)
+ -  [``Vector<'T, 'Dimension>``](type-vector.html)
+ -  [``Matrix<'T, 'Rows, 'Columns>``](type-matrix.html)
  
  [Suggest another](https://github.com/fsprojects/FSharpPlus/issues/new) concrete implementation
 *)