diff --git a/base/docs/Control.App.Console.html b/base/docs/Control.App.Console.html index ddae3ee80a..6d24bb6385 100644 --- a/base/docs/Control.App.Console.html +++ b/base/docs/Control.App.Console.html @@ -61,4 +61,4 @@ -

Control.App.Console(source)

Reexports
import public Control.App
Definitions
interface Console : List Error -> Type
  Parameters: e
Methods:
  
putChar : Char -> App e ()
  
putStr : String -> App e ()
  
getChar : App e Char
  
getLine : App e String

Implementation: 
PrimIO e => Console e
putChar : Console e => Char -> App e ()
  Totality: total
  Visibility: public export
putStr : Console e => String -> App e ()
  Totality: total
  Visibility: public export
getChar : Console e => App e Char
  Totality: total
  Visibility: public export
getLine : Console e => App e String
  Totality: total
  Visibility: public export
putStrLn : Console e => String -> App e ()
  Totality: total
  Visibility: export
putCharLn : Console e => Char -> App e ()
  Totality: total
  Visibility: export
print : Show a => Console e => a -> App e ()
  Totality: total
  Visibility: export
printLn : Show a => Console e => a -> App e ()
  Totality: total
  Visibility: export

\ No newline at end of file
+
Control.App.Console(source)
Reexports
import public Control.App
Definitions
interface Console : List Error -> Type
  Parameters: e
Methods:
  
putChar : Char -> App e ()
  
putStr : String -> App e ()
  
getChar : App e Char
  
getLine : App e String

Implementation: 
PrimIO e => Console e
putChar : Console e => Char -> App e ()
  Totality: total
  Visibility: public export
putStr : Console e => String -> App e ()
  Totality: total
  Visibility: public export
getChar : Console e => App e Char
  Totality: total
  Visibility: public export
getLine : Console e => App e String
  Totality: total
  Visibility: public export
putStrLn : Console e => String -> App e ()
  Totality: total
  Visibility: export
putCharLn : Console e => Char -> App e ()
  Totality: total
  Visibility: export
print : Show a => Console e => a -> App e ()
  Totality: total
  Visibility: export
printLn : Show a => Console e => a -> App e ()
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Control.App.FileIO.html b/base/docs/Control.App.FileIO.html
index a4e497918b..ef1b28877d 100644
--- a/base/docs/Control.App.FileIO.html
+++ b/base/docs/Control.App.FileIO.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.App.FileIO(source)
Definitions
interface FileIO : List Error -> Type
  Parameters: e
Constraints: Has (Exception IOError :: Nil) e
Methods:
  
withFile : String -> Mode -> (IOError -> App e a) -> (File -> App e a) -> App e a
  
fGetStr : File -> App e String
  
fGetChars : File -> Int -> App e String
  
fGetChar : File -> App e Char
  
fPutStr : File -> String -> App e ()
  
fPutStrLn : File -> String -> App e ()
  
fflush : File -> App e ()
  
fEOF : File -> App e Bool

Implementation: 
Has [PrimIO, Exception IOError] e => FileIO e
withFile : FileIO e => String -> Mode -> (IOError -> App e a) -> (File -> App e a) -> App e a
  Visibility: public export
fGetStr : FileIO e => File -> App e String
  Visibility: public export
fGetChars : FileIO e => File -> Int -> App e String
  Visibility: public export
fGetChar : FileIO e => File -> App e Char
  Visibility: public export
fPutStr : FileIO e => File -> String -> App e ()
  Visibility: public export
fPutStrLn : FileIO e => File -> String -> App e ()
  Visibility: public export
fflush : FileIO e => File -> App e ()
  Visibility: public export
fEOF : FileIO e => File -> App e Bool
  Visibility: public export
readFile : FileIO e => String -> App e String
  Visibility: export
withFileIO : Has [PrimIO] e => App (IOError :: e) a -> (a -> App e b) -> (IOError -> App e b) -> App e b
  Visibility: export

\ No newline at end of file
+
Control.App.FileIO(source)
Definitions
interface FileIO : List Error -> Type
  Parameters: e
Constraints: Has (Exception IOError :: Nil) e
Methods:
  
withFile : String -> Mode -> (IOError -> App e a) -> (File -> App e a) -> App e a
  
fGetStr : File -> App e String
  
fGetChars : File -> Int -> App e String
  
fGetChar : File -> App e Char
  
fPutStr : File -> String -> App e ()
  
fPutStrLn : File -> String -> App e ()
  
fflush : File -> App e ()
  
fEOF : File -> App e Bool

Implementation: 
Has [PrimIO, Exception IOError] e => FileIO e
withFile : FileIO e => String -> Mode -> (IOError -> App e a) -> (File -> App e a) -> App e a
  Visibility: public export
fGetStr : FileIO e => File -> App e String
  Visibility: public export
fGetChars : FileIO e => File -> Int -> App e String
  Visibility: public export
fGetChar : FileIO e => File -> App e Char
  Visibility: public export
fPutStr : FileIO e => File -> String -> App e ()
  Visibility: public export
fPutStrLn : FileIO e => File -> String -> App e ()
  Visibility: public export
fflush : FileIO e => File -> App e ()
  Visibility: public export
fEOF : FileIO e => File -> App e Bool
  Visibility: public export
readFile : FileIO e => String -> App e String
  Visibility: export
withFileIO : Has [PrimIO] e => App (IOError :: e) a -> (a -> App e b) -> (IOError -> App e b) -> App e b
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Control.App.html b/base/docs/Control.App.html
index 097be62d97..b5f220e66e 100644
--- a/base/docs/Control.App.html
+++ b/base/docs/Control.App.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.App(source)
Definitions
Error : Type
  `Error` is a type synonym for `Type`, specify for exception handling.

  Visibility: public export
data HasErr : Error -> List Error -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Here : HasErr e (e :: es)
  
There : HasErr e es -> HasErr e (e' :: es)

  Hint: 
HasErr AppHasIO e => PrimIO e
data Path : Type
  States whether the program's execution path is linear or might throw exceptions so that we can know
  whether it is safe to reference linear resources.

  Totality: total
  Visibility: public export
  Constructors:
  
MayThrow : Path
  
NoThrow : Path

  Hints:
  
Applicative (App es)
  
Functor (App es)
  
Uninhabited (OneOf [] p)
data Usage : Type
  Totality: total
  Visibility: public export
  Constructors:
  
One : Usage
  
Any : Usage
0 Has : List (a -> Type) -> a -> Type
  Visibility: public export
data SafeBind : Path -> Path -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
SafeSame : SafeBind l l
  
SafeToThrow : SafeBind NoThrow MayThrow
data App : {default MayThrow _ : Path} -> List Error -> Type -> Type
  A type supports throwing and catching exceptions. See `interface Exception err e` for details.
  @ l  An implicit Path states whether the program's execution path is linear or might throw
       exceptions. The default value is `MayThrow` which represents that the program might throw.
  @ es A list of exception types that can be thrown. Constrained interfaces can be defined by
       parameterising with a list of errors `es`.

  Totality: total
  Visibility: export
  Constructor: 
MkApp : (1 _ : ((1 _ : %World) -> AppRes (execTy l e t))) -> App e t

  Hints:
  
Applicative (App es)
  
Functor (App es)
  
Monad (App es)
data App1 : {default One _ : Usage} -> List Error -> Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkApp1 : (1 _ : ((1 _ : %World) -> App1Res u t)) -> App1 e t
Cont1Type : Usage -> Type -> Usage -> List Error -> Type -> Type
  Visibility: public export
bindApp1 : (1 _ : App1 e a) -> (1 _ : Cont1Type u a u' e b) -> App1 e b
  Visibility: export
data AppHasIO : Type
  When type is present in app "errors" list, app is allowed to perform I/O.

  Totality: total
  Visibility: public export
  Hints:
  
HasErr AppHasIO e => PrimIO e
  
Uninhabited AppHasIO
bindL : App e a -> (1 _ : (a -> App e b)) -> App e b
  Visibility: export
seqL : App e () -> (1 _ : App e b) -> App e b
  Visibility: export
app : (1 _ : App e a) -> App1 e a
  Visibility: export
app1 : (1 _ : App1 e a) -> App e a
  Visibility: export
(>>=) : SafeBind l l' => App e a -> (a -> App e b) -> App e b
  Visibility: export
  Fixity Declaration: infixl operator, level 1
(>>=) : (1 _ : App1 e a) -> (1 _ : Cont1Type u a u' e b) -> App1 e b
  Visibility: export
  Fixity Declaration: infixl operator, level 1
(>>) : (1 _ : App1 e ()) -> (1 _ : App1 e b) -> App1 e b
  Visibility: export
  Fixity Declaration: infixl operator, level 1
pure : a -> App1 e a
  Visibility: export
pure1 : (1 _ : a) -> App1 e a
  Visibility: export
data State : a -> Type -> List Error -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkState : IORef t -> State tag t e

  Hint: 
State tag t e -> State tag t (eff :: e)
mapState : State tag t e -> State tag t (eff :: e)
  Visibility: export
get : (0 tag : {_:2831}) -> State tag t e => App e t
  Visibility: export
put : (0 tag : {_:2883}) -> State tag t e => t -> App e ()
  Visibility: export
modify : (0 tag : {_:2941}) -> State tag t e => (t -> t) -> App e ()
  Visibility: export
new : t -> (State tag t e => App e a) -> App e a
  Visibility: export
Exception : Error -> List Error -> Type
  An alias for `HasErr`.

  Visibility: public export
throw : HasErr err es => err -> App es a
  Visibility: export
catch : HasErr err es => App es a -> (err -> App es a) -> App es a
  Visibility: export
handle : App (err :: e) a -> (a -> App e b) -> (err -> App e b) -> App e b
  Visibility: export
lift : App e a -> App (err :: e) a
  Visibility: export
Init : List Error
  Visibility: public export
run : App Init a -> IO a
  The only way provided by `Control.App` to run an App.
  @ Init A concrete list of errors.

  Visibility: export
noThrow : App Init a -> App Init a
  Visibility: export
interface PrimIO : List Error -> Type
  Parameters: e
Methods:
  
primIO : IO a -> App e a
  
primIO1 : (1 _ : IO a) -> App1 e a
  
fork : (PrimIO e' => App e' ()) -> App e ()

Implementation: 
HasErr AppHasIO e => PrimIO e
primIO : PrimIO e => IO a -> App e a
  Visibility: public export
primIO1 : PrimIO e => (1 _ : IO a) -> App1 e a
  Visibility: public export
fork : PrimIO e => (PrimIO e' => App e' ()) -> App e ()
  Visibility: public export
new1 : t -> (1 _ : (State tag t e => App1 e a)) -> App1 e a
  Visibility: export
data FileEx : Type
  Totality: total
  Visibility: public export
  Constructors:
  
GenericFileEx : Int -> FileEx
  
FileReadError : FileEx
  
FileWriteError : FileEx
  
FileNotFound : FileEx
  
PermissionDenied : FileEx
  
FileExists : FileEx

  Hint: 
Show FileEx
data IOError : Type
  Totality: total
  Visibility: public export
  Constructors:
  
GenericErr : String -> IOError
  
FileErr : FileEx -> IOError

  Hint: 
Show IOError

\ No newline at end of file
+
Control.App(source)
Definitions
Error : Type
  `Error` is a type synonym for `Type`, specify for exception handling.

  Visibility: public export
data HasErr : Error -> List Error -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Here : HasErr e (e :: es)
  
There : HasErr e es -> HasErr e (e' :: es)

  Hint: 
HasErr AppHasIO e => PrimIO e
data Path : Type
  States whether the program's execution path is linear or might throw exceptions so that we can know
  whether it is safe to reference linear resources.

  Totality: total
  Visibility: public export
  Constructors:
  
MayThrow : Path
  
NoThrow : Path

  Hints:
  
Applicative (App es)
  
Functor (App es)
  
Uninhabited (OneOf [] p)
data Usage : Type
  Totality: total
  Visibility: public export
  Constructors:
  
One : Usage
  
Any : Usage
0 Has : List (a -> Type) -> a -> Type
  Visibility: public export
data SafeBind : Path -> Path -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
SafeSame : SafeBind l l
  
SafeToThrow : SafeBind NoThrow MayThrow
data App : {default MayThrow _ : Path} -> List Error -> Type -> Type
  A type supports throwing and catching exceptions. See `interface Exception err e` for details.
  @ l  An implicit Path states whether the program's execution path is linear or might throw
       exceptions. The default value is `MayThrow` which represents that the program might throw.
  @ es A list of exception types that can be thrown. Constrained interfaces can be defined by
       parameterising with a list of errors `es`.

  Totality: total
  Visibility: export
  Constructor: 
MkApp : (1 _ : ((1 _ : %World) -> AppRes (execTy l e t))) -> App e t

  Hints:
  
Applicative (App es)
  
Functor (App es)
  
Monad (App es)
data App1 : {default One _ : Usage} -> List Error -> Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkApp1 : (1 _ : ((1 _ : %World) -> App1Res u t)) -> App1 e t
Cont1Type : Usage -> Type -> Usage -> List Error -> Type -> Type
  Visibility: public export
bindApp1 : (1 _ : App1 e a) -> (1 _ : Cont1Type u a u' e b) -> App1 e b
  Visibility: export
data AppHasIO : Type
  When type is present in app "errors" list, app is allowed to perform I/O.

  Totality: total
  Visibility: public export
  Hints:
  
HasErr AppHasIO e => PrimIO e
  
Uninhabited AppHasIO
bindL : App e a -> (1 _ : (a -> App e b)) -> App e b
  Visibility: export
seqL : App e () -> (1 _ : App e b) -> App e b
  Visibility: export
app : (1 _ : App e a) -> App1 e a
  Visibility: export
app1 : (1 _ : App1 e a) -> App e a
  Visibility: export
(>>=) : SafeBind l l' => App e a -> (a -> App e b) -> App e b
  Visibility: export
  Fixity Declaration: infixl operator, level 1
(>>=) : (1 _ : App1 e a) -> (1 _ : Cont1Type u a u' e b) -> App1 e b
  Visibility: export
  Fixity Declaration: infixl operator, level 1
(>>) : (1 _ : App1 e ()) -> (1 _ : App1 e b) -> App1 e b
  Visibility: export
  Fixity Declaration: infixl operator, level 1
pure : a -> App1 e a
  Visibility: export
pure1 : (1 _ : a) -> App1 e a
  Visibility: export
data State : a -> Type -> List Error -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkState : IORef t -> State tag t e

  Hint: 
State tag t e -> State tag t (eff :: e)
mapState : State tag t e -> State tag t (eff :: e)
  Visibility: export
get : (0 tag : {_:2831}) -> State tag t e => App e t
  Visibility: export
put : (0 tag : {_:2883}) -> State tag t e => t -> App e ()
  Visibility: export
modify : (0 tag : {_:2941}) -> State tag t e => (t -> t) -> App e ()
  Visibility: export
new : t -> (State tag t e => App e a) -> App e a
  Visibility: export
Exception : Error -> List Error -> Type
  An alias for `HasErr`.

  Visibility: public export
throw : HasErr err es => err -> App es a
  Visibility: export
catch : HasErr err es => App es a -> (err -> App es a) -> App es a
  Visibility: export
handle : App (err :: e) a -> (a -> App e b) -> (err -> App e b) -> App e b
  Visibility: export
lift : App e a -> App (err :: e) a
  Visibility: export
Init : List Error
  Visibility: public export
run : App Init a -> IO a
  The only way provided by `Control.App` to run an App.
  @ Init A concrete list of errors.

  Visibility: export
noThrow : App Init a -> App Init a
  Visibility: export
interface PrimIO : List Error -> Type
  Parameters: e
Methods:
  
primIO : IO a -> App e a
  
primIO1 : (1 _ : IO a) -> App1 e a
  
fork : (PrimIO e' => App e' ()) -> App e ()

Implementation: 
HasErr AppHasIO e => PrimIO e
primIO : PrimIO e => IO a -> App e a
  Visibility: public export
primIO1 : PrimIO e => (1 _ : IO a) -> App1 e a
  Visibility: public export
fork : PrimIO e => (PrimIO e' => App e' ()) -> App e ()
  Visibility: public export
new1 : t -> (1 _ : (State tag t e => App1 e a)) -> App1 e a
  Visibility: export
data FileEx : Type
  Totality: total
  Visibility: public export
  Constructors:
  
GenericFileEx : Int -> FileEx
  
FileReadError : FileEx
  
FileWriteError : FileEx
  
FileNotFound : FileEx
  
PermissionDenied : FileEx
  
FileExists : FileEx

  Hint: 
Show FileEx
data IOError : Type
  Totality: total
  Visibility: public export
  Constructors:
  
GenericErr : String -> IOError
  
FileErr : FileEx -> IOError

  Hint: 
Show IOError

\ No newline at end of file
diff --git a/base/docs/Control.Applicative.Const.html b/base/docs/Control.Applicative.Const.html
index b67f24f804..b9ac3d27e1 100644
--- a/base/docs/Control.Applicative.Const.html
+++ b/base/docs/Control.Applicative.Const.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Applicative.Const(source)
Definitions
record Const : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkConst : a -> Const a b

  Projection: 
.runConst : Const a b -> a

  Hints:
  
Abs a => Abs (Const a b)
  
Monoid a => Applicative (Const a)
  
Bifoldable Const
  
Bifunctor Const
  
Bitraversable Const
  
Bits a => Bits (Const a b)
  
Contravariant (Const a)
  
Eq a => Eq (Const a b)
  
Foldable (Const a)
  
Fractional a => Fractional (Const a b)
  
FromString a => FromString (Const a b)
  
Functor (Const a)
  
Integral a => Integral (Const a b)
  
Monoid a => Monoid (Const a b)
  
Neg a => Neg (Const a b)
  
Num a => Num (Const a b)
  
Ord a => Ord (Const a b)
  
Semigroup a => Semigroup (Const a b)
  
Show a => Show (Const a b)
  
Traversable (Const a)
.runConst : Const a b -> a
  Totality: total
  Visibility: public export
runConst : Const a b -> a
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Control.Applicative.Const(source)
Definitions
record Const : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkConst : a -> Const a b

  Projection: 
.runConst : Const a b -> a

  Hints:
  
Abs a => Abs (Const a b)
  
Monoid a => Applicative (Const a)
  
Bifoldable Const
  
Bifunctor Const
  
Bitraversable Const
  
Bits a => Bits (Const a b)
  
Contravariant (Const a)
  
Eq a => Eq (Const a b)
  
Foldable (Const a)
  
Fractional a => Fractional (Const a b)
  
FromString a => FromString (Const a b)
  
Functor (Const a)
  
Integral a => Integral (Const a b)
  
Monoid a => Monoid (Const a b)
  
Neg a => Neg (Const a b)
  
Num a => Num (Const a b)
  
Ord a => Ord (Const a b)
  
Semigroup a => Semigroup (Const a b)
  
Show a => Show (Const a b)
  
Traversable (Const a)
.runConst : Const a b -> a
  Totality: total
  Visibility: public export
runConst : Const a b -> a
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Control.Function.FunExt.html b/base/docs/Control.Function.FunExt.html
index c96ece0390..4f45e5073d 100644
--- a/base/docs/Control.Function.FunExt.html
+++ b/base/docs/Control.Function.FunExt.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Function.FunExt(source)
Definitions
interface FunExt : Type
  This interface contains a proposition for the function extensionality.
  It is not meant to be ever implemented.
  It can be used to mark properties as requiring function extensionality to hold,
  i.e. its main objective is to provide a universal way to formulate a conditional property
  that holds only in the presence of function extensionality.

  Methods:
  
funExt : {0 b : a -> Type} -> ((x : a) -> f x = g x) -> f = g
funExt : FunExt => {0 b : a -> Type} -> ((x : a) -> f x = g x) -> f = g
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Control.Function.FunExt(source)
Definitions
interface FunExt : Type
  This interface contains a proposition for the function extensionality.
  It is not meant to be ever implemented.
  It can be used to mark properties as requiring function extensionality to hold,
  i.e. its main objective is to provide a universal way to formulate a conditional property
  that holds only in the presence of function extensionality.

  Methods:
  
funExt : {0 b : a -> Type} -> ((x : a) -> f x = g x) -> f = g
funExt : FunExt => {0 b : a -> Type} -> ((x : a) -> f x = g x) -> f = g
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Control.Function.html b/base/docs/Control.Function.html
index f4e3d5537e..620867da73 100644
--- a/base/docs/Control.Function.html
+++ b/base/docs/Control.Function.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Function(source)
Definitions
interface Injective : (a -> b) -> Type
  An injective function maps distinct elements to distinct elements.

  Parameters: f
Constructor: 
MkInjective

Methods:
  
injective : f x = f y -> x = y

Implementations:
  
Injective Left
  
Injective Right
  
Injective (\{arg:0} => x ::: {arg:0})
  
Injective (\{arg:0} => {arg:0} ::: ys)
  
Injective This
  
Injective That
  
Injective (Both x)
  
Injective (\{arg:0} => Both {arg:0} y)
  
Injective ((x ::))
  
Injective (\x => x :: xs)
  
Injective Just
  
Injective S
  
Injective FS
  
Injective finToNat
injective : Injective f => f x = f y -> x = y
  Totality: total
  Visibility: public export
inj : (0 f : (a -> b)) -> {auto 0 _ : Injective f} -> (0 _ : f x = f y) -> x = y
  Totality: total
  Visibility: public export
interface Biinjective : (a -> b -> c) -> Type
  An bi-injective function maps distinct elements to distinct elements in both arguments.
  This is more strict than injectivity on each of arguments.
  For instance, list appending is injective on both arguments but is not biinjective.

  Parameters: f
Constructor: 
MkBiinjective

Methods:
  
biinjective : f x v = f y w -> (x = y, v = w)

Implementations:
  
Biinjective (:::)
  
Biinjective Both
  
Biinjective (::)
  
Biinjective (::)
  
Biinjective MkPair
  
Biinjective (:<)
biinjective : Biinjective f => f x v = f y w -> (x = y, v = w)
  Totality: total
  Visibility: public export
biinj : (0 f : ({type_of_y:1507} -> {type_of_w:1506} -> {a:1508})) -> {auto 0 _ : Biinjective f} -> (0 _ : f x v = f y w) -> (x = y, v = w)
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Control.Function(source)
Definitions
interface Injective : (a -> b) -> Type
  An injective function maps distinct elements to distinct elements.

  Parameters: f
Constructor: 
MkInjective

Methods:
  
injective : f x = f y -> x = y

Implementations:
  
Injective Left
  
Injective Right
  
Injective (\{arg:0} => x ::: {arg:0})
  
Injective (\{arg:0} => {arg:0} ::: ys)
  
Injective This
  
Injective That
  
Injective (Both x)
  
Injective (\{arg:0} => Both {arg:0} y)
  
Injective ((x ::))
  
Injective (\x => x :: xs)
  
Injective Just
  
Injective S
  
Injective FS
  
Injective finToNat
injective : Injective f => f x = f y -> x = y
  Totality: total
  Visibility: public export
inj : (0 f : (a -> b)) -> {auto 0 _ : Injective f} -> (0 _ : f x = f y) -> x = y
  Totality: total
  Visibility: public export
interface Biinjective : (a -> b -> c) -> Type
  An bi-injective function maps distinct elements to distinct elements in both arguments.
  This is more strict than injectivity on each of arguments.
  For instance, list appending is injective on both arguments but is not biinjective.

  Parameters: f
Constructor: 
MkBiinjective

Methods:
  
biinjective : f x v = f y w -> (x = y, v = w)

Implementations:
  
Biinjective (:::)
  
Biinjective Both
  
Biinjective (::)
  
Biinjective (::)
  
Biinjective MkPair
  
Biinjective (:<)
biinjective : Biinjective f => f x v = f y w -> (x = y, v = w)
  Totality: total
  Visibility: public export
biinj : (0 f : ({type_of_y:1507} -> {type_of_w:1506} -> {a:1508})) -> {auto 0 _ : Biinjective f} -> (0 _ : f x v = f y w) -> (x = y, v = w)
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Control.Monad.Either.html b/base/docs/Control.Monad.Either.html
index 173af98566..69dd7a4e6b 100644
--- a/base/docs/Control.Monad.Either.html
+++ b/base/docs/Control.Monad.Either.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Monad.Either(source)
Reexports
import public Control.Monad.Error.Either as Control.Monad.Either
import public Control.Monad.Error.Interface as Control.Monad.Either

\ No newline at end of file
+
Control.Monad.Either(source)
Reexports
import public Control.Monad.Error.Either as Control.Monad.Either
import public Control.Monad.Error.Interface as Control.Monad.Either

\ No newline at end of file
diff --git a/base/docs/Control.Monad.Error.Either.html b/base/docs/Control.Monad.Error.Either.html
index 9bbb9c9ec6..0325d08475 100644
--- a/base/docs/Control.Monad.Error.Either.html
+++ b/base/docs/Control.Monad.Error.Either.html
@@ -63,4 +63,4 @@
 
 
Control.Monad.Error.Either(source)
Provides a monad transformer `EitherT` that extends an inner monad with the
 ability to throw and catch exceptions.
-
Definitions
data EitherT : Type -> (Type -> Type) -> Type -> Type
  A monad transformer extending an inner monad with the ability to throw and
  catch exceptions.
  
  Sequenced actions produce an exception if either action produces an
  exception, with preference for the first exception. If neither produce an
  exception, neither does the sequence of actions.
  
  `MaybeT m a` is equivalent to `EitherT () m a`, that is, an computation
  that can only throw a single, information-less exception.

  Totality: total
  Visibility: public export
  Constructor: 
MkEitherT : m (Either e a) -> EitherT e m a

  Hints:
  
(Monad m, Monoid e) => Alternative (EitherT e m)
  
Applicative m => Applicative (EitherT e m)
  
Eq (m (Either e a)) => Eq (EitherT e m a)
  
Foldable m => Foldable (EitherT e m)
  
Functor m => Functor (EitherT e m)
  
HasIO m => HasIO (EitherT e m)
  
Monad m => Monad (EitherT e m)
  
Monad m => MonadError e (EitherT e m)
  
MonadTrans (EitherT e)
  
Ord (m (Either e a)) => Ord (EitherT e m a)
  
Monad m => Semigroup (EitherT e m a)
  
Show (m (Either e a)) => Show (EitherT e m a)
  
Traversable m => Traversable (EitherT e m)
runEitherT : EitherT e m a -> m (Either e a)
  Unwrap an `EitherT` computation.

  Totality: total
  Visibility: public export
eitherT : Monad m => (a -> m c) -> (b -> m c) -> EitherT a m b -> m c
  Run an `EitherT` computation, handling results and exceptions with seperate
  functions.
  
  This is a version of `either` lifted to work with `EitherT`.

  Totality: total
  Visibility: public export
mapEitherT : (m (Either e a) -> n (Either e' a')) -> EitherT e m a -> EitherT e' n a'
  Map over the underlying monadic computation.

  Totality: total
  Visibility: public export
bimapEitherT : Functor m => (a -> c) -> (b -> d) -> EitherT a m b -> EitherT c m d
  Map over the result or the exception of a monadic computation.

  Totality: total
  Visibility: public export
left : Applicative m => e -> EitherT e m a
  A version of `Left` lifted to work with `EitherT`.
  
  This is equivalent to `throwE`.

  Totality: total
  Visibility: public export
right : Applicative m => a -> EitherT e m a
  A version of `Right` lifted to work with `EitherT`.
  
  This is equivalent to `pure`.

  Totality: total
  Visibility: public export
swapEitherT : Functor m => EitherT e m a -> EitherT a m e
  Swap the result and the exception of a monadic computation.

  Totality: total
  Visibility: public export
throwE : Applicative m => e -> EitherT e m a
  Throw an exception in a monadic computation.

  Totality: total
  Visibility: public export
catchE : Monad m => EitherT e m a -> (e -> EitherT e' m a) -> EitherT e' m a
  Handle an exception thrown in a monadic computation.
  
  Since the handler catches all errors thrown in the computation, it may
  raise a different exception type.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
data EitherT : Type -> (Type -> Type) -> Type -> Type
  A monad transformer extending an inner monad with the ability to throw and
  catch exceptions.
  
  Sequenced actions produce an exception if either action produces an
  exception, with preference for the first exception. If neither produce an
  exception, neither does the sequence of actions.
  
  `MaybeT m a` is equivalent to `EitherT () m a`, that is, an computation
  that can only throw a single, information-less exception.

  Totality: total
  Visibility: public export
  Constructor: 
MkEitherT : m (Either e a) -> EitherT e m a

  Hints:
  
(Monad m, Monoid e) => Alternative (EitherT e m)
  
Applicative m => Applicative (EitherT e m)
  
Eq (m (Either e a)) => Eq (EitherT e m a)
  
Foldable m => Foldable (EitherT e m)
  
Functor m => Functor (EitherT e m)
  
HasIO m => HasIO (EitherT e m)
  
Monad m => Monad (EitherT e m)
  
Monad m => MonadError e (EitherT e m)
  
MonadTrans (EitherT e)
  
Ord (m (Either e a)) => Ord (EitherT e m a)
  
Monad m => Semigroup (EitherT e m a)
  
Show (m (Either e a)) => Show (EitherT e m a)
  
Traversable m => Traversable (EitherT e m)
runEitherT : EitherT e m a -> m (Either e a)
  Unwrap an `EitherT` computation.

  Totality: total
  Visibility: public export
eitherT : Monad m => (a -> m c) -> (b -> m c) -> EitherT a m b -> m c
  Run an `EitherT` computation, handling results and exceptions with seperate
  functions.
  
  This is a version of `either` lifted to work with `EitherT`.

  Totality: total
  Visibility: public export
mapEitherT : (m (Either e a) -> n (Either e' a')) -> EitherT e m a -> EitherT e' n a'
  Map over the underlying monadic computation.

  Totality: total
  Visibility: public export
bimapEitherT : Functor m => (a -> c) -> (b -> d) -> EitherT a m b -> EitherT c m d
  Map over the result or the exception of a monadic computation.

  Totality: total
  Visibility: public export
left : Applicative m => e -> EitherT e m a
  A version of `Left` lifted to work with `EitherT`.
  
  This is equivalent to `throwE`.

  Totality: total
  Visibility: public export
right : Applicative m => a -> EitherT e m a
  A version of `Right` lifted to work with `EitherT`.
  
  This is equivalent to `pure`.

  Totality: total
  Visibility: public export
swapEitherT : Functor m => EitherT e m a -> EitherT a m e
  Swap the result and the exception of a monadic computation.

  Totality: total
  Visibility: public export
throwE : Applicative m => e -> EitherT e m a
  Throw an exception in a monadic computation.

  Totality: total
  Visibility: public export
catchE : Monad m => EitherT e m a -> (e -> EitherT e' m a) -> EitherT e' m a
  Handle an exception thrown in a monadic computation.
  
  Since the handler catches all errors thrown in the computation, it may
  raise a different exception type.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Control.Monad.Error.Interface.html b/base/docs/Control.Monad.Error.Interface.html
index 6f66d08d7e..18a19032fd 100644
--- a/base/docs/Control.Monad.Error.Interface.html
+++ b/base/docs/Control.Monad.Error.Interface.html
@@ -62,4 +62,4 @@
 
 
 
Control.Monad.Error.Interface(source)
The Error monad (also called the Exception monad).
-
Definitions
interface MonadError : Type -> (Type -> Type) -> Type
  The strategy of combining computations that can throw exceptions
  by bypassing bound functions
  from the point an exception is thrown to the point that it is handled.
  Is parameterized over the type of error information and
  the monad type constructor.
  It is common to use `Either String` as the monad type constructor
  for an error monad in which error descriptions take the form of strings.
  In that case and many other common cases the resulting monad is already defined
  as an instance of the 'MonadError' class.

  Parameters: e, m
Constraints: Monad m
Methods:
  
throwError : e -> m a
  Is used within a monadic computation to begin exception processing.
  
catchError : m a -> (e -> m a) -> m a
  A handler function to handle previous errors and return to normal execution.
  A common idiom is:
  
  ```idris example
  do { action1; action2; action3 } `catchError` handler
  ```

Implementations:
  
MonadError () Maybe
  
Monad m => MonadError () (MaybeT m)
  
MonadError e (Either e)
  
Monad m => MonadError e (EitherT e m)
  
MonadError e m => MonadError e (MaybeT m)
  
MonadError e m => MonadError e (ReaderT r m)
  
MonadError e m => MonadError e (StateT r m)
  
MonadError e m => MonadError e (RWST r w s m)
  
MonadError e m => MonadError e (WriterT w m)
throwError : MonadError e m => e -> m a
  Is used within a monadic computation to begin exception processing.

  Totality: total
  Visibility: public export
catchError : MonadError e m => m a -> (e -> m a) -> m a
  A handler function to handle previous errors and return to normal execution.
  A common idiom is:
  
  ```idris example
  do { action1; action2; action3 } `catchError` handler
  ```

  Totality: total
  Visibility: public export
liftEither : MonadError e m => Either e a -> m a
  Lifts an `Either e` into any `MonadError e`.

  Totality: total
  Visibility: public export
tryError : MonadError e m => m a -> m (Either e a)
  Makes a success or failure of an action visible in
  the return type.

  Totality: total
  Visibility: public export
withError : MonadError e m => (e -> e) -> m a -> m a
  `MonadError` analogue to the `withEitherT` function.
  Modify the value (but not the type) of an error.
  If you need to change the type of `e` use `mapError`.

  Totality: total
  Visibility: public export
handleError : MonadError e m => (e -> m a) -> m a -> m a
  Flipped version of `catchError`.

  Totality: total
  Visibility: public export
mapError : (MonadError e m, MonadError e' n) => (m (Either e a) -> n (Either e' b)) -> m a -> n b
  `MonadError` analogue of the `mapEitherT` function.  The
  computation is unwrapped, a function is applied to the `Either`, and
  the result is lifted into the second `MonadError` instance.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
interface MonadError : Type -> (Type -> Type) -> Type
  The strategy of combining computations that can throw exceptions
  by bypassing bound functions
  from the point an exception is thrown to the point that it is handled.
  Is parameterized over the type of error information and
  the monad type constructor.
  It is common to use `Either String` as the monad type constructor
  for an error monad in which error descriptions take the form of strings.
  In that case and many other common cases the resulting monad is already defined
  as an instance of the 'MonadError' class.

  Parameters: e, m
Constraints: Monad m
Methods:
  
throwError : e -> m a
  Is used within a monadic computation to begin exception processing.
  
catchError : m a -> (e -> m a) -> m a
  A handler function to handle previous errors and return to normal execution.
  A common idiom is:
  
  ```idris example
  do { action1; action2; action3 } `catchError` handler
  ```

Implementations:
  
MonadError () Maybe
  
Monad m => MonadError () (MaybeT m)
  
MonadError e (Either e)
  
Monad m => MonadError e (EitherT e m)
  
MonadError e m => MonadError e (MaybeT m)
  
MonadError e m => MonadError e (ReaderT r m)
  
MonadError e m => MonadError e (StateT r m)
  
MonadError e m => MonadError e (RWST r w s m)
  
MonadError e m => MonadError e (WriterT w m)
throwError : MonadError e m => e -> m a
  Is used within a monadic computation to begin exception processing.

  Totality: total
  Visibility: public export
catchError : MonadError e m => m a -> (e -> m a) -> m a
  A handler function to handle previous errors and return to normal execution.
  A common idiom is:
  
  ```idris example
  do { action1; action2; action3 } `catchError` handler
  ```

  Totality: total
  Visibility: public export
liftEither : MonadError e m => Either e a -> m a
  Lifts an `Either e` into any `MonadError e`.

  Totality: total
  Visibility: public export
tryError : MonadError e m => m a -> m (Either e a)
  Makes a success or failure of an action visible in
  the return type.

  Totality: total
  Visibility: public export
withError : MonadError e m => (e -> e) -> m a -> m a
  `MonadError` analogue to the `withEitherT` function.
  Modify the value (but not the type) of an error.
  If you need to change the type of `e` use `mapError`.

  Totality: total
  Visibility: public export
handleError : MonadError e m => (e -> m a) -> m a -> m a
  Flipped version of `catchError`.

  Totality: total
  Visibility: public export
mapError : (MonadError e m, MonadError e' n) => (m (Either e a) -> n (Either e' b)) -> m a -> n b
  `MonadError` analogue of the `mapEitherT` function.  The
  computation is unwrapped, a function is applied to the `Either`, and
  the result is lifted into the second `MonadError` instance.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Control.Monad.Identity.html b/base/docs/Control.Monad.Identity.html
index 9584b1e917..35d8d02542 100644
--- a/base/docs/Control.Monad.Identity.html
+++ b/base/docs/Control.Monad.Identity.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Monad.Identity(source)
Definitions
record Identity : Type -> Type
  The identity monad. This monad provides no abilities other than pure
  computation.

  Totality: total
  Visibility: public export
  Constructor: 
Id : a -> Identity a

  Projection: 
.runIdentity : Identity a -> a

  Hints:
  
Abs a => Abs (Identity a)
  
Applicative Identity
  
Bits a => Bits (Identity a)
  
Eq a => Eq (Identity a)
  
Fractional a => Fractional (Identity a)
  
FromString a => FromString (Identity a)
  
Functor Identity
  
Integral a => Integral (Identity a)
  
Monad Identity
  
Monoid a => Monoid (Identity a)
  
Neg a => Neg (Identity a)
  
Num a => Num (Identity a)
  
Ord a => Ord (Identity a)
  
Semigroup a => Semigroup (Identity a)
  
Show a => Show (Identity a)
.runIdentity : Identity a -> a
  Totality: total
  Visibility: public export
runIdentity : Identity a -> a
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Control.Monad.Identity(source)
Definitions
record Identity : Type -> Type
  The identity monad. This monad provides no abilities other than pure
  computation.

  Totality: total
  Visibility: public export
  Constructor: 
Id : a -> Identity a

  Projection: 
.runIdentity : Identity a -> a

  Hints:
  
Abs a => Abs (Identity a)
  
Applicative Identity
  
Bits a => Bits (Identity a)
  
Eq a => Eq (Identity a)
  
Fractional a => Fractional (Identity a)
  
FromString a => FromString (Identity a)
  
Functor Identity
  
Integral a => Integral (Identity a)
  
Monad Identity
  
Monoid a => Monoid (Identity a)
  
Neg a => Neg (Identity a)
  
Num a => Num (Identity a)
  
Ord a => Ord (Identity a)
  
Semigroup a => Semigroup (Identity a)
  
Show a => Show (Identity a)
.runIdentity : Identity a -> a
  Totality: total
  Visibility: public export
runIdentity : Identity a -> a
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Control.Monad.Maybe.html b/base/docs/Control.Monad.Maybe.html
index 26fae1c1a5..2e063e3855 100644
--- a/base/docs/Control.Monad.Maybe.html
+++ b/base/docs/Control.Monad.Maybe.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Monad.Maybe(source)
Definitions
data MaybeT : (Type -> Type) -> Type -> Type
  A monad transformer extending an inner monad with the ability to not return
  a result.
  
  Sequenced actions produce a result only if both actions return a result.
  
  `MaybeT m a` is equivalent to `EitherT () m a`, that is, an computation
  that can only throw a single, information-less exception.

  Totality: total
  Visibility: public export
  Constructor: 
MkMaybeT : m (Maybe a) -> MaybeT m a

  Hints:
  
Monad m => Alternative (MaybeT m)
  
Applicative m => Applicative (MaybeT m)
  
Eq (m (Maybe a)) => Eq (MaybeT m a)
  
Foldable m => Foldable (MaybeT m)
  
Functor m => Functor (MaybeT m)
  
HasIO m => HasIO (MaybeT m)
  
Monad m => Monad (MaybeT m)
  
Monad m => MonadError () (MaybeT m)
  
MonadError e m => MonadError e (MaybeT m)
  
MonadTrans MaybeT
  
Monad m => Monoid (MaybeT m a)
  
Ord (m (Maybe a)) => Ord (MaybeT m a)
  
Monad m => Semigroup (MaybeT m a)
  
Show (m (Maybe a)) => Show (MaybeT m a)
  
Traversable m => Traversable (MaybeT m)
runMaybeT : MaybeT m a -> m (Maybe a)
  Unwrap a `MaybeT` computation.

  Totality: total
  Visibility: public export
isNothingT : Functor m => MaybeT m a -> m Bool
  Check if a monadic computation returns a result. This returns `False` if
  the computation returns a result, and `True` otherwise.
  
  This is a version of `isNothing` lifted to work with `MaybeT`.

  Totality: total
  Visibility: public export
isJustT : Functor m => MaybeT m a -> m Bool
  Check if a monadic computation returns a result. This returns `True` if
  the computation returns a result, and `False` otherwise.
  
  This is a version of `isJust` lifted to work with `MaybeT`.

  Totality: total
  Visibility: public export
maybeT : Monad m => m b -> (a -> m b) -> MaybeT m a -> m b
  Run a `MaybeT` computation, handling the case of a result or no result
  seperately.
  
  This is a version of `maybe` lifted to work with `MaybeT`.

  Totality: total
  Visibility: public export
fromMaybeT : Monad m => m a -> MaybeT m a -> m a
  Run a `MaybeT` computation providing a default value.
  
  This is a version of `fromMaybe` lifted to work with `MaybeT`.

  Totality: total
  Visibility: public export
toMaybeT : Functor m => Bool -> m a -> MaybeT m a
  Return a value if a condition is met, or else no value.
  
  This is a version of `toMaybe` lifted to work with `MaybeT`.

  Totality: total
  Visibility: public export
mapMaybeT : (m (Maybe a) -> n (Maybe a')) -> MaybeT m a -> MaybeT n a'
  Map over the underlying computation.

  Totality: total
  Visibility: public export
just : Applicative m => a -> MaybeT m a
  A version of `Just` lifted to work with `MaybeT`.
  
  This is equivalent to `pure`.

  Totality: total
  Visibility: public export
nothing : Applicative m => MaybeT m a
  A version of `Nothing` lifted to work with `MaybeT`.
  
  This is equivalent to `throwE ()`.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Control.Monad.Maybe(source)
Definitions
data MaybeT : (Type -> Type) -> Type -> Type
  A monad transformer extending an inner monad with the ability to not return
  a result.
  
  Sequenced actions produce a result only if both actions return a result.
  
  `MaybeT m a` is equivalent to `EitherT () m a`, that is, an computation
  that can only throw a single, information-less exception.

  Totality: total
  Visibility: public export
  Constructor: 
MkMaybeT : m (Maybe a) -> MaybeT m a

  Hints:
  
Monad m => Alternative (MaybeT m)
  
Applicative m => Applicative (MaybeT m)
  
Eq (m (Maybe a)) => Eq (MaybeT m a)
  
Foldable m => Foldable (MaybeT m)
  
Functor m => Functor (MaybeT m)
  
HasIO m => HasIO (MaybeT m)
  
Monad m => Monad (MaybeT m)
  
Monad m => MonadError () (MaybeT m)
  
MonadError e m => MonadError e (MaybeT m)
  
MonadTrans MaybeT
  
Monad m => Monoid (MaybeT m a)
  
Ord (m (Maybe a)) => Ord (MaybeT m a)
  
Monad m => Semigroup (MaybeT m a)
  
Show (m (Maybe a)) => Show (MaybeT m a)
  
Traversable m => Traversable (MaybeT m)
runMaybeT : MaybeT m a -> m (Maybe a)
  Unwrap a `MaybeT` computation.

  Totality: total
  Visibility: public export
isNothingT : Functor m => MaybeT m a -> m Bool
  Check if a monadic computation returns a result. This returns `False` if
  the computation returns a result, and `True` otherwise.
  
  This is a version of `isNothing` lifted to work with `MaybeT`.

  Totality: total
  Visibility: public export
isJustT : Functor m => MaybeT m a -> m Bool
  Check if a monadic computation returns a result. This returns `True` if
  the computation returns a result, and `False` otherwise.
  
  This is a version of `isJust` lifted to work with `MaybeT`.

  Totality: total
  Visibility: public export
maybeT : Monad m => m b -> (a -> m b) -> MaybeT m a -> m b
  Run a `MaybeT` computation, handling the case of a result or no result
  seperately.
  
  This is a version of `maybe` lifted to work with `MaybeT`.

  Totality: total
  Visibility: public export
fromMaybeT : Monad m => m a -> MaybeT m a -> m a
  Run a `MaybeT` computation providing a default value.
  
  This is a version of `fromMaybe` lifted to work with `MaybeT`.

  Totality: total
  Visibility: public export
toMaybeT : Functor m => Bool -> m a -> MaybeT m a
  Return a value if a condition is met, or else no value.
  
  This is a version of `toMaybe` lifted to work with `MaybeT`.

  Totality: total
  Visibility: public export
mapMaybeT : (m (Maybe a) -> n (Maybe a')) -> MaybeT m a -> MaybeT n a'
  Map over the underlying computation.

  Totality: total
  Visibility: public export
just : Applicative m => a -> MaybeT m a
  A version of `Just` lifted to work with `MaybeT`.
  
  This is equivalent to `pure`.

  Totality: total
  Visibility: public export
nothing : Applicative m => MaybeT m a
  A version of `Nothing` lifted to work with `MaybeT`.
  
  This is equivalent to `throwE ()`.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Control.Monad.RWS.CPS.html b/base/docs/Control.Monad.RWS.CPS.html
index 08120bfc3e..8a121d514a 100644
--- a/base/docs/Control.Monad.RWS.CPS.html
+++ b/base/docs/Control.Monad.RWS.CPS.html
@@ -65,4 +65,4 @@
 that accumulation of values does not happen in the
 Applicative and Monad instances but when invoking `Writer`-specific
 functions like `writer` or `listen`.
-
Definitions
record RWST : Type -> Type -> Type -> (Type -> Type) -> Type -> Type
  A monad transformer extending an inner monad `m` with the ability to read
  an environment of type `r`, collect an output of type `w` and update a
  state of type `s`.
  
  This is equivalent to `ReaderT r (WriterT w (StateT s m)) a`, but fuses the
  three layers.

  Totality: total
  Visibility: public export
  Constructor: 
MkRWST : (r -> s -> w -> m (a, (s, w))) -> RWST r w s m a

  Projection: 
.unRWST : RWST r w s m a -> r -> s -> w -> m (a, (s, w))

  Hints:
  
(Monad m, Alternative m) => Alternative (RWST r w s m)
  
Monad m => Applicative (RWST r w s m)
  
Functor m => Functor (RWST r w s m)
  
HasIO m => HasIO (RWST r w s m)
  
Monad m => Monad (RWST r w s m)
  
MonadError e m => MonadError e (RWST r w s m)
  
(Monoid w, Monad m) => MonadRWS r w s (RWST r w s m)
  
Monad m => MonadReader r (RWST r w s m)
  
Monad m => MonadState s (RWST r w s m)
  
MonadTrans (RWST r w s)
  
(Monoid w, Monad m) => MonadWriter w (RWST r w s m)
.unRWST : RWST r w s m a -> r -> s -> w -> m (a, (s, w))
  Totality: total
  Visibility: public export
unRWST : RWST r w s m a -> r -> s -> w -> m (a, (s, w))
  Totality: total
  Visibility: public export
runRWST : Monoid w => r -> s -> RWST r w s m a -> m (a, (s, w))
  Unwrap an RWST computation as a function.
  
  This is the inverse of `rwsT`.

  Totality: total
  Visibility: public export
rwsT : Semigroup w => Functor m => (r -> s -> m (a, (s, w))) -> RWST r w s m a
  Construct an RWST computation from a function.
  
  This is the inverse of `runRWST`.

  Totality: total
  Visibility: public export
evalRWST : Monoid w => Functor m => r -> s -> RWST r w s m a -> m (a, w)
  Evaluate a computation with the given initial state and environment,
  returning the final value and output, discarding the final state.

  Totality: total
  Visibility: public export
execRWST : Monoid w => Functor m => r -> s -> RWST r w s m a -> m (s, w)
  Evaluate a computation with the given initial state and environment,
  returning the final state and output, discarding the final value.

  Totality: total
  Visibility: public export
mapRWST : (Functor n, (Monoid w, Semigroup w')) => (m (a, (s, w)) -> n (b, (s, w'))) -> RWST r w s m a -> RWST r w' s n b
  Map over the inner computation.

  Totality: total
  Visibility: public export
withRWST : (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a
  `withRWST f m` executes action `m` with an initial environment
  and state modified by applying `f`.

  Totality: total
  Visibility: public export
RWS : Type -> Type -> Type -> Type -> Type
  A monad containing an environment of type `r`, output of type `w`
  and an updatable state of type `s`.
  
  This is `RWST` applied to `Identity`.

  Totality: total
  Visibility: public export
runRWS : Monoid w => r -> s -> RWS r w s a -> (a, (s, w))
  Unwrap an RWS computation as a function.
  
  This is the inverse of `rws`.

  Totality: total
  Visibility: public export
rws : Semigroup w => (r -> s -> (a, (s, w))) -> RWS r w s a
  Construct an RWS computation from a function.
  
  This is the inverse of `runRWS`.

  Totality: total
  Visibility: public export
evalRWS : Monoid w => r -> s -> RWS r w s a -> (a, w)
  Evaluate a computation with the given initial state and environment,
  returning the final value and output, discarding the final state.

  Totality: total
  Visibility: public export
execRWS : Monoid w => r -> s -> RWS r w s a -> (s, w)
  Evaluate a computation with the given initial state and environment,
  returning the final state and output, discarding the final value.

  Totality: total
  Visibility: public export
mapRWS : (Monoid w, Semigroup w') => ((a, (s, w)) -> (b, (s, w'))) -> RWS r w s a -> RWS r w' s b
  Map the return value, final state and output of a computation using
  the given function.

  Totality: total
  Visibility: public export
withRWS : (r' -> s -> (r, s)) -> RWS r w s a -> RWS r' w s a
  `withRWS f m` executes action `m` with an initial environment
  and state modified by applying `f`.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
record RWST : Type -> Type -> Type -> (Type -> Type) -> Type -> Type
  A monad transformer extending an inner monad `m` with the ability to read
  an environment of type `r`, collect an output of type `w` and update a
  state of type `s`.
  
  This is equivalent to `ReaderT r (WriterT w (StateT s m)) a`, but fuses the
  three layers.

  Totality: total
  Visibility: public export
  Constructor: 
MkRWST : (r -> s -> w -> m (a, (s, w))) -> RWST r w s m a

  Projection: 
.unRWST : RWST r w s m a -> r -> s -> w -> m (a, (s, w))

  Hints:
  
(Monad m, Alternative m) => Alternative (RWST r w s m)
  
Monad m => Applicative (RWST r w s m)
  
Functor m => Functor (RWST r w s m)
  
HasIO m => HasIO (RWST r w s m)
  
Monad m => Monad (RWST r w s m)
  
MonadError e m => MonadError e (RWST r w s m)
  
(Monoid w, Monad m) => MonadRWS r w s (RWST r w s m)
  
Monad m => MonadReader r (RWST r w s m)
  
Monad m => MonadState s (RWST r w s m)
  
MonadTrans (RWST r w s)
  
(Monoid w, Monad m) => MonadWriter w (RWST r w s m)
.unRWST : RWST r w s m a -> r -> s -> w -> m (a, (s, w))
  Totality: total
  Visibility: public export
unRWST : RWST r w s m a -> r -> s -> w -> m (a, (s, w))
  Totality: total
  Visibility: public export
runRWST : Monoid w => r -> s -> RWST r w s m a -> m (a, (s, w))
  Unwrap an RWST computation as a function.
  
  This is the inverse of `rwsT`.

  Totality: total
  Visibility: public export
rwsT : Semigroup w => Functor m => (r -> s -> m (a, (s, w))) -> RWST r w s m a
  Construct an RWST computation from a function.
  
  This is the inverse of `runRWST`.

  Totality: total
  Visibility: public export
evalRWST : Monoid w => Functor m => r -> s -> RWST r w s m a -> m (a, w)
  Evaluate a computation with the given initial state and environment,
  returning the final value and output, discarding the final state.

  Totality: total
  Visibility: public export
execRWST : Monoid w => Functor m => r -> s -> RWST r w s m a -> m (s, w)
  Evaluate a computation with the given initial state and environment,
  returning the final state and output, discarding the final value.

  Totality: total
  Visibility: public export
mapRWST : (Functor n, (Monoid w, Semigroup w')) => (m (a, (s, w)) -> n (b, (s, w'))) -> RWST r w s m a -> RWST r w' s n b
  Map over the inner computation.

  Totality: total
  Visibility: public export
withRWST : (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a
  `withRWST f m` executes action `m` with an initial environment
  and state modified by applying `f`.

  Totality: total
  Visibility: public export
RWS : Type -> Type -> Type -> Type -> Type
  A monad containing an environment of type `r`, output of type `w`
  and an updatable state of type `s`.
  
  This is `RWST` applied to `Identity`.

  Totality: total
  Visibility: public export
runRWS : Monoid w => r -> s -> RWS r w s a -> (a, (s, w))
  Unwrap an RWS computation as a function.
  
  This is the inverse of `rws`.

  Totality: total
  Visibility: public export
rws : Semigroup w => (r -> s -> (a, (s, w))) -> RWS r w s a
  Construct an RWS computation from a function.
  
  This is the inverse of `runRWS`.

  Totality: total
  Visibility: public export
evalRWS : Monoid w => r -> s -> RWS r w s a -> (a, w)
  Evaluate a computation with the given initial state and environment,
  returning the final value and output, discarding the final state.

  Totality: total
  Visibility: public export
execRWS : Monoid w => r -> s -> RWS r w s a -> (s, w)
  Evaluate a computation with the given initial state and environment,
  returning the final state and output, discarding the final value.

  Totality: total
  Visibility: public export
mapRWS : (Monoid w, Semigroup w') => ((a, (s, w)) -> (b, (s, w'))) -> RWS r w s a -> RWS r w' s b
  Map the return value, final state and output of a computation using
  the given function.

  Totality: total
  Visibility: public export
withRWS : (r' -> s -> (r, s)) -> RWS r w s a -> RWS r' w s a
  `withRWS f m` executes action `m` with an initial environment
  and state modified by applying `f`.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Control.Monad.RWS.Interface.html b/base/docs/Control.Monad.RWS.Interface.html
index d0eb93adbf..7690b0bacb 100644
--- a/base/docs/Control.Monad.RWS.Interface.html
+++ b/base/docs/Control.Monad.RWS.Interface.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Monad.RWS.Interface(source)
Definitions
interface MonadRWS : Type -> Type -> Type -> (Type -> Type) -> Type
  Parameters: r, w, s, m
Constraints: MonadReader r m, MonadWriter w m, MonadState s m
Implementation: 
(Monoid w, Monad m) => MonadRWS r w s (RWST r w s m)

\ No newline at end of file
+
Control.Monad.RWS.Interface(source)
Definitions
interface MonadRWS : Type -> Type -> Type -> (Type -> Type) -> Type
  Parameters: r, w, s, m
Constraints: MonadReader r m, MonadWriter w m, MonadState s m
Implementation: 
(Monoid w, Monad m) => MonadRWS r w s (RWST r w s m)

\ No newline at end of file
diff --git a/base/docs/Control.Monad.RWS.html b/base/docs/Control.Monad.RWS.html
index 6f5d5bf4fb..c579e9fad8 100644
--- a/base/docs/Control.Monad.RWS.html
+++ b/base/docs/Control.Monad.RWS.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Monad.RWS(source)
Reexports
import public Control.Monad.RWS.CPS as Control.Monad.RWS
import public Control.Monad.RWS.Interface as Control.Monad.RWS
import public Control.Monad.Reader.Interface as Control.Monad.RWS
import public Control.Monad.Writer.Interface as Control.Monad.RWS
import public Control.Monad.State.Interface as Control.Monad.RWS

\ No newline at end of file
+
Control.Monad.RWS(source)
Reexports
import public Control.Monad.RWS.CPS as Control.Monad.RWS
import public Control.Monad.RWS.Interface as Control.Monad.RWS
import public Control.Monad.Reader.Interface as Control.Monad.RWS
import public Control.Monad.Writer.Interface as Control.Monad.RWS
import public Control.Monad.State.Interface as Control.Monad.RWS

\ No newline at end of file
diff --git a/base/docs/Control.Monad.Reader.Interface.html b/base/docs/Control.Monad.Reader.Interface.html
index 43790ff641..fac5bb03ca 100644
--- a/base/docs/Control.Monad.Reader.Interface.html
+++ b/base/docs/Control.Monad.Reader.Interface.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Monad.Reader.Interface(source)
Definitions
interface MonadReader : Type -> (Type -> Type) -> Type
  A computation which runs in a static context and produces an output

  Parameters: stateType, m
Constraints: Monad m
Methods:
  
ask : m stateType
  Get the context
  
local : (stateType -> stateType) -> m a -> m a
  `local f c` runs the computation `c` in an environment modified by `f`.

Implementations:
  
Monad m => MonadReader stateType (ReaderT stateType m)
  
Monad m => MonadReader r (RWST r w s m)
  
MonadReader r m => MonadReader r (EitherT e m)
  
MonadReader r m => MonadReader r (MaybeT m)
  
MonadReader r m => MonadReader r (StateT s m)
  
MonadReader r m => MonadReader r (WriterT w m)
ask : MonadReader stateType m => m stateType
  Get the context

  Totality: total
  Visibility: public export
local : MonadReader stateType m => (stateType -> stateType) -> m a -> m a
  `local f c` runs the computation `c` in an environment modified by `f`.

  Totality: total
  Visibility: public export
asks : MonadReader stateType m => (stateType -> a) -> m a
  Evaluate a function in the context held by this computation

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Control.Monad.Reader.Interface(source)
Definitions
interface MonadReader : Type -> (Type -> Type) -> Type
  A computation which runs in a static context and produces an output

  Parameters: stateType, m
Constraints: Monad m
Methods:
  
ask : m stateType
  Get the context
  
local : (stateType -> stateType) -> m a -> m a
  `local f c` runs the computation `c` in an environment modified by `f`.

Implementations:
  
Monad m => MonadReader stateType (ReaderT stateType m)
  
Monad m => MonadReader r (RWST r w s m)
  
MonadReader r m => MonadReader r (EitherT e m)
  
MonadReader r m => MonadReader r (MaybeT m)
  
MonadReader r m => MonadReader r (StateT s m)
  
MonadReader r m => MonadReader r (WriterT w m)
ask : MonadReader stateType m => m stateType
  Get the context

  Totality: total
  Visibility: public export
local : MonadReader stateType m => (stateType -> stateType) -> m a -> m a
  `local f c` runs the computation `c` in an environment modified by `f`.

  Totality: total
  Visibility: public export
asks : MonadReader stateType m => (stateType -> a) -> m a
  Evaluate a function in the context held by this computation

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Control.Monad.Reader.Reader.html b/base/docs/Control.Monad.Reader.Reader.html
index 3f4a2e581f..e5be66ec80 100644
--- a/base/docs/Control.Monad.Reader.Reader.html
+++ b/base/docs/Control.Monad.Reader.Reader.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Monad.Reader.Reader(source)
Definitions
record ReaderT : Type -> (Type -> Type) -> Type -> Type
  A monad transformer extending an inner monad with access to an environment.
  
  The environment is the same for all actions in a sequence, but may be
  changed within scopes created by `Control.Monad.Reader.local`.

  Totality: total
  Visibility: public export
  Constructor: 
MkReaderT : (1 _ : (stateType -> m a)) -> ReaderT stateType m a

  Projection: 
.runReaderT' : ReaderT stateType m a -> stateType -> m a

  Hints:
  
Alternative f => Alternative (ReaderT stateType f)
  
Applicative f => Applicative (ReaderT stateType f)
  
Functor f => Functor (ReaderT stateType f)
  
HasIO m => HasIO (ReaderT stateType m)
  
Monad m => Monad (ReaderT stateType m)
  
MonadError e m => MonadError e (ReaderT r m)
  
Monad m => MonadReader stateType (ReaderT stateType m)
  
MonadState s m => MonadState s (ReaderT r m)
  
MonadTrans (ReaderT stateType)
  
MonadWriter w m => MonadWriter w (ReaderT r m)
.runReaderT' : ReaderT stateType m a -> stateType -> m a
  Totality: total
  Visibility: public export
runReaderT' : ReaderT stateType m a -> stateType -> m a
  Totality: total
  Visibility: public export
mapReaderT : (m a -> n b) -> ReaderT r m a -> ReaderT r n b
  Transform the computation inside a @ReaderT@.

  Totality: total
  Visibility: public export
runReaderT : stateType -> ReaderT stateType m a -> m a
  Unwrap and apply a ReaderT monad computation

  Totality: total
  Visibility: public export
Reader : Type -> Type -> Type
  A monad that can access an environment.
  
  This is `ReaderT` applied to `Identity`.

  Totality: total
  Visibility: public export
runReader : stateType -> Reader stateType a -> a
  Unwrap and apply a Reader monad computation

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Control.Monad.Reader.Reader(source)
Definitions
record ReaderT : Type -> (Type -> Type) -> Type -> Type
  A monad transformer extending an inner monad with access to an environment.
  
  The environment is the same for all actions in a sequence, but may be
  changed within scopes created by `Control.Monad.Reader.local`.

  Totality: total
  Visibility: public export
  Constructor: 
MkReaderT : (1 _ : (stateType -> m a)) -> ReaderT stateType m a

  Projection: 
.runReaderT' : ReaderT stateType m a -> stateType -> m a

  Hints:
  
Alternative f => Alternative (ReaderT stateType f)
  
Applicative f => Applicative (ReaderT stateType f)
  
Functor f => Functor (ReaderT stateType f)
  
HasIO m => HasIO (ReaderT stateType m)
  
Monad m => Monad (ReaderT stateType m)
  
MonadError e m => MonadError e (ReaderT r m)
  
Monad m => MonadReader stateType (ReaderT stateType m)
  
MonadState s m => MonadState s (ReaderT r m)
  
MonadTrans (ReaderT stateType)
  
MonadWriter w m => MonadWriter w (ReaderT r m)
.runReaderT' : ReaderT stateType m a -> stateType -> m a
  Totality: total
  Visibility: public export
runReaderT' : ReaderT stateType m a -> stateType -> m a
  Totality: total
  Visibility: public export
mapReaderT : (m a -> n b) -> ReaderT r m a -> ReaderT r n b
  Transform the computation inside a @ReaderT@.

  Totality: total
  Visibility: public export
runReaderT : stateType -> ReaderT stateType m a -> m a
  Unwrap and apply a ReaderT monad computation

  Totality: total
  Visibility: public export
Reader : Type -> Type -> Type
  A monad that can access an environment.
  
  This is `ReaderT` applied to `Identity`.

  Totality: total
  Visibility: public export
runReader : stateType -> Reader stateType a -> a
  Unwrap and apply a Reader monad computation

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Control.Monad.Reader.html b/base/docs/Control.Monad.Reader.html
index 8eeb305927..48da773958 100644
--- a/base/docs/Control.Monad.Reader.html
+++ b/base/docs/Control.Monad.Reader.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Monad.Reader(source)
Reexports
import public Control.Monad.Reader.Reader as Control.Monad.Reader
import public Control.Monad.Reader.Interface as Control.Monad.Reader

\ No newline at end of file
+
Control.Monad.Reader(source)
Reexports
import public Control.Monad.Reader.Reader as Control.Monad.Reader
import public Control.Monad.Reader.Interface as Control.Monad.Reader

\ No newline at end of file
diff --git a/base/docs/Control.Monad.ST.html b/base/docs/Control.Monad.ST.html
index c384884eb4..759bc4fa9e 100644
--- a/base/docs/Control.Monad.ST.html
+++ b/base/docs/Control.Monad.ST.html
@@ -62,4 +62,4 @@
 
 
 
Control.Monad.ST(source)
Provides mutable references as described in Lazy Functional State Threads.
-
Definitions
data STRef : Type -> Type -> Type
  A mutable reference, bound to a state thread.
  
  A value of type `STRef s a` contains a mutable `a`, bound to a "thread"
  `s`. Any access to the reference must occur in an `ST s` monad with the
  same "thread".

  Totality: total
  Visibility: export
  Constructor: 
MkSTRef : IORef a -> STRef s a
data ST : Type -> Type -> Type
  The `ST` monad allows for mutable access to references, but unlike `IO`, it
  is "escapable".
  
  The parameter `s` is a "thread" -- it ensures that access to mutable
  references created in each thread must occur in that same thread.

  Totality: total
  Visibility: export
  Constructor: 
MkST : IO a -> ST s a

  Hints:
  
Applicative (ST s)
  
Functor (ST s)
  
Monad (ST s)
runST : ST s a -> a
  Run a `ST` computation.

  Totality: total
  Visibility: export
newSTRef : a -> ST s (STRef s a)
  Create a new mutable reference with the given value.

  Totality: total
  Visibility: export
readSTRef : STRef s a -> ST s a
  Read the value of a mutable reference.
  
  This occurs within `ST s` to prevent `STRef`s from being usable if they are
  "leaked" via `runST`.

  Totality: total
  Visibility: export
writeSTRef : STRef s a -> a -> ST s ()
  Write to a mutable reference.

  Totality: total
  Visibility: export
modifySTRef : STRef s a -> (a -> a) -> ST s ()
  Apply a function to the contents of a mutable reference.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
data STRef : Type -> Type -> Type
  A mutable reference, bound to a state thread.
  
  A value of type `STRef s a` contains a mutable `a`, bound to a "thread"
  `s`. Any access to the reference must occur in an `ST s` monad with the
  same "thread".

  Totality: total
  Visibility: export
  Constructor: 
MkSTRef : IORef a -> STRef s a
data ST : Type -> Type -> Type
  The `ST` monad allows for mutable access to references, but unlike `IO`, it
  is "escapable".
  
  The parameter `s` is a "thread" -- it ensures that access to mutable
  references created in each thread must occur in that same thread.

  Totality: total
  Visibility: export
  Constructor: 
MkST : IO a -> ST s a

  Hints:
  
Applicative (ST s)
  
Functor (ST s)
  
Monad (ST s)
runST : ST s a -> a
  Run a `ST` computation.

  Totality: total
  Visibility: export
newSTRef : a -> ST s (STRef s a)
  Create a new mutable reference with the given value.

  Totality: total
  Visibility: export
readSTRef : STRef s a -> ST s a
  Read the value of a mutable reference.
  
  This occurs within `ST s` to prevent `STRef`s from being usable if they are
  "leaked" via `runST`.

  Totality: total
  Visibility: export
writeSTRef : STRef s a -> a -> ST s ()
  Write to a mutable reference.

  Totality: total
  Visibility: export
modifySTRef : STRef s a -> (a -> a) -> ST s ()
  Apply a function to the contents of a mutable reference.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Control.Monad.State.Interface.html b/base/docs/Control.Monad.State.Interface.html
index 22599288eb..7a19b910e0 100644
--- a/base/docs/Control.Monad.State.Interface.html
+++ b/base/docs/Control.Monad.State.Interface.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Monad.State.Interface(source)
Definitions
interface MonadState : Type -> (Type -> Type) -> Type
  A monadic computation that has access to state.

  Parameters: stateType, m
Constraints: Monad m
Methods:
  
get : m stateType
  Get the context
  
put : stateType -> m ()
  Write a new context/output
  
state : (stateType -> (stateType, a)) -> m a
  Embed a simple state action into the monad.

Implementations:
  
Monad m => MonadState stateType (StateT stateType m)
  
MonadState s m => MonadState s (EitherT e m)
  
MonadState s m => MonadState s (MaybeT m)
  
Monad m => MonadState s (RWST r w s m)
  
MonadState s m => MonadState s (ReaderT r m)
  
MonadState s m => MonadState s (WriterT r m)
get : MonadState stateType m => m stateType
  Get the context

  Totality: total
  Visibility: public export
put : MonadState stateType m => stateType -> m ()
  Write a new context/output

  Totality: total
  Visibility: public export
state : MonadState stateType m => (stateType -> (stateType, a)) -> m a
  Embed a simple state action into the monad.

  Totality: total
  Visibility: public export
modify : MonadState stateType m => (stateType -> stateType) -> m ()
  Apply a function to modify the context of this computation

  Totality: total
  Visibility: public export
gets : MonadState stateType m => (stateType -> a) -> m a
  Evaluate a function in the context held by this computation

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Control.Monad.State.Interface(source)
Definitions
interface MonadState : Type -> (Type -> Type) -> Type
  A monadic computation that has access to state.

  Parameters: stateType, m
Constraints: Monad m
Methods:
  
get : m stateType
  Get the context
  
put : stateType -> m ()
  Write a new context/output
  
state : (stateType -> (stateType, a)) -> m a
  Embed a simple state action into the monad.

Implementations:
  
Monad m => MonadState stateType (StateT stateType m)
  
MonadState s m => MonadState s (EitherT e m)
  
MonadState s m => MonadState s (MaybeT m)
  
Monad m => MonadState s (RWST r w s m)
  
MonadState s m => MonadState s (ReaderT r m)
  
MonadState s m => MonadState s (WriterT r m)
get : MonadState stateType m => m stateType
  Get the context

  Totality: total
  Visibility: public export
put : MonadState stateType m => stateType -> m ()
  Write a new context/output

  Totality: total
  Visibility: public export
state : MonadState stateType m => (stateType -> (stateType, a)) -> m a
  Embed a simple state action into the monad.

  Totality: total
  Visibility: public export
modify : MonadState stateType m => (stateType -> stateType) -> m ()
  Apply a function to modify the context of this computation

  Totality: total
  Visibility: public export
gets : MonadState stateType m => (stateType -> a) -> m a
  Evaluate a function in the context held by this computation

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Control.Monad.State.State.html b/base/docs/Control.Monad.State.State.html
index 9213b3b18c..fc77e96242 100644
--- a/base/docs/Control.Monad.State.State.html
+++ b/base/docs/Control.Monad.State.State.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Monad.State.State(source)
Definitions
record StateT : Type -> (Type -> Type) -> Type -> Type
  A monad transformer extending an inner monad `m` with state `stateType`.
  
  Updates to the state are applied in the order as the sequence of actions.

  Totality: total
  Visibility: public export
  Constructor: 
ST : (stateType -> m (stateType, a)) -> StateT stateType m a

  Projection: 
.runStateT' : StateT stateType m a -> stateType -> m (stateType, a)

  Hints:
  
(Monad f, Alternative f) => Alternative (StateT st f)
  
Monad f => Applicative (StateT stateType f)
  
Functor f => Functor (StateT stateType f)
  
HasIO m => HasIO (StateT stateType m)
  
Monad m => Monad (StateT stateType m)
  
MonadError e m => MonadError e (StateT r m)
  
MonadReader r m => MonadReader r (StateT s m)
  
Monad m => MonadState stateType (StateT stateType m)
  
MonadTrans (StateT stateType)
  
MonadWriter w m => MonadWriter w (StateT s m)
.runStateT' : StateT stateType m a -> stateType -> m (stateType, a)
  Totality: total
  Visibility: public export
runStateT' : StateT stateType m a -> stateType -> m (stateType, a)
  Totality: total
  Visibility: public export
runStateT : stateType -> StateT stateType m a -> m (stateType, a)
  Unwrap and apply a StateT monad computation.

  Totality: total
  Visibility: public export
evalStateT : Functor m => stateType -> StateT stateType m a -> m a
  Unwrap and apply a StateT monad computation, but discard the final state.

  Totality: total
  Visibility: public export
execStateT : Functor m => stateType -> StateT stateType m a -> m stateType
  Unwrap and apply a StateT monad computation, but discard the resulting value.

  Totality: total
  Visibility: public export
mapStateT : (m (s, a) -> n (s, b)) -> StateT s m a -> StateT s n b
  Map both the return value and final state of a computation using
  the given function.

  Totality: total
  Visibility: public export
State : Type -> Type -> Type
  The State monad. See the MonadState interface

  Totality: total
  Visibility: public export
runState : stateType -> State stateType a -> (stateType, a)
  Unwrap and apply a State monad computation.

  Totality: total
  Visibility: public export
evalState : stateType -> State stateType a -> a
  Unwrap and apply a State monad computation, but discard the final state.

  Totality: total
  Visibility: public export
execState : stateType -> State stateType a -> stateType
  Unwrap and apply a State monad computation, but discard the resulting value.

  Totality: total
  Visibility: public export
mapState : ((s, a) -> (s, b)) -> State s a -> State s b
  Map both the return value and final state of a computation using
  the given function.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Control.Monad.State.State(source)
Definitions
record StateT : Type -> (Type -> Type) -> Type -> Type
  A monad transformer extending an inner monad `m` with state `stateType`.
  
  Updates to the state are applied in the order as the sequence of actions.

  Totality: total
  Visibility: public export
  Constructor: 
ST : (stateType -> m (stateType, a)) -> StateT stateType m a

  Projection: 
.runStateT' : StateT stateType m a -> stateType -> m (stateType, a)

  Hints:
  
(Monad f, Alternative f) => Alternative (StateT st f)
  
Monad f => Applicative (StateT stateType f)
  
Functor f => Functor (StateT stateType f)
  
HasIO m => HasIO (StateT stateType m)
  
Monad m => Monad (StateT stateType m)
  
MonadError e m => MonadError e (StateT r m)
  
MonadReader r m => MonadReader r (StateT s m)
  
Monad m => MonadState stateType (StateT stateType m)
  
MonadTrans (StateT stateType)
  
MonadWriter w m => MonadWriter w (StateT s m)
.runStateT' : StateT stateType m a -> stateType -> m (stateType, a)
  Totality: total
  Visibility: public export
runStateT' : StateT stateType m a -> stateType -> m (stateType, a)
  Totality: total
  Visibility: public export
runStateT : stateType -> StateT stateType m a -> m (stateType, a)
  Unwrap and apply a StateT monad computation.

  Totality: total
  Visibility: public export
evalStateT : Functor m => stateType -> StateT stateType m a -> m a
  Unwrap and apply a StateT monad computation, but discard the final state.

  Totality: total
  Visibility: public export
execStateT : Functor m => stateType -> StateT stateType m a -> m stateType
  Unwrap and apply a StateT monad computation, but discard the resulting value.

  Totality: total
  Visibility: public export
mapStateT : (m (s, a) -> n (s, b)) -> StateT s m a -> StateT s n b
  Map both the return value and final state of a computation using
  the given function.

  Totality: total
  Visibility: public export
State : Type -> Type -> Type
  The State monad. See the MonadState interface

  Totality: total
  Visibility: public export
runState : stateType -> State stateType a -> (stateType, a)
  Unwrap and apply a State monad computation.

  Totality: total
  Visibility: public export
evalState : stateType -> State stateType a -> a
  Unwrap and apply a State monad computation, but discard the final state.

  Totality: total
  Visibility: public export
execState : stateType -> State stateType a -> stateType
  Unwrap and apply a State monad computation, but discard the resulting value.

  Totality: total
  Visibility: public export
mapState : ((s, a) -> (s, b)) -> State s a -> State s b
  Map both the return value and final state of a computation using
  the given function.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Control.Monad.State.html b/base/docs/Control.Monad.State.html
index 2fa1e346c3..adc253ce08 100644
--- a/base/docs/Control.Monad.State.html
+++ b/base/docs/Control.Monad.State.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Monad.State(source)
Reexports
import public Control.Monad.Identity
import public Control.Monad.Trans
import public Control.Monad.State.Interface as Control.Monad.State
import public Control.Monad.State.State as Control.Monad.State

\ No newline at end of file
+
Control.Monad.State(source)
Reexports
import public Control.Monad.Identity
import public Control.Monad.Trans
import public Control.Monad.State.Interface as Control.Monad.State
import public Control.Monad.State.State as Control.Monad.State

\ No newline at end of file
diff --git a/base/docs/Control.Monad.Trans.html b/base/docs/Control.Monad.Trans.html
index dddf9f5708..83f042361c 100644
--- a/base/docs/Control.Monad.Trans.html
+++ b/base/docs/Control.Monad.Trans.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Monad.Trans(source)
Definitions
interface MonadTrans : ((Type -> Type) -> Type -> Type) -> Type
  A monad transformer is a type that can wrap an inner monad, extending it
  with additional abilities.

  Parameters: t
Methods:
  
lift : Monad m => m a -> t m a
  Lift a computation from the inner monad to the transformed monad.

Implementations:
  
MonadTrans (EitherT e)
  
MonadTrans MaybeT
  
MonadTrans (RWST r w s)
  
MonadTrans (ReaderT stateType)
  
MonadTrans (StateT stateType)
  
MonadTrans (WriterT w)
lift : MonadTrans t => Monad m => m a -> t m a
  Lift a computation from the inner monad to the transformed monad.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Control.Monad.Trans(source)
Definitions
interface MonadTrans : ((Type -> Type) -> Type -> Type) -> Type
  A monad transformer is a type that can wrap an inner monad, extending it
  with additional abilities.

  Parameters: t
Methods:
  
lift : Monad m => m a -> t m a
  Lift a computation from the inner monad to the transformed monad.

Implementations:
  
MonadTrans (EitherT e)
  
MonadTrans MaybeT
  
MonadTrans (RWST r w s)
  
MonadTrans (ReaderT stateType)
  
MonadTrans (StateT stateType)
  
MonadTrans (WriterT w)
lift : MonadTrans t => Monad m => m a -> t m a
  Lift a computation from the inner monad to the transformed monad.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Control.Monad.Writer.CPS.html b/base/docs/Control.Monad.Writer.CPS.html
index d2285ecb62..a08788dd21 100644
--- a/base/docs/Control.Monad.Writer.CPS.html
+++ b/base/docs/Control.Monad.Writer.CPS.html
@@ -65,4 +65,4 @@
 that accumulation of values does not happen in the
 Applicative and Monad instances but when invoking `Writer`-specific
 functions like `writer` or `listen`.
-
Definitions
record WriterT : Type -> (Type -> Type) -> Type -> Type
  A writer monad parameterized by:
  
    @w the output to accumulate.
  
    @m The inner monad.
  
  The `pure` function produces the output `neutral`, while `>>=`
  combines the outputs of the subcomputations using `<+>`.

  Totality: total
  Visibility: public export
  Constructor: 
MkWriterT : (w -> m (a, w)) -> WriterT w m a

  Projection: 
.unWriterT : WriterT w m a -> w -> m (a, w)

  Hints:
  
(Monad m, Alternative m) => Alternative (WriterT w m)
  
Monad m => Applicative (WriterT w m)
  
Functor m => Functor (WriterT w m)
  
HasIO m => HasIO (WriterT w m)
  
Monad m => Monad (WriterT w m)
  
MonadError e m => MonadError e (WriterT w m)
  
MonadReader r m => MonadReader r (WriterT w m)
  
MonadState s m => MonadState s (WriterT r m)
  
MonadTrans (WriterT w)
  
(Monoid w, Monad m) => MonadWriter w (WriterT w m)
.unWriterT : WriterT w m a -> w -> m (a, w)
  Totality: total
  Visibility: public export
unWriterT : WriterT w m a -> w -> m (a, w)
  Totality: total
  Visibility: public export
writerT : Semigroup w => Functor m => m (a, w) -> WriterT w m a
  Construct an writer computation from a (result,output) computation.
  (The inverse of `runWriterT`.)

  Totality: total
  Visibility: public export
runWriterT : Monoid w => WriterT w m a -> m (a, w)
  Unwrap a writer computation.
  (The inverse of 'writerT'.)

  Totality: total
  Visibility: public export
execWriterT : Monoid w => Functor m => WriterT w m a -> m w
  Extract the output from a writer computation.

  Totality: total
  Visibility: public export
mapWriterT : (Functor n, (Monoid w, Semigroup w')) => (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
  Map both the return value and output of a computation using
  the given function.

  Totality: total
  Visibility: public export
Writer : Type -> Type -> Type
  The `return` function produces the output `neutral`, while `>>=`
  combines the outputs of the subcomputations using `<+>`.

  Totality: total
  Visibility: public export
runWriter : Monoid w => Writer w a -> (a, w)
  Unwrap a writer computation as a (result, output) pair.

  Totality: total
  Visibility: public export
execWriter : Monoid w => Writer w a -> w
  Extract the output from a writer computation.

  Totality: total
  Visibility: public export
mapWriter : (Monoid w, Semigroup w') => ((a, w) -> (b, w')) -> Writer w a -> Writer w' b
  Map both the return value and output of a computation using
  the given function.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
record WriterT : Type -> (Type -> Type) -> Type -> Type
  A writer monad parameterized by:
  
    @w the output to accumulate.
  
    @m The inner monad.
  
  The `pure` function produces the output `neutral`, while `>>=`
  combines the outputs of the subcomputations using `<+>`.

  Totality: total
  Visibility: public export
  Constructor: 
MkWriterT : (w -> m (a, w)) -> WriterT w m a

  Projection: 
.unWriterT : WriterT w m a -> w -> m (a, w)

  Hints:
  
(Monad m, Alternative m) => Alternative (WriterT w m)
  
Monad m => Applicative (WriterT w m)
  
Functor m => Functor (WriterT w m)
  
HasIO m => HasIO (WriterT w m)
  
Monad m => Monad (WriterT w m)
  
MonadError e m => MonadError e (WriterT w m)
  
MonadReader r m => MonadReader r (WriterT w m)
  
MonadState s m => MonadState s (WriterT r m)
  
MonadTrans (WriterT w)
  
(Monoid w, Monad m) => MonadWriter w (WriterT w m)
.unWriterT : WriterT w m a -> w -> m (a, w)
  Totality: total
  Visibility: public export
unWriterT : WriterT w m a -> w -> m (a, w)
  Totality: total
  Visibility: public export
writerT : Semigroup w => Functor m => m (a, w) -> WriterT w m a
  Construct an writer computation from a (result,output) computation.
  (The inverse of `runWriterT`.)

  Totality: total
  Visibility: public export
runWriterT : Monoid w => WriterT w m a -> m (a, w)
  Unwrap a writer computation.
  (The inverse of 'writerT'.)

  Totality: total
  Visibility: public export
execWriterT : Monoid w => Functor m => WriterT w m a -> m w
  Extract the output from a writer computation.

  Totality: total
  Visibility: public export
mapWriterT : (Functor n, (Monoid w, Semigroup w')) => (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
  Map both the return value and output of a computation using
  the given function.

  Totality: total
  Visibility: public export
Writer : Type -> Type -> Type
  The `return` function produces the output `neutral`, while `>>=`
  combines the outputs of the subcomputations using `<+>`.

  Totality: total
  Visibility: public export
runWriter : Monoid w => Writer w a -> (a, w)
  Unwrap a writer computation as a (result, output) pair.

  Totality: total
  Visibility: public export
execWriter : Monoid w => Writer w a -> w
  Extract the output from a writer computation.

  Totality: total
  Visibility: public export
mapWriter : (Monoid w, Semigroup w') => ((a, w) -> (b, w')) -> Writer w a -> Writer w' b
  Map both the return value and output of a computation using
  the given function.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Control.Monad.Writer.Interface.html b/base/docs/Control.Monad.Writer.Interface.html
index 0545e71887..0c86a330c6 100644
--- a/base/docs/Control.Monad.Writer.Interface.html
+++ b/base/docs/Control.Monad.Writer.Interface.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Monad.Writer.Interface(source)
Definitions
interface MonadWriter : Type -> (Type -> Type) -> Type
  MonadWriter interface
  
  tell is like tell on the MUD's it shouts to monad
  what you want to be heard. The monad carries this 'packet'
  upwards, merging it if needed (hence the Monoid requirement).
  
  listen listens to a monad acting, and returns what the monad "said".
  
  pass lets you provide a writer transformer which changes internals of
  the written object.

  Parameters: w, m
Constraints: Monoid w, Monad m
Methods:
  
writer : (a, w) -> m a
  `writer (a,w)` embeds a simple writer action.
  
tell : w -> m ()
  `tell w` is an action that produces the output `w`.
  
listen : m a -> m (a, w)
  `listen m` is an action that executes the action `m` and adds
  its output to the value of the computation.
  
pass : m (a, w -> w) -> m a
  `pass m` is an action that executes the action `m`, which
  returns a value and a function, and returns the value, applying
  the function to the output.

Implementations:
  
(Monoid w, Monad m) => MonadWriter w (WriterT w m)
  
(Monoid w, Monad m) => MonadWriter w (RWST r w s m)
  
MonadWriter w m => MonadWriter w (EitherT e m)
  
MonadWriter w m => MonadWriter w (MaybeT m)
  
MonadWriter w m => MonadWriter w (ReaderT r m)
  
MonadWriter w m => MonadWriter w (StateT s m)
writer : MonadWriter w m => (a, w) -> m a
  `writer (a,w)` embeds a simple writer action.

  Totality: total
  Visibility: public export
tell : MonadWriter w m => w -> m ()
  `tell w` is an action that produces the output `w`.

  Totality: total
  Visibility: public export
listen : MonadWriter w m => m a -> m (a, w)
  `listen m` is an action that executes the action `m` and adds
  its output to the value of the computation.

  Totality: total
  Visibility: public export
pass : MonadWriter w m => m (a, w -> w) -> m a
  `pass m` is an action that executes the action `m`, which
  returns a value and a function, and returns the value, applying
  the function to the output.

  Totality: total
  Visibility: public export
listens : MonadWriter w m => (w -> b) -> m a -> m (a, b)
  `listens f m` is an action that executes the action `m` and adds
  the result of applying @f@ to the output to the value of the computation.

  Totality: total
  Visibility: public export
censor : MonadWriter w m => (w -> w) -> m a -> m a
  `censor f m` is an action that executes the action `m` and
  applies the function `f` to its output, leaving the return value
  unchanged.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Control.Monad.Writer.Interface(source)
Definitions
interface MonadWriter : Type -> (Type -> Type) -> Type
  MonadWriter interface
  
  tell is like tell on the MUD's it shouts to monad
  what you want to be heard. The monad carries this 'packet'
  upwards, merging it if needed (hence the Monoid requirement).
  
  listen listens to a monad acting, and returns what the monad "said".
  
  pass lets you provide a writer transformer which changes internals of
  the written object.

  Parameters: w, m
Constraints: Monoid w, Monad m
Methods:
  
writer : (a, w) -> m a
  `writer (a,w)` embeds a simple writer action.
  
tell : w -> m ()
  `tell w` is an action that produces the output `w`.
  
listen : m a -> m (a, w)
  `listen m` is an action that executes the action `m` and adds
  its output to the value of the computation.
  
pass : m (a, w -> w) -> m a
  `pass m` is an action that executes the action `m`, which
  returns a value and a function, and returns the value, applying
  the function to the output.

Implementations:
  
(Monoid w, Monad m) => MonadWriter w (WriterT w m)
  
(Monoid w, Monad m) => MonadWriter w (RWST r w s m)
  
MonadWriter w m => MonadWriter w (EitherT e m)
  
MonadWriter w m => MonadWriter w (MaybeT m)
  
MonadWriter w m => MonadWriter w (ReaderT r m)
  
MonadWriter w m => MonadWriter w (StateT s m)
writer : MonadWriter w m => (a, w) -> m a
  `writer (a,w)` embeds a simple writer action.

  Totality: total
  Visibility: public export
tell : MonadWriter w m => w -> m ()
  `tell w` is an action that produces the output `w`.

  Totality: total
  Visibility: public export
listen : MonadWriter w m => m a -> m (a, w)
  `listen m` is an action that executes the action `m` and adds
  its output to the value of the computation.

  Totality: total
  Visibility: public export
pass : MonadWriter w m => m (a, w -> w) -> m a
  `pass m` is an action that executes the action `m`, which
  returns a value and a function, and returns the value, applying
  the function to the output.

  Totality: total
  Visibility: public export
listens : MonadWriter w m => (w -> b) -> m a -> m (a, b)
  `listens f m` is an action that executes the action `m` and adds
  the result of applying @f@ to the output to the value of the computation.

  Totality: total
  Visibility: public export
censor : MonadWriter w m => (w -> w) -> m a -> m a
  `censor f m` is an action that executes the action `m` and
  applies the function `f` to its output, leaving the return value
  unchanged.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Control.Monad.Writer.html b/base/docs/Control.Monad.Writer.html
index 6b808ed6d6..4fb6258500 100644
--- a/base/docs/Control.Monad.Writer.html
+++ b/base/docs/Control.Monad.Writer.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Monad.Writer(source)
Reexports
import public Control.Monad.Writer.Interface as Control.Monad.Writer
import public Control.Monad.Writer.CPS as Control.Monad.Writer

\ No newline at end of file
+
Control.Monad.Writer(source)
Reexports
import public Control.Monad.Writer.Interface as Control.Monad.Writer
import public Control.Monad.Writer.CPS as Control.Monad.Writer

\ No newline at end of file
diff --git a/base/docs/Control.Ord.html b/base/docs/Control.Ord.html
index 360dc39614..b96ed19ebf 100644
--- a/base/docs/Control.Ord.html
+++ b/base/docs/Control.Ord.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Ord(source)
Definitions

\ No newline at end of file
+
Control.Ord(source)
Definitions

\ No newline at end of file
diff --git a/base/docs/Control.Order.html b/base/docs/Control.Order.html
index 23f6e2ccc4..f869de6ccd 100644
--- a/base/docs/Control.Order.html
+++ b/base/docs/Control.Order.html
@@ -69,4 +69,4 @@
 properties.
 
 A prominent example of an order relation is LTE over Nat.
-
Definitions
interface Preorder : (ty : Type) -> (ty -> ty -> Type) -> Type
  A preorder is reflexive and transitive.

  Parameters: ty, rel
Constraints: Reflexive ty rel, Transitive ty rel
Implementation: 
Preorder Nat LTE
interface PartialOrder : (ty : Type) -> (ty -> ty -> Type) -> Type
  A partial order is an antisymmetrics preorder.

  Parameters: ty, rel
Constraints: Preorder ty rel, Antisymmetric ty rel
Implementation: 
PartialOrder Nat LTE
interface Connex : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is connex if for any two distinct x and y, either x ~ y or y ~ x.
  
  This can also be stated as a trichotomy: x ~ y or x = y or y ~ x.

  Parameters: ty, rel
Methods:
  
connex : Not (x = y) -> Either (rel x y) (rel y x)

Implementation: 
Connex Nat LTE
connex : Connex ty rel => Not (x = y) -> Either (rel x y) (rel y x)
  Visibility: public export
interface StronglyConnex : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is strongly connex if for any two x and y, either x ~ y or y ~ x.

  Parameters: ty, rel
Methods:
  
order : (x : ty) -> (y : ty) -> Either (rel x y) (rel y x)
order : StronglyConnex ty rel => (x : ty) -> (y : ty) -> Either (rel x y) (rel y x)
  Visibility: public export
interface LinearOrder : (ty : Type) -> (ty -> ty -> Type) -> Type
  A linear order is a connex partial order.

  Parameters: ty, rel
Constraints: PartialOrder ty rel, Connex ty rel
Implementation: 
LinearOrder Nat LTE
leftmost : (0 rel : (ty -> ty -> Type)) -> StronglyConnex ty rel => ty -> ty -> ty
  Gives the leftmost of a strongly connex relation among the given two elements, generalisation of `min`.
  
  That is, leftmost x y ~ x and leftmost x y ~ y, and `leftmost x y` is either `x` or `y`

  Visibility: public export
rightmost : (0 rel : (ty -> ty -> Type)) -> StronglyConnex ty rel => ty -> ty -> ty
  Gives the rightmost of a strongly connex relation among the given two elements, generalisation of `max`.
  
  That is, x ~ rightmost x y and y ~ rightmost x y, and `rightmost x y` is either `x` or `y`

  Visibility: public export
leftmostRelL : (0 rel : (ty -> ty -> Type)) -> Reflexive ty rel => {auto {conArg:2893} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> rel (leftmost rel x y) x
  Visibility: export
leftmostRelR : (0 rel : (ty -> ty -> Type)) -> Reflexive ty rel => {auto {conArg:2963} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> rel (leftmost rel x y) y
  Visibility: export
leftmostPreserves : (0 rel : (ty -> ty -> Type)) -> {auto {conArg:3030} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> Either (leftmost rel x y = x) (leftmost rel x y = y)
  Visibility: export
leftmostIsRightmostLeft : (0 rel : (ty -> ty -> Type)) -> {auto {conArg:3113} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> (z : ty) -> rel z x -> rel z y -> rel z (leftmost rel x y)
  Visibility: export
rightmostRelL : (0 rel : (ty -> ty -> Type)) -> Reflexive ty rel => {auto {conArg:3188} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> rel x (rightmost rel x y)
  Visibility: export
rightmostRelR : (0 rel : (ty -> ty -> Type)) -> Reflexive ty rel => {auto {conArg:3258} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> rel y (rightmost rel x y)
  Visibility: export
rightmostPreserves : (0 rel : (ty -> ty -> Type)) -> {auto {conArg:3325} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> Either (rightmost rel x y = x) (rightmost rel x y = y)
  Visibility: export
rightmostIsLeftmostRight : (0 rel : (ty -> ty -> Type)) -> {auto {conArg:3408} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> (z : ty) -> rel x z -> rel y z -> rel (leftmost rel x y) z
  Visibility: export

\ No newline at end of file
+
Definitions
interface Preorder : (ty : Type) -> (ty -> ty -> Type) -> Type
  A preorder is reflexive and transitive.

  Parameters: ty, rel
Constraints: Reflexive ty rel, Transitive ty rel
Implementation: 
Preorder Nat LTE
interface PartialOrder : (ty : Type) -> (ty -> ty -> Type) -> Type
  A partial order is an antisymmetrics preorder.

  Parameters: ty, rel
Constraints: Preorder ty rel, Antisymmetric ty rel
Implementation: 
PartialOrder Nat LTE
interface Connex : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is connex if for any two distinct x and y, either x ~ y or y ~ x.
  
  This can also be stated as a trichotomy: x ~ y or x = y or y ~ x.

  Parameters: ty, rel
Methods:
  
connex : Not (x = y) -> Either (rel x y) (rel y x)

Implementation: 
Connex Nat LTE
connex : Connex ty rel => Not (x = y) -> Either (rel x y) (rel y x)
  Visibility: public export
interface StronglyConnex : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is strongly connex if for any two x and y, either x ~ y or y ~ x.

  Parameters: ty, rel
Methods:
  
order : (x : ty) -> (y : ty) -> Either (rel x y) (rel y x)
order : StronglyConnex ty rel => (x : ty) -> (y : ty) -> Either (rel x y) (rel y x)
  Visibility: public export
interface LinearOrder : (ty : Type) -> (ty -> ty -> Type) -> Type
  A linear order is a connex partial order.

  Parameters: ty, rel
Constraints: PartialOrder ty rel, Connex ty rel
Implementation: 
LinearOrder Nat LTE
leftmost : (0 rel : (ty -> ty -> Type)) -> StronglyConnex ty rel => ty -> ty -> ty
  Gives the leftmost of a strongly connex relation among the given two elements, generalisation of `min`.
  
  That is, leftmost x y ~ x and leftmost x y ~ y, and `leftmost x y` is either `x` or `y`

  Visibility: public export
rightmost : (0 rel : (ty -> ty -> Type)) -> StronglyConnex ty rel => ty -> ty -> ty
  Gives the rightmost of a strongly connex relation among the given two elements, generalisation of `max`.
  
  That is, x ~ rightmost x y and y ~ rightmost x y, and `rightmost x y` is either `x` or `y`

  Visibility: public export
leftmostRelL : (0 rel : (ty -> ty -> Type)) -> Reflexive ty rel => {auto {conArg:2893} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> rel (leftmost rel x y) x
  Visibility: export
leftmostRelR : (0 rel : (ty -> ty -> Type)) -> Reflexive ty rel => {auto {conArg:2963} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> rel (leftmost rel x y) y
  Visibility: export
leftmostPreserves : (0 rel : (ty -> ty -> Type)) -> {auto {conArg:3030} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> Either (leftmost rel x y = x) (leftmost rel x y = y)
  Visibility: export
leftmostIsRightmostLeft : (0 rel : (ty -> ty -> Type)) -> {auto {conArg:3113} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> (z : ty) -> rel z x -> rel z y -> rel z (leftmost rel x y)
  Visibility: export
rightmostRelL : (0 rel : (ty -> ty -> Type)) -> Reflexive ty rel => {auto {conArg:3188} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> rel x (rightmost rel x y)
  Visibility: export
rightmostRelR : (0 rel : (ty -> ty -> Type)) -> Reflexive ty rel => {auto {conArg:3258} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> rel y (rightmost rel x y)
  Visibility: export
rightmostPreserves : (0 rel : (ty -> ty -> Type)) -> {auto {conArg:3325} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> Either (rightmost rel x y = x) (rightmost rel x y = y)
  Visibility: export
rightmostIsLeftmostRight : (0 rel : (ty -> ty -> Type)) -> {auto {conArg:3408} : StronglyConnex ty rel} -> (x : ty) -> (y : ty) -> (z : ty) -> rel x z -> rel y z -> rel (leftmost rel x y) z
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Control.Relation.Closure.html b/base/docs/Control.Relation.Closure.html
index 54d8247ae7..90dbefaf6b 100644
--- a/base/docs/Control.Relation.Closure.html
+++ b/base/docs/Control.Relation.Closure.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Relation.Closure(source)
Definitions
data SymClosure : Rel ty -> ty -> ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Fwd : rel x y -> SymClosure rel x y
  
Bwd : rel y x -> SymClosure rel x y

  Hints:
  
Reflexive ty rel => Reflexive ty (SymClosure rel)
  
Symmetric ty (SymClosure rel)
data TransClosure : Rel ty -> ty -> ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : TransClosure rel x x
  
(::) : rel x y -> TransClosure rel y z -> TransClosure rel x z

  Hints:
  
Symmetric ty rel => Equivalence ty (TransClosure rel)
  
Symmetric ty rel => Euclidean ty (TransClosure rel)
  
Symmetric ty rel => PartialEquivalence ty (TransClosure rel)
  
Reflexive ty (TransClosure rel)
  
Symmetric ty rel => Symmetric ty (TransClosure rel)
  
Symmetric ty rel => Tolerance ty (TransClosure rel)
  
Transitive ty (TransClosure rel)

\ No newline at end of file
+
Control.Relation.Closure(source)
Definitions
data SymClosure : Rel ty -> ty -> ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Fwd : rel x y -> SymClosure rel x y
  
Bwd : rel y x -> SymClosure rel x y

  Hints:
  
Reflexive ty rel => Reflexive ty (SymClosure rel)
  
Symmetric ty (SymClosure rel)
data TransClosure : Rel ty -> ty -> ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : TransClosure rel x x
  
(::) : rel x y -> TransClosure rel y z -> TransClosure rel x z

  Hints:
  
Symmetric ty rel => Equivalence ty (TransClosure rel)
  
Symmetric ty rel => Euclidean ty (TransClosure rel)
  
Symmetric ty rel => PartialEquivalence ty (TransClosure rel)
  
Reflexive ty (TransClosure rel)
  
Symmetric ty rel => Symmetric ty (TransClosure rel)
  
Symmetric ty rel => Tolerance ty (TransClosure rel)
  
Transitive ty (TransClosure rel)

\ No newline at end of file
diff --git a/base/docs/Control.Relation.html b/base/docs/Control.Relation.html
index 3da03693da..ff5636f608 100644
--- a/base/docs/Control.Relation.html
+++ b/base/docs/Control.Relation.html
@@ -67,4 +67,4 @@
 
 This module defines some interfaces for describing properties of
 binary relations. It also proves somes relations among relations.
-
Definitions
Rel : Type -> Type
  A relation on ty is a type indexed by two ty values

  Totality: total
  Visibility: public export
interface Reflexive : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is reflexive if x ~ x for every x.

  Parameters: ty, rel
Constructor: 
MkReflexive

Methods:
  
reflexive : rel x x

Implementations:
  
(Transitive ty rel, (Symmetric ty rel, Serial ty rel)) => Reflexive ty rel
  
Reflexive ty Equal
  
Reflexive Nat LTE
reflexive : Reflexive ty rel => rel x x
  Totality: total
  Visibility: public export
interface Transitive : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is transitive if x ~ z when x ~ y and y ~ z.

  Parameters: ty, rel
Constructor: 
MkTransitive

Methods:
  
transitive : rel x y -> rel y z -> rel x z

Implementations:
  
Transitive ty Equal
  
Transitive Nat LTE
transitive : Transitive ty rel => rel x y -> rel y z -> rel x z
  Totality: total
  Visibility: public export
interface Symmetric : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is symmetric if y ~ x when x ~ y.

  Parameters: ty, rel
Constructor: 
MkSymmetric

Methods:
  
symmetric : rel x y -> rel y x

Implementation: 
Symmetric ty Equal
symmetric : Symmetric ty rel => rel x y -> rel y x
  Totality: total
  Visibility: public export
interface Antisymmetric : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is antisymmetric if no two distinct elements bear the relation to each other.

  Parameters: ty, rel
Constructor: 
MkAntisymmetric

Methods:
  
antisymmetric : rel x y -> rel y x -> x = y

Implementation: 
Antisymmetric Nat LTE
antisymmetric : Antisymmetric ty rel => rel x y -> rel y x -> x = y
  Totality: total
  Visibility: public export
interface Dense : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is dense if when x ~ y there is z such that x ~ z and z ~ y.

  Parameters: ty, rel
Constructor: 
MkDense

Methods:
  
dense : rel x y -> (z : ty ** (rel x z, rel z y))

Implementation: 
Reflexive ty rel => Dense ty rel
dense : Dense ty rel => rel x y -> (z : ty ** (rel x z, rel z y))
  Totality: total
  Visibility: public export
interface Serial : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is serial if for all x there is a y such that x ~ y.

  Parameters: ty, rel
Constructor: 
MkSerial

Methods:
  
serial : (y : ty ** rel x y)

Implementation: 
Reflexive ty rel => Serial ty rel
serial : Serial ty rel => (y : ty ** rel x y)
  Totality: total
  Visibility: public export
interface Euclidean : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is euclidean if y ~ z when x ~ y and x ~ z.

  Parameters: ty, rel
Constructor: 
MkEuclidean

Methods:
  
euclidean : rel x y -> rel x z -> rel y z

Implementation: 
Euclidean ty Equal
euclidean : Euclidean ty rel => rel x y -> rel x z -> rel y z
  Totality: total
  Visibility: public export
interface Tolerance : (ty : Type) -> (ty -> ty -> Type) -> Type
  A tolerance relation is reflexive and symmetric.

  Parameters: ty, rel
Constraints: Reflexive ty rel, Symmetric ty rel
Implementation: 
Tolerance ty Equal
interface PartialEquivalence : (ty : Type) -> (ty -> ty -> Type) -> Type
  A partial equivalence is transitive and symmetric.

  Parameters: ty, rel
Constraints: Transitive ty rel, Symmetric ty rel
Implementation: 
PartialEquivalence ty Equal
interface Equivalence : (ty : Type) -> (ty -> ty -> Type) -> Type
  An equivalence relation is transitive, symmetric, and reflexive.

  Parameters: ty, rel
Constraints: Reflexive ty rel, Transitive ty rel, Symmetric ty rel
Implementation: 
Equivalence ty Equal

\ No newline at end of file
+
Definitions
Rel : Type -> Type
  A relation on ty is a type indexed by two ty values

  Totality: total
  Visibility: public export
interface Reflexive : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is reflexive if x ~ x for every x.

  Parameters: ty, rel
Constructor: 
MkReflexive

Methods:
  
reflexive : rel x x

Implementations:
  
(Transitive ty rel, (Symmetric ty rel, Serial ty rel)) => Reflexive ty rel
  
Reflexive ty Equal
  
Reflexive Nat LTE
reflexive : Reflexive ty rel => rel x x
  Totality: total
  Visibility: public export
interface Transitive : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is transitive if x ~ z when x ~ y and y ~ z.

  Parameters: ty, rel
Constructor: 
MkTransitive

Methods:
  
transitive : rel x y -> rel y z -> rel x z

Implementations:
  
Transitive ty Equal
  
Transitive Nat LTE
transitive : Transitive ty rel => rel x y -> rel y z -> rel x z
  Totality: total
  Visibility: public export
interface Symmetric : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is symmetric if y ~ x when x ~ y.

  Parameters: ty, rel
Constructor: 
MkSymmetric

Methods:
  
symmetric : rel x y -> rel y x

Implementation: 
Symmetric ty Equal
symmetric : Symmetric ty rel => rel x y -> rel y x
  Totality: total
  Visibility: public export
interface Antisymmetric : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is antisymmetric if no two distinct elements bear the relation to each other.

  Parameters: ty, rel
Constructor: 
MkAntisymmetric

Methods:
  
antisymmetric : rel x y -> rel y x -> x = y

Implementation: 
Antisymmetric Nat LTE
antisymmetric : Antisymmetric ty rel => rel x y -> rel y x -> x = y
  Totality: total
  Visibility: public export
interface Dense : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is dense if when x ~ y there is z such that x ~ z and z ~ y.

  Parameters: ty, rel
Constructor: 
MkDense

Methods:
  
dense : rel x y -> (z : ty ** (rel x z, rel z y))

Implementation: 
Reflexive ty rel => Dense ty rel
dense : Dense ty rel => rel x y -> (z : ty ** (rel x z, rel z y))
  Totality: total
  Visibility: public export
interface Serial : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is serial if for all x there is a y such that x ~ y.

  Parameters: ty, rel
Constructor: 
MkSerial

Methods:
  
serial : (y : ty ** rel x y)

Implementation: 
Reflexive ty rel => Serial ty rel
serial : Serial ty rel => (y : ty ** rel x y)
  Totality: total
  Visibility: public export
interface Euclidean : (ty : Type) -> (ty -> ty -> Type) -> Type
  A relation is euclidean if y ~ z when x ~ y and x ~ z.

  Parameters: ty, rel
Constructor: 
MkEuclidean

Methods:
  
euclidean : rel x y -> rel x z -> rel y z

Implementation: 
Euclidean ty Equal
euclidean : Euclidean ty rel => rel x y -> rel x z -> rel y z
  Totality: total
  Visibility: public export
interface Tolerance : (ty : Type) -> (ty -> ty -> Type) -> Type
  A tolerance relation is reflexive and symmetric.

  Parameters: ty, rel
Constraints: Reflexive ty rel, Symmetric ty rel
Implementation: 
Tolerance ty Equal
interface PartialEquivalence : (ty : Type) -> (ty -> ty -> Type) -> Type
  A partial equivalence is transitive and symmetric.

  Parameters: ty, rel
Constraints: Transitive ty rel, Symmetric ty rel
Implementation: 
PartialEquivalence ty Equal
interface Equivalence : (ty : Type) -> (ty -> ty -> Type) -> Type
  An equivalence relation is transitive, symmetric, and reflexive.

  Parameters: ty, rel
Constraints: Reflexive ty rel, Transitive ty rel, Symmetric ty rel
Implementation: 
Equivalence ty Equal

\ No newline at end of file
diff --git a/base/docs/Control.WellFounded.html b/base/docs/Control.WellFounded.html
index c18dfb54c5..14d8eddef9 100644
--- a/base/docs/Control.WellFounded.html
+++ b/base/docs/Control.WellFounded.html
@@ -80,4 +80,4 @@
 Many instances of well-founded induction are actually induction over
 natural numbers that are derived from the elements being inducted over. For
 this purpose, the `Sized` interface and related functions are provided.
-
Definitions
data Accessible : (a -> a -> Type) -> a -> Type
  A value is accessible if everything smaller than it is also accessible.

  Totality: total
  Visibility: public export
  Constructor: 
Access : ((y : a) -> rel y x -> Accessible rel y) -> Accessible rel x
interface WellFounded : (a : Type) -> (a -> a -> Type) -> Type
  A relation is well-founded if every element is accessible.

  Parameters: a, rel
Methods:
  
wellFounded : (x : a) -> Accessible rel x

Implementation: 
WellFounded Nat LT
wellFounded : WellFounded a rel => (x : a) -> Accessible rel x
  Totality: total
  Visibility: public export
accRec : ((x : a) -> ((y : a) -> rel y x -> b) -> b) -> (z : a) -> (0 _ : Accessible rel z) -> b
  Simply-typed recursion based on accessibility.
  
  The recursive step for an element has access to all elements smaller than
  it. The recursion will therefore halt when it reaches a minimum element.
  
  This may sometimes improve type-inference, compared to `accInd`.

  Totality: total
  Visibility: export
accInd : {0 P : a -> Type} -> ((x : a) -> ((y : a) -> rel y x -> P y) -> P x) -> (z : a) -> (0 _ : Accessible rel z) -> P z
  Depedently-typed induction based on accessibility.
  
  The recursive step for an element has access to all elements smaller than
  it. The recursion will therefore halt when it reaches a minimum element.

  Totality: total
  Visibility: export
accIndProp : {0 P : a -> Type} -> (step : ((x : a) -> ((y : a) -> rel y x -> P y) -> P x)) -> {0 RP : (x : a) -> P x -> Type} -> ((x : a) -> (f : ((y : a) -> rel y x -> P y)) -> ((y : a) -> (isRel : rel y x) -> RP y (f y isRel)) -> RP x (step x f)) -> (z : a) -> (0 acc : Accessible rel z) -> RP z (accInd step z acc)
  Depedently-typed induction for creating extrinsic proofs on results of `accInd`.

  Totality: total
  Visibility: export
wfRec : {auto 0 _ : WellFounded a rel} -> ((x : a) -> ((y : a) -> rel y x -> b) -> b) -> a -> b
  Simply-typed recursion based on well-founded-ness.
  
  This is `accRec` applied to accessibility derived from a `WellFounded`
  instance.

  Totality: total
  Visibility: export
wfInd : {auto 0 _ : WellFounded a rel} -> {0 P : a -> Type} -> ((x : a) -> ((y : a) -> rel y x -> P y) -> P x) -> (myz : a) -> P myz
  Depedently-typed induction based on well-founded-ness.
  
  This is `accInd` applied to accessibility derived from a `WellFounded`
  instance.

  Totality: total
  Visibility: export
wfIndProp : {auto 0 {conArg:1388} : WellFounded a rel} -> {0 P : a -> Type} -> (step : ((x : a) -> ((y : a) -> rel y x -> P y) -> P x)) -> {0 RP : (x : a) -> P x -> Type} -> ((x : a) -> (f : ((y : a) -> rel y x -> P y)) -> ((y : a) -> (isRel : rel y x) -> RP y (f y isRel)) -> RP x (step x f)) -> (myz : a) -> RP myz (wfInd step myz)
  Depedently-typed induction for creating extrinsic proofs on results of `wfInd`.

  Totality: total
  Visibility: export
interface Sized : Type -> Type
  Types that have a concept of size. The size must be a natural number.

  Parameters: a
Constructor: 
MkSized

Methods:
  
size : a -> Nat

Implementations:
  
Sized Nat
  
Sized (List a)
  
(Sized a, Sized b) => Sized (a, b)
size : Sized a => a -> Nat
  Totality: total
  Visibility: public export
Smaller : Sized a => a -> a -> Type
  A relation based on the size of the values.

  Totality: total
  Visibility: public export
SizeAccessible : Sized a => a -> Type
  Values that are accessible based on their size.

  Totality: total
  Visibility: public export
sizeAccessible : {auto {conArg:1594} : Sized a} -> (x : a) -> SizeAccessible x
  Any value of a sized type is accessible, since naturals are well-founded.

  Totality: total
  Visibility: export
sizeInd : {auto {conArg:1659} : Sized a} -> {0 P : a -> Type} -> ((x : a) -> ((y : a) -> Smaller y x -> P y) -> P x) -> (z : a) -> P z
  Depedently-typed induction based on the size of values.
  
  This is `accInd` applied to accessibility derived from size.

  Totality: total
  Visibility: export
sizeRec : {auto {conArg:1720} : Sized a} -> ((x : a) -> ((y : a) -> Smaller y x -> b) -> b) -> a -> b
  Simply-typed recursion based on the size of values.
  
  This is `recInd` applied to accessibility derived from size.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
data Accessible : (a -> a -> Type) -> a -> Type
  A value is accessible if everything smaller than it is also accessible.

  Totality: total
  Visibility: public export
  Constructor: 
Access : ((y : a) -> rel y x -> Accessible rel y) -> Accessible rel x
interface WellFounded : (a : Type) -> (a -> a -> Type) -> Type
  A relation is well-founded if every element is accessible.

  Parameters: a, rel
Methods:
  
wellFounded : (x : a) -> Accessible rel x

Implementation: 
WellFounded Nat LT
wellFounded : WellFounded a rel => (x : a) -> Accessible rel x
  Totality: total
  Visibility: public export
accRec : ((x : a) -> ((y : a) -> rel y x -> b) -> b) -> (z : a) -> (0 _ : Accessible rel z) -> b
  Simply-typed recursion based on accessibility.
  
  The recursive step for an element has access to all elements smaller than
  it. The recursion will therefore halt when it reaches a minimum element.
  
  This may sometimes improve type-inference, compared to `accInd`.

  Totality: total
  Visibility: export
accInd : {0 P : a -> Type} -> ((x : a) -> ((y : a) -> rel y x -> P y) -> P x) -> (z : a) -> (0 _ : Accessible rel z) -> P z
  Depedently-typed induction based on accessibility.
  
  The recursive step for an element has access to all elements smaller than
  it. The recursion will therefore halt when it reaches a minimum element.

  Totality: total
  Visibility: export
accIndProp : {0 P : a -> Type} -> (step : ((x : a) -> ((y : a) -> rel y x -> P y) -> P x)) -> {0 RP : (x : a) -> P x -> Type} -> ((x : a) -> (f : ((y : a) -> rel y x -> P y)) -> ((y : a) -> (isRel : rel y x) -> RP y (f y isRel)) -> RP x (step x f)) -> (z : a) -> (0 acc : Accessible rel z) -> RP z (accInd step z acc)
  Depedently-typed induction for creating extrinsic proofs on results of `accInd`.

  Totality: total
  Visibility: export
wfRec : {auto 0 _ : WellFounded a rel} -> ((x : a) -> ((y : a) -> rel y x -> b) -> b) -> a -> b
  Simply-typed recursion based on well-founded-ness.
  
  This is `accRec` applied to accessibility derived from a `WellFounded`
  instance.

  Totality: total
  Visibility: export
wfInd : {auto 0 _ : WellFounded a rel} -> {0 P : a -> Type} -> ((x : a) -> ((y : a) -> rel y x -> P y) -> P x) -> (myz : a) -> P myz
  Depedently-typed induction based on well-founded-ness.
  
  This is `accInd` applied to accessibility derived from a `WellFounded`
  instance.

  Totality: total
  Visibility: export
wfIndProp : {auto 0 {conArg:1388} : WellFounded a rel} -> {0 P : a -> Type} -> (step : ((x : a) -> ((y : a) -> rel y x -> P y) -> P x)) -> {0 RP : (x : a) -> P x -> Type} -> ((x : a) -> (f : ((y : a) -> rel y x -> P y)) -> ((y : a) -> (isRel : rel y x) -> RP y (f y isRel)) -> RP x (step x f)) -> (myz : a) -> RP myz (wfInd step myz)
  Depedently-typed induction for creating extrinsic proofs on results of `wfInd`.

  Totality: total
  Visibility: export
interface Sized : Type -> Type
  Types that have a concept of size. The size must be a natural number.

  Parameters: a
Constructor: 
MkSized

Methods:
  
size : a -> Nat

Implementations:
  
Sized Nat
  
Sized (List a)
  
(Sized a, Sized b) => Sized (a, b)
size : Sized a => a -> Nat
  Totality: total
  Visibility: public export
Smaller : Sized a => a -> a -> Type
  A relation based on the size of the values.

  Totality: total
  Visibility: public export
SizeAccessible : Sized a => a -> Type
  Values that are accessible based on their size.

  Totality: total
  Visibility: public export
sizeAccessible : {auto {conArg:1594} : Sized a} -> (x : a) -> SizeAccessible x
  Any value of a sized type is accessible, since naturals are well-founded.

  Totality: total
  Visibility: export
sizeInd : {auto {conArg:1659} : Sized a} -> {0 P : a -> Type} -> ((x : a) -> ((y : a) -> Smaller y x -> P y) -> P x) -> (z : a) -> P z
  Depedently-typed induction based on the size of values.
  
  This is `accInd` applied to accessibility derived from size.

  Totality: total
  Visibility: export
sizeRec : {auto {conArg:1720} : Sized a} -> ((x : a) -> ((y : a) -> Smaller y x -> b) -> b) -> a -> b
  Simply-typed recursion based on the size of values.
  
  This is `recInd` applied to accessibility derived from size.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.Bifoldable.html b/base/docs/Data.Bifoldable.html
index 355b7b6c8b..8e8ed4b3b4 100644
--- a/base/docs/Data.Bifoldable.html
+++ b/base/docs/Data.Bifoldable.html
@@ -62,4 +62,4 @@
 
 
 
Data.Bifoldable(source)
Additional utility functions for the `Bifoldable` interface.
-
Definitions
bifoldlM : Monad m => Bifoldable p => (a -> b -> m a) -> (a -> c -> m a) -> a -> p b c -> m a
  Left associative monadic bifold over a structure.

  Totality: total
  Visibility: public export
biconcat : Monoid m => Bifoldable p => p m m -> m
  Combines the elements of a structure using a monoid.

  Totality: total
  Visibility: public export
biconcatMap : Monoid m => Bifoldable p => (a -> m) -> (b -> m) -> p a b -> m
  Combines the elements of a structure,
  given ways of mapping them to a common monoid.

  Totality: total
  Visibility: public export
biand : Bifoldable p => p (Lazy Bool) (Lazy Bool) -> Bool
  The conjunction of all elements of a structure containing lazy boolean
  values.  `biand` short-circuits from left to right, evaluating until either an
  element is `False` or no elements remain.

  Totality: total
  Visibility: public export
bior : Bifoldable p => p (Lazy Bool) (Lazy Bool) -> Bool
  The disjunction of all elements of a structure containing lazy boolean
  values.  `bior` short-circuits from left to right, evaluating either until an
  element is `True` or no elements remain.

  Totality: total
  Visibility: public export
biany : Bifoldable p => (a -> Bool) -> (b -> Bool) -> p a b -> Bool
  The disjunction of the collective results of applying a predicate to all
  elements of a structure. `biany` short-circuits from left to right.

  Totality: total
  Visibility: public export
biall : Bifoldable p => (a -> Bool) -> (b -> Bool) -> p a b -> Bool
  The disjunction of the collective results of applying a predicate to all
  elements of a structure.  `biall` short-circuits from left to right.

  Totality: total
  Visibility: public export
bisum : Num a => Bifoldable p => p a a -> a
  Add together all the elements of a structure.

  Totality: total
  Visibility: public export
bisum' : Num a => Bifoldable p => p a a -> a
  Add together all the elements of a structure.
  Same as `bisum` but tail recursive.

  Totality: total
  Visibility: export
biproduct : Num a => Bifoldable p => p a a -> a
  Multiply together all elements of a structure.

  Totality: total
  Visibility: public export
biproduct' : Num a => Bifoldable p => p a a -> a
  Multiply together all elements of a structure.
  Same as `product` but tail recursive.

  Totality: total
  Visibility: export
bitraverse_ : (Bifoldable p, Applicative f) => (a -> f x) -> (b -> f y) -> p a b -> f ()
  Map each element of a structure to a computation, evaluate those
  computations and discard the results.

  Totality: total
  Visibility: public export
bisequence_ : Applicative f => Bifoldable p => p (f a) (f b) -> f ()
  Evaluate each computation in a structure and discard the results.

  Totality: total
  Visibility: public export
bifor_ : (Bifoldable p, Applicative f) => p a b -> (a -> f x) -> (b -> f y) -> f ()
  Like `bitraverse_` but with the arguments flipped.

  Totality: total
  Visibility: public export
bichoice : Alternative f => Bifoldable p => p (Lazy (f a)) (Lazy (f a)) -> f a
  Bifold using Alternative.
  
  If you have a left-biased alternative operator `<|>`, then `choice` performs
  left-biased choice from a list of alternatives, which means that it
  evaluates to the left-most non-`empty` alternative.

  Totality: total
  Visibility: public export
bichoiceMap : (Bifoldable p, Alternative f) => (a -> f x) -> (b -> f x) -> p a b -> f x
  A fused version of `bichoice` and `bimap`.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
bifoldlM : Monad m => Bifoldable p => (a -> b -> m a) -> (a -> c -> m a) -> a -> p b c -> m a
  Left associative monadic bifold over a structure.

  Totality: total
  Visibility: public export
biconcat : Monoid m => Bifoldable p => p m m -> m
  Combines the elements of a structure using a monoid.

  Totality: total
  Visibility: public export
biconcatMap : Monoid m => Bifoldable p => (a -> m) -> (b -> m) -> p a b -> m
  Combines the elements of a structure,
  given ways of mapping them to a common monoid.

  Totality: total
  Visibility: public export
biand : Bifoldable p => p (Lazy Bool) (Lazy Bool) -> Bool
  The conjunction of all elements of a structure containing lazy boolean
  values.  `biand` short-circuits from left to right, evaluating until either an
  element is `False` or no elements remain.

  Totality: total
  Visibility: public export
bior : Bifoldable p => p (Lazy Bool) (Lazy Bool) -> Bool
  The disjunction of all elements of a structure containing lazy boolean
  values.  `bior` short-circuits from left to right, evaluating either until an
  element is `True` or no elements remain.

  Totality: total
  Visibility: public export
biany : Bifoldable p => (a -> Bool) -> (b -> Bool) -> p a b -> Bool
  The disjunction of the collective results of applying a predicate to all
  elements of a structure. `biany` short-circuits from left to right.

  Totality: total
  Visibility: public export
biall : Bifoldable p => (a -> Bool) -> (b -> Bool) -> p a b -> Bool
  The disjunction of the collective results of applying a predicate to all
  elements of a structure.  `biall` short-circuits from left to right.

  Totality: total
  Visibility: public export
bisum : Num a => Bifoldable p => p a a -> a
  Add together all the elements of a structure.

  Totality: total
  Visibility: public export
bisum' : Num a => Bifoldable p => p a a -> a
  Add together all the elements of a structure.
  Same as `bisum` but tail recursive.

  Totality: total
  Visibility: export
biproduct : Num a => Bifoldable p => p a a -> a
  Multiply together all elements of a structure.

  Totality: total
  Visibility: public export
biproduct' : Num a => Bifoldable p => p a a -> a
  Multiply together all elements of a structure.
  Same as `product` but tail recursive.

  Totality: total
  Visibility: export
bitraverse_ : (Bifoldable p, Applicative f) => (a -> f x) -> (b -> f y) -> p a b -> f ()
  Map each element of a structure to a computation, evaluate those
  computations and discard the results.

  Totality: total
  Visibility: public export
bisequence_ : Applicative f => Bifoldable p => p (f a) (f b) -> f ()
  Evaluate each computation in a structure and discard the results.

  Totality: total
  Visibility: public export
bifor_ : (Bifoldable p, Applicative f) => p a b -> (a -> f x) -> (b -> f y) -> f ()
  Like `bitraverse_` but with the arguments flipped.

  Totality: total
  Visibility: public export
bichoice : Alternative f => Bifoldable p => p (Lazy (f a)) (Lazy (f a)) -> f a
  Bifold using Alternative.
  
  If you have a left-biased alternative operator `<|>`, then `choice` performs
  left-biased choice from a list of alternatives, which means that it
  evaluates to the left-most non-`empty` alternative.

  Totality: total
  Visibility: public export
bichoiceMap : (Bifoldable p, Alternative f) => (a -> f x) -> (b -> f x) -> p a b -> f x
  A fused version of `bichoice` and `bimap`.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Bits.html b/base/docs/Data.Bits.html
index ac3a78ee48..6de7f411d6 100644
--- a/base/docs/Data.Bits.html
+++ b/base/docs/Data.Bits.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Bits(source)
Reexports
import public Data.Fin
Definitions
interface Bits : Type -> Type
  The `Bits` interface defines bitwise operations over integral types.

  Parameters: a
Methods:
  
0 Index : Type
  
(.&.) : a -> a -> a
  Bitwise "and"

  Fixity Declaration: infixl operator, level 7
  
(.|.) : a -> a -> a
  Bitwise "or"

  Fixity Declaration: infixl operator, level 5
  
xor : a -> a -> a
  Bitwise "xor".

  Fixity Declaration: infixl operator, level 6
  
shiftL : a -> Index -> a
  Shift the argument left by the specified number of bits.

  Fixity Declaration: infixl operator, level 8
  
shiftR : a -> Index -> a
  Shift the argument right by the specified number of bits.

  Fixity Declaration: infixl operator, level 8
  
bit : Index -> a
  Sets the `i`-th bit.
  
zeroBits : a
  The value with all bits unset.
  
complement : a -> a
  Returns the bitwise complement of a value.
  
oneBits : a
  The value with all bits set..
  
complementBit : a -> Index -> a
  `complementBit x i` is the same as `xor x (bit i)`.
  
clearBit : a -> Index -> a
  `clearBit x i` is the same as `x .&. complement (bit i)`
  
testBit : a -> Index -> Bool
  Tests, whether the i-th bit is set in the given value.
  
setBit : a -> Index -> a
  Sets the i-th bit of a value.

Implementations:
  
Bits a => Bits (Identity a)
  
Bits Bits8
  
Bits Bits16
  
Bits Bits32
  
Bits Bits64
  
Bits Int
  
Bits Int8
  
Bits Int16
  
Bits Int32
  
Bits Int64
  
Bits Integer
  
Bits a => Bits (Const a b)
0 Index : Bits a => Type
  Totality: total
  Visibility: public export
(.&.) : Bits a => a -> a -> a
  Bitwise "and"

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 7
(.|.) : Bits a => a -> a -> a
  Bitwise "or"

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 5
xor : Bits a => a -> a -> a
  Bitwise "xor".

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 6
shiftL : {auto __con : Bits a} -> a -> Index -> a
  Shift the argument left by the specified number of bits.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 8
shiftR : {auto __con : Bits a} -> a -> Index -> a
  Shift the argument right by the specified number of bits.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 8
bit : {auto __con : Bits a} -> Index -> a
  Sets the `i`-th bit.

  Totality: total
  Visibility: public export
zeroBits : Bits a => a
  The value with all bits unset.

  Totality: total
  Visibility: public export
complement : Bits a => a -> a
  Returns the bitwise complement of a value.

  Totality: total
  Visibility: public export
oneBits : Bits a => a
  The value with all bits set..

  Totality: total
  Visibility: public export
complementBit : {auto __con : Bits a} -> a -> Index -> a
  `complementBit x i` is the same as `xor x (bit i)`.

  Totality: total
  Visibility: public export
clearBit : {auto __con : Bits a} -> a -> Index -> a
  `clearBit x i` is the same as `x .&. complement (bit i)`

  Totality: total
  Visibility: public export
testBit : {auto __con : Bits a} -> a -> Index -> Bool
  Tests, whether the i-th bit is set in the given value.

  Totality: total
  Visibility: public export
setBit : {auto __con : Bits a} -> a -> Index -> a
  Sets the i-th bit of a value.

  Totality: total
  Visibility: public export
interface FiniteBits : Type -> Type
  Parameters: a
Constraints: Bits a
Methods:
  
bitSize : Nat
  Return the number of bits in values of type `t`.
  
bitsToIndex : Fin bitSize -> Index
  Properly correlates `bitSize` and `Index`.
  
popCount : a -> Nat
  Return the number of set bits in the argument.  This number is
  known as the population count or the Hamming weight.
  
rotR : a -> Fin bitSize -> a
  Rotate the argument right by the specified number of bits.
  
rotL : a -> Fin bitSize -> a
  Rotate the argument left by the specified number of bits.

Implementations:
  
FiniteBits Bits8
  
FiniteBits Bits16
  
FiniteBits Bits32
  
FiniteBits Bits64
  
FiniteBits Int
  
FiniteBits Int8
  
FiniteBits Int16
  
FiniteBits Int32
  
FiniteBits Int64
bitSize : FiniteBits a => Nat
  Return the number of bits in values of type `t`.

  Totality: total
  Visibility: public export
bitsToIndex : {auto __con : FiniteBits a} -> Fin bitSize -> Index
  Properly correlates `bitSize` and `Index`.

  Totality: total
  Visibility: public export
popCount : FiniteBits a => a -> Nat
  Return the number of set bits in the argument.  This number is
  known as the population count or the Hamming weight.

  Totality: total
  Visibility: public export
rotR : {auto __con : FiniteBits a} -> a -> Fin bitSize -> a
  Rotate the argument right by the specified number of bits.

  Totality: total
  Visibility: public export
rotL : {auto __con : FiniteBits a} -> a -> Fin bitSize -> a
  Rotate the argument left by the specified number of bits.

  Totality: total
  Visibility: public export
asBitVector : {auto {conArg:6938} : FiniteBits a} -> a -> Vect bitSize Bool
  Totality: total
  Visibility: public export
asString : FiniteBits a => a -> String
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Bits(source)
Reexports
import public Data.Fin
Definitions
interface Bits : Type -> Type
  The `Bits` interface defines bitwise operations over integral types.

  Parameters: a
Methods:
  
0 Index : Type
  
(.&.) : a -> a -> a
  Bitwise "and"

  Fixity Declaration: infixl operator, level 7
  
(.|.) : a -> a -> a
  Bitwise "or"

  Fixity Declaration: infixl operator, level 5
  
xor : a -> a -> a
  Bitwise "xor".

  Fixity Declaration: infixl operator, level 6
  
shiftL : a -> Index -> a
  Shift the argument left by the specified number of bits.

  Fixity Declaration: infixl operator, level 8
  
shiftR : a -> Index -> a
  Shift the argument right by the specified number of bits.

  Fixity Declaration: infixl operator, level 8
  
bit : Index -> a
  Sets the `i`-th bit.
  
zeroBits : a
  The value with all bits unset.
  
complement : a -> a
  Returns the bitwise complement of a value.
  
oneBits : a
  The value with all bits set..
  
complementBit : a -> Index -> a
  `complementBit x i` is the same as `xor x (bit i)`.
  
clearBit : a -> Index -> a
  `clearBit x i` is the same as `x .&. complement (bit i)`
  
testBit : a -> Index -> Bool
  Tests, whether the i-th bit is set in the given value.
  
setBit : a -> Index -> a
  Sets the i-th bit of a value.

Implementations:
  
Bits a => Bits (Identity a)
  
Bits Bits8
  
Bits Bits16
  
Bits Bits32
  
Bits Bits64
  
Bits Int
  
Bits Int8
  
Bits Int16
  
Bits Int32
  
Bits Int64
  
Bits Integer
  
Bits a => Bits (Const a b)
0 Index : Bits a => Type
  Totality: total
  Visibility: public export
(.&.) : Bits a => a -> a -> a
  Bitwise "and"

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 7
(.|.) : Bits a => a -> a -> a
  Bitwise "or"

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 5
xor : Bits a => a -> a -> a
  Bitwise "xor".

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 6
shiftL : {auto __con : Bits a} -> a -> Index -> a
  Shift the argument left by the specified number of bits.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 8
shiftR : {auto __con : Bits a} -> a -> Index -> a
  Shift the argument right by the specified number of bits.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 8
bit : {auto __con : Bits a} -> Index -> a
  Sets the `i`-th bit.

  Totality: total
  Visibility: public export
zeroBits : Bits a => a
  The value with all bits unset.

  Totality: total
  Visibility: public export
complement : Bits a => a -> a
  Returns the bitwise complement of a value.

  Totality: total
  Visibility: public export
oneBits : Bits a => a
  The value with all bits set..

  Totality: total
  Visibility: public export
complementBit : {auto __con : Bits a} -> a -> Index -> a
  `complementBit x i` is the same as `xor x (bit i)`.

  Totality: total
  Visibility: public export
clearBit : {auto __con : Bits a} -> a -> Index -> a
  `clearBit x i` is the same as `x .&. complement (bit i)`

  Totality: total
  Visibility: public export
testBit : {auto __con : Bits a} -> a -> Index -> Bool
  Tests, whether the i-th bit is set in the given value.

  Totality: total
  Visibility: public export
setBit : {auto __con : Bits a} -> a -> Index -> a
  Sets the i-th bit of a value.

  Totality: total
  Visibility: public export
interface FiniteBits : Type -> Type
  Parameters: a
Constraints: Bits a
Methods:
  
bitSize : Nat
  Return the number of bits in values of type `t`.
  
bitsToIndex : Fin bitSize -> Index
  Properly correlates `bitSize` and `Index`.
  
popCount : a -> Nat
  Return the number of set bits in the argument.  This number is
  known as the population count or the Hamming weight.
  
rotR : a -> Fin bitSize -> a
  Rotate the argument right by the specified number of bits.
  
rotL : a -> Fin bitSize -> a
  Rotate the argument left by the specified number of bits.

Implementations:
  
FiniteBits Bits8
  
FiniteBits Bits16
  
FiniteBits Bits32
  
FiniteBits Bits64
  
FiniteBits Int
  
FiniteBits Int8
  
FiniteBits Int16
  
FiniteBits Int32
  
FiniteBits Int64
bitSize : FiniteBits a => Nat
  Return the number of bits in values of type `t`.

  Totality: total
  Visibility: public export
bitsToIndex : {auto __con : FiniteBits a} -> Fin bitSize -> Index
  Properly correlates `bitSize` and `Index`.

  Totality: total
  Visibility: public export
popCount : FiniteBits a => a -> Nat
  Return the number of set bits in the argument.  This number is
  known as the population count or the Hamming weight.

  Totality: total
  Visibility: public export
rotR : {auto __con : FiniteBits a} -> a -> Fin bitSize -> a
  Rotate the argument right by the specified number of bits.

  Totality: total
  Visibility: public export
rotL : {auto __con : FiniteBits a} -> a -> Fin bitSize -> a
  Rotate the argument left by the specified number of bits.

  Totality: total
  Visibility: public export
asBitVector : {auto {conArg:6938} : FiniteBits a} -> a -> Vect bitSize Bool
  Totality: total
  Visibility: public export
asString : FiniteBits a => a -> String
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Bool.Xor.html b/base/docs/Data.Bool.Xor.html
index bc10eb5670..0959a0f8e5 100644
--- a/base/docs/Data.Bool.Xor.html
+++ b/base/docs/Data.Bool.Xor.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Bool.Xor(source)
Definitions
xor : Bool -> Bool -> Bool
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 6
xorSameFalse : (b : Bool) -> b `xor` b = False
  Totality: total
  Visibility: export
xorFalseNeutral : (b : Bool) -> False `xor` b = b
  Totality: total
  Visibility: export
xorTrueNot : (b : Bool) -> True `xor` b = not b
  Totality: total
  Visibility: export
notXor : (a : Bool) -> (b : Bool) -> not (a `xor` b) = not a `xor` b
  Totality: total
  Visibility: export
notXorCancel : (a : Bool) -> (b : Bool) -> not a `xor` not b = a `xor` b
  Totality: total
  Visibility: export
xorAssociative : (a : Bool) -> (b : Bool) -> (c : Bool) -> a `xor` (b `xor` c) = (a `xor` b) `xor` c
  Totality: total
  Visibility: export
xorCommutative : (a : Bool) -> (b : Bool) -> a `xor` b = b `xor` a
  Totality: total
  Visibility: export
xorNotTrue : (a : Bool) -> a `xor` not a = True
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Bool.Xor(source)
Definitions
xor : Bool -> Bool -> Bool
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 6
xorSameFalse : (b : Bool) -> b `xor` b = False
  Totality: total
  Visibility: export
xorFalseNeutral : (b : Bool) -> False `xor` b = b
  Totality: total
  Visibility: export
xorTrueNot : (b : Bool) -> True `xor` b = not b
  Totality: total
  Visibility: export
notXor : (a : Bool) -> (b : Bool) -> not (a `xor` b) = not a `xor` b
  Totality: total
  Visibility: export
notXorCancel : (a : Bool) -> (b : Bool) -> not a `xor` not b = a `xor` b
  Totality: total
  Visibility: export
xorAssociative : (a : Bool) -> (b : Bool) -> (c : Bool) -> a `xor` (b `xor` c) = (a `xor` b) `xor` c
  Totality: total
  Visibility: export
xorCommutative : (a : Bool) -> (b : Bool) -> a `xor` b = b `xor` a
  Totality: total
  Visibility: export
xorNotTrue : (a : Bool) -> a `xor` not a = True
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.Bool.html b/base/docs/Data.Bool.html
index f9549f2351..e105d94a74 100644
--- a/base/docs/Data.Bool.html
+++ b/base/docs/Data.Bool.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Bool(source)
Definitions
notInvolutive : (x : Bool) -> not (not x) = x
  Totality: total
  Visibility: export
andSameNeutral : (x : Bool) -> x && Delay x = x
  Totality: total
  Visibility: export
andFalseFalse : (x : Bool) -> x && Delay False = False
  Totality: total
  Visibility: export
andTrueNeutral : (x : Bool) -> x && Delay True = x
  Totality: total
  Visibility: export
andAssociative : (x : Bool) -> (y : Bool) -> (z : Bool) -> x && Delay (y && Delay z) = (x && Delay y) && Delay z
  Totality: total
  Visibility: export
andCommutative : (x : Bool) -> (y : Bool) -> x && Delay y = y && Delay x
  Totality: total
  Visibility: export
andNotFalse : (x : Bool) -> x && Delay (not x) = False
  Totality: total
  Visibility: export
orSameNeutral : (x : Bool) -> x || Delay x = x
  Totality: total
  Visibility: export
orFalseNeutral : (x : Bool) -> x || Delay False = x
  Totality: total
  Visibility: export
orTrueTrue : (x : Bool) -> x || Delay True = True
  Totality: total
  Visibility: export
orAssociative : (x : Bool) -> (y : Bool) -> (z : Bool) -> x || Delay (y || Delay z) = (x || Delay y) || Delay z
  Totality: total
  Visibility: export
orCommutative : (x : Bool) -> (y : Bool) -> x || Delay y = y || Delay x
  Totality: total
  Visibility: export
orNotTrue : (x : Bool) -> x || Delay (not x) = True
  Totality: total
  Visibility: export
orBothFalse : (0 _ : x || Delay y = False) -> (x = False, y = False)
  Totality: total
  Visibility: export
orSameAndRightNeutral : (x : Bool) -> (y : Bool) -> x || Delay (x && Delay y) = x
  Totality: total
  Visibility: export
andDistribOrR : (x : Bool) -> (y : Bool) -> (z : Bool) -> x && Delay (y || Delay z) = (x && Delay y) || Delay (x && Delay z)
  Totality: total
  Visibility: export
orDistribAndR : (x : Bool) -> (y : Bool) -> (z : Bool) -> x || Delay (y && Delay z) = (x || Delay y) && Delay (x || Delay z)
  Totality: total
  Visibility: export
notAndIsOr : (x : Bool) -> (y : Bool) -> not (x && Delay y) = not x || Delay (not y)
  Totality: total
  Visibility: export
notOrIsAnd : (x : Bool) -> (y : Bool) -> not (x || Delay y) = not x && Delay (not y)
  Totality: total
  Visibility: export
notTrueIsFalse : Not (x = True) -> x = False
  Totality: total
  Visibility: export
notFalseIsTrue : Not (x = False) -> x = True
  Totality: total
  Visibility: export
invertContraBool : (a : Bool) -> (b : Bool) -> Not (a = b) -> not a = b
  You can reverse decidability when bool is involved.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Bool(source)
Definitions
notInvolutive : (x : Bool) -> not (not x) = x
  Totality: total
  Visibility: export
andSameNeutral : (x : Bool) -> x && Delay x = x
  Totality: total
  Visibility: export
andFalseFalse : (x : Bool) -> x && Delay False = False
  Totality: total
  Visibility: export
andTrueNeutral : (x : Bool) -> x && Delay True = x
  Totality: total
  Visibility: export
andAssociative : (x : Bool) -> (y : Bool) -> (z : Bool) -> x && Delay (y && Delay z) = (x && Delay y) && Delay z
  Totality: total
  Visibility: export
andCommutative : (x : Bool) -> (y : Bool) -> x && Delay y = y && Delay x
  Totality: total
  Visibility: export
andNotFalse : (x : Bool) -> x && Delay (not x) = False
  Totality: total
  Visibility: export
orSameNeutral : (x : Bool) -> x || Delay x = x
  Totality: total
  Visibility: export
orFalseNeutral : (x : Bool) -> x || Delay False = x
  Totality: total
  Visibility: export
orTrueTrue : (x : Bool) -> x || Delay True = True
  Totality: total
  Visibility: export
orAssociative : (x : Bool) -> (y : Bool) -> (z : Bool) -> x || Delay (y || Delay z) = (x || Delay y) || Delay z
  Totality: total
  Visibility: export
orCommutative : (x : Bool) -> (y : Bool) -> x || Delay y = y || Delay x
  Totality: total
  Visibility: export
orNotTrue : (x : Bool) -> x || Delay (not x) = True
  Totality: total
  Visibility: export
orBothFalse : (0 _ : x || Delay y = False) -> (x = False, y = False)
  Totality: total
  Visibility: export
orSameAndRightNeutral : (x : Bool) -> (y : Bool) -> x || Delay (x && Delay y) = x
  Totality: total
  Visibility: export
andDistribOrR : (x : Bool) -> (y : Bool) -> (z : Bool) -> x && Delay (y || Delay z) = (x && Delay y) || Delay (x && Delay z)
  Totality: total
  Visibility: export
orDistribAndR : (x : Bool) -> (y : Bool) -> (z : Bool) -> x || Delay (y && Delay z) = (x || Delay y) && Delay (x || Delay z)
  Totality: total
  Visibility: export
notAndIsOr : (x : Bool) -> (y : Bool) -> not (x && Delay y) = not x || Delay (not y)
  Totality: total
  Visibility: export
notOrIsAnd : (x : Bool) -> (y : Bool) -> not (x || Delay y) = not x && Delay (not y)
  Totality: total
  Visibility: export
notTrueIsFalse : Not (x = True) -> x = False
  Totality: total
  Visibility: export
notFalseIsTrue : Not (x = False) -> x = True
  Totality: total
  Visibility: export
invertContraBool : (a : Bool) -> (b : Bool) -> Not (a = b) -> not a = b
  You can reverse decidability when bool is involved.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Buffer.html b/base/docs/Data.Buffer.html
index 3b6c1681f4..6f5d17228f 100644
--- a/base/docs/Data.Buffer.html
+++ b/base/docs/Data.Buffer.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Buffer(source)
Definitions
data Buffer : Type
  Totality: total
  Visibility: export
rawSize : HasIO io => Buffer -> io Int
  Totality: total
  Visibility: export
newBuffer : HasIO io => Int -> io (Maybe Buffer)
  Totality: total
  Visibility: export
=DEPRECATED=
setByte : HasIO io => Buffer -> Int -> Int -> io ()
  Use `setBits8` instead, as its value is correctly limited.

  Totality: total
  Visibility: export
setBits8 : HasIO io => Buffer -> Int -> Bits8 -> io ()
  Totality: total
  Visibility: export
=DEPRECATED=
getByte : HasIO io => Buffer -> Int -> io Int
  Use `getBits8` instead, as its value is correctly limited.

  Totality: total
  Visibility: export
getBits8 : HasIO io => Buffer -> Int -> io Bits8
  Totality: total
  Visibility: export
setBits16 : HasIO io => Buffer -> Int -> Bits16 -> io ()
  Totality: total
  Visibility: export
getBits16 : HasIO io => Buffer -> Int -> io Bits16
  Totality: total
  Visibility: export
setBits32 : HasIO io => Buffer -> Int -> Bits32 -> io ()
  Totality: total
  Visibility: export
getBits32 : HasIO io => Buffer -> Int -> io Bits32
  Totality: total
  Visibility: export
setBits64 : HasIO io => Buffer -> Int -> Bits64 -> io ()
  Totality: total
  Visibility: export
getBits64 : HasIO io => Buffer -> Int -> io Bits64
  Totality: total
  Visibility: export
setInt8 : HasIO io => Buffer -> Int -> Int8 -> io ()
  Totality: total
  Visibility: export
getInt8 : HasIO io => Buffer -> Int -> io Int8
  Totality: total
  Visibility: export
setInt16 : HasIO io => Buffer -> Int -> Int16 -> io ()
  Totality: total
  Visibility: export
getInt16 : HasIO io => Buffer -> Int -> io Int16
  Totality: total
  Visibility: export
setInt32 : HasIO io => Buffer -> Int -> Int32 -> io ()
  Totality: total
  Visibility: export
getInt32 : HasIO io => Buffer -> Int -> io Int32
  Totality: total
  Visibility: export
setInt64 : HasIO io => Buffer -> Int -> Int64 -> io ()
  Totality: total
  Visibility: export
getInt64 : HasIO io => Buffer -> Int -> io Int64
  Totality: total
  Visibility: export
setInt : HasIO io => Buffer -> Int -> Int -> io ()
  Totality: total
  Visibility: export
getInt : HasIO io => Buffer -> Int -> io Int
  Totality: total
  Visibility: export
setDouble : HasIO io => Buffer -> Int -> Double -> io ()
  Totality: total
  Visibility: export
getDouble : HasIO io => Buffer -> Int -> io Double
  Totality: total
  Visibility: export
setBool : HasIO io => Buffer -> Int -> Bool -> io ()
  Totality: total
  Visibility: export
getBool : HasIO io => Buffer -> Int -> io Bool
  Totality: total
  Visibility: export
setNat : HasIO io => Buffer -> Int -> Nat -> io Int
  setNat returns the end offset

  Totality: total
  Visibility: export
getNat : HasIO io => Buffer -> Int -> io (Int, Nat)
  getNat returns the end offset

  Totality: total
  Visibility: export
setInteger : HasIO io => Buffer -> Int -> Integer -> io Int
  setInteger returns the end offset

  Totality: total
  Visibility: export
getInteger : HasIO io => Buffer -> Int -> io (Int, Integer)
  getInteger returns the end offset

  Totality: total
  Visibility: export
stringByteLength : String -> Int
setString : HasIO io => Buffer -> Int -> String -> io ()
  Totality: total
  Visibility: export
getString : HasIO io => Buffer -> Int -> Int -> io String
  Totality: total
  Visibility: export
=DEPRECATED=
bufferData : HasIO io => Buffer -> io (List Int)
  Use `bufferData'` instead, as its value is correctly limited.

  Visibility: export
bufferData' : HasIO io => Buffer -> io (List Bits8)
  This function performs the same task as `bufferData` but it
  returns `List Bits8` which is more correct than `List Int`.

  Visibility: export
copyData : HasIO io => Buffer -> Int -> Int -> Buffer -> Int -> io ()
  Totality: total
  Visibility: export
resizeBuffer : HasIO io => Buffer -> Int -> io (Maybe Buffer)
  Totality: total
  Visibility: export
concatBuffers : HasIO io => List Buffer -> io (Maybe Buffer)
  Create a buffer containing the concatenated content from a
  list of buffers.

  Totality: total
  Visibility: export
splitBuffer : HasIO io => Buffer -> Int -> io (Maybe (Buffer, Buffer))
  Split a buffer into two at a position.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Buffer(source)
Definitions
data Buffer : Type
  Totality: total
  Visibility: export
rawSize : HasIO io => Buffer -> io Int
  Totality: total
  Visibility: export
newBuffer : HasIO io => Int -> io (Maybe Buffer)
  Totality: total
  Visibility: export
=DEPRECATED=
setByte : HasIO io => Buffer -> Int -> Int -> io ()
  Use `setBits8` instead, as its value is correctly limited.

  Totality: total
  Visibility: export
setBits8 : HasIO io => Buffer -> Int -> Bits8 -> io ()
  Totality: total
  Visibility: export
=DEPRECATED=
getByte : HasIO io => Buffer -> Int -> io Int
  Use `getBits8` instead, as its value is correctly limited.

  Totality: total
  Visibility: export
getBits8 : HasIO io => Buffer -> Int -> io Bits8
  Totality: total
  Visibility: export
setBits16 : HasIO io => Buffer -> Int -> Bits16 -> io ()
  Totality: total
  Visibility: export
getBits16 : HasIO io => Buffer -> Int -> io Bits16
  Totality: total
  Visibility: export
setBits32 : HasIO io => Buffer -> Int -> Bits32 -> io ()
  Totality: total
  Visibility: export
getBits32 : HasIO io => Buffer -> Int -> io Bits32
  Totality: total
  Visibility: export
setBits64 : HasIO io => Buffer -> Int -> Bits64 -> io ()
  Totality: total
  Visibility: export
getBits64 : HasIO io => Buffer -> Int -> io Bits64
  Totality: total
  Visibility: export
setInt8 : HasIO io => Buffer -> Int -> Int8 -> io ()
  Totality: total
  Visibility: export
getInt8 : HasIO io => Buffer -> Int -> io Int8
  Totality: total
  Visibility: export
setInt16 : HasIO io => Buffer -> Int -> Int16 -> io ()
  Totality: total
  Visibility: export
getInt16 : HasIO io => Buffer -> Int -> io Int16
  Totality: total
  Visibility: export
setInt32 : HasIO io => Buffer -> Int -> Int32 -> io ()
  Totality: total
  Visibility: export
getInt32 : HasIO io => Buffer -> Int -> io Int32
  Totality: total
  Visibility: export
setInt64 : HasIO io => Buffer -> Int -> Int64 -> io ()
  Totality: total
  Visibility: export
getInt64 : HasIO io => Buffer -> Int -> io Int64
  Totality: total
  Visibility: export
setInt : HasIO io => Buffer -> Int -> Int -> io ()
  Totality: total
  Visibility: export
getInt : HasIO io => Buffer -> Int -> io Int
  Totality: total
  Visibility: export
setDouble : HasIO io => Buffer -> Int -> Double -> io ()
  Totality: total
  Visibility: export
getDouble : HasIO io => Buffer -> Int -> io Double
  Totality: total
  Visibility: export
setBool : HasIO io => Buffer -> Int -> Bool -> io ()
  Totality: total
  Visibility: export
getBool : HasIO io => Buffer -> Int -> io Bool
  Totality: total
  Visibility: export
setNat : HasIO io => Buffer -> Int -> Nat -> io Int
  setNat returns the end offset

  Totality: total
  Visibility: export
getNat : HasIO io => Buffer -> Int -> io (Int, Nat)
  getNat returns the end offset

  Totality: total
  Visibility: export
setInteger : HasIO io => Buffer -> Int -> Integer -> io Int
  setInteger returns the end offset

  Totality: total
  Visibility: export
getInteger : HasIO io => Buffer -> Int -> io (Int, Integer)
  getInteger returns the end offset

  Totality: total
  Visibility: export
stringByteLength : String -> Int
setString : HasIO io => Buffer -> Int -> String -> io ()
  Totality: total
  Visibility: export
getString : HasIO io => Buffer -> Int -> Int -> io String
  Totality: total
  Visibility: export
=DEPRECATED=
bufferData : HasIO io => Buffer -> io (List Int)
  Use `bufferData'` instead, as its value is correctly limited.

  Visibility: export
bufferData' : HasIO io => Buffer -> io (List Bits8)
  This function performs the same task as `bufferData` but it
  returns `List Bits8` which is more correct than `List Int`.

  Visibility: export
copyData : HasIO io => Buffer -> Int -> Int -> Buffer -> Int -> io ()
  Totality: total
  Visibility: export
resizeBuffer : HasIO io => Buffer -> Int -> io (Maybe Buffer)
  Totality: total
  Visibility: export
concatBuffers : HasIO io => List Buffer -> io (Maybe Buffer)
  Create a buffer containing the concatenated content from a
  list of buffers.

  Totality: total
  Visibility: export
splitBuffer : HasIO io => Buffer -> Int -> io (Maybe (Buffer, Buffer))
  Split a buffer into two at a position.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.Colist.html b/base/docs/Data.Colist.html
index a50b087cc9..80679a94ea 100644
--- a/base/docs/Data.Colist.html
+++ b/base/docs/Data.Colist.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Colist(source)
Reexports
import public Data.Zippable
Definitions
data Colist : Type -> Type
  A possibly finite Stream.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Colist a
  
(::) : a -> Inf (Colist a) -> Colist a

  Hints:
  
Applicative Colist
  
Functor Colist
  
Monoid (Colist a)
  
Semigroup (Colist a)
  
Uninhabited (InBounds k xs) => Uninhabited (InBounds (S k) (x :: Delay xs))
  
Zippable Colist
fromList : List a -> Colist a
  Convert a list to a `Colist`.

  Totality: total
  Visibility: public export
fromStream : Stream a -> Colist a
  Convert a stream to a `Colist`.

  Totality: total
  Visibility: public export
singleton : a -> Colist a
  Create a `Colist` of only a single element.

  Totality: total
  Visibility: public export
repeat : a -> Colist a
  An infinite `Colist` of repetitions of the same element.

  Totality: total
  Visibility: public export
replicate : Nat -> a -> Colist a
  Create a `Colist` of `n` replications of the given element.

  Totality: total
  Visibility: public export
cycle : List a -> Colist a
  Produce a `Colist` by repeating a sequence.

  Totality: total
  Visibility: public export
iterate : (a -> a) -> a -> Colist a
  Generate an infinite `Colist` by repeatedly applying a function.

  Totality: total
  Visibility: public export
iterateMaybe : (a -> Maybe a) -> Maybe a -> Colist a
  Generate a `Colist` by repeatedly applying a function.
  This stops once the function returns `Nothing`.

  Totality: total
  Visibility: public export
unfold : (s -> Maybe (s, a)) -> s -> Colist a
  Generate an `Colist` by repeatedly applying a function
  to a seed value.
  This stops once the function returns `Nothing`.

  Totality: total
  Visibility: public export
isNil : Colist a -> Bool
  True, if this is the empty `Colist`.

  Totality: total
  Visibility: public export
isCons : Colist a -> Bool
  True, if the given `Colist` is non-empty.

  Totality: total
  Visibility: public export
append : Colist a -> Colist a -> Colist a
  Concatenate two `Colist`s.

  Totality: total
  Visibility: public export
lappend : List a -> Colist a -> Colist a
  Append a `Colist` to a `List`.

  Totality: total
  Visibility: public export
appendl : Colist a -> List a -> Colist a
  Append a `List` to a `Colist`.

  Totality: total
  Visibility: public export
uncons : Colist a -> Maybe (a, Colist a)
  Try to extract the head and tail of a `Colist`.

  Totality: total
  Visibility: public export
head : Colist a -> Maybe a
  Try to extract the first element from a `Colist`.

  Totality: total
  Visibility: public export
tail : Colist a -> Maybe (Colist a)
  Try to drop the first element from a `Colist`.
  This returns `Nothing` if the given `Colist` is
  empty.

  Totality: total
  Visibility: public export
take : Nat -> Colist a -> List a
  Take up to `n` elements from a `Colist`.

  Totality: total
  Visibility: public export
takeUntil : (a -> Bool) -> Colist a -> Colist a
  Take elements from a `Colist` up to and including the
  first element, for which `p` returns `True`.

  Totality: total
  Visibility: public export
takeBefore : (a -> Bool) -> Colist a -> Colist a
  Take elements from a `Colist` up to (but not including) the
  first element, for which `p` returns `True`.

  Totality: total
  Visibility: public export
takeWhile : (a -> Bool) -> Colist a -> Colist a
  Take elements from a `Colist` while the given predicate
  returns `True`.

  Totality: total
  Visibility: public export
takeWhileJust : Colist (Maybe a) -> Colist a
  Extract all values wrapped in `Just` from the beginning
  of a `Colist`. This stops, once the first `Nothing` is encountered.

  Totality: total
  Visibility: public export
drop : Nat -> Colist a -> Colist a
  Drop up to `n` elements from the beginning of the `Colist`.

  Totality: total
  Visibility: public export
index : Nat -> Colist a -> Maybe a
  Try to extract the `n`-th element from a `Colist`.

  Totality: total
  Visibility: public export
scanl : (a -> b -> a) -> a -> Colist b -> Colist a
  Produce a `Colist` of left folds of prefixes of the given `Colist`.
  @ f the combining function
  @ acc the initial value
  @ xs the `Colist` to process

  Totality: total
  Visibility: public export
data InBounds : Nat -> Colist a -> Type
  Satisfiable if `k` is a valid index into `xs`
  
  @ k the potential index
  @ xs the Colist into which k may be an index

  Totality: total
  Visibility: public export
  Constructors:
  
InFirst : InBounds 0 (x :: xs)
  Z is a valid index into any cons cell
  
InLater : InBounds k (Force xs) -> InBounds (S k) (x :: xs)
  Valid indices can be extended

  Hints:
  
Uninhabited (InBounds k [])
  
Uninhabited (InBounds k xs) => Uninhabited (InBounds (S k) (x :: Delay xs))
inBounds : (k : Nat) -> (xs : Colist a) -> Dec (InBounds k xs)
  Decide whether `k` is a valid index into Colist `xs`

  Totality: total
  Visibility: public export
index' : (k : Nat) -> (xs : Colist a) -> {auto 0 _ : InBounds k xs} -> a
  Find a particular element of a Colist using InBounds
  
  @ ok a proof that the index is within bounds

  Totality: total
  Visibility: public export
ZippableColist : Zippable Colist
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Colist(source)
Reexports
import public Data.Zippable
Definitions
data Colist : Type -> Type
  A possibly finite Stream.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Colist a
  
(::) : a -> Inf (Colist a) -> Colist a

  Hints:
  
Applicative Colist
  
Functor Colist
  
Monoid (Colist a)
  
Semigroup (Colist a)
  
Uninhabited (InBounds k xs) => Uninhabited (InBounds (S k) (x :: Delay xs))
  
Zippable Colist
fromList : List a -> Colist a
  Convert a list to a `Colist`.

  Totality: total
  Visibility: public export
fromStream : Stream a -> Colist a
  Convert a stream to a `Colist`.

  Totality: total
  Visibility: public export
singleton : a -> Colist a
  Create a `Colist` of only a single element.

  Totality: total
  Visibility: public export
repeat : a -> Colist a
  An infinite `Colist` of repetitions of the same element.

  Totality: total
  Visibility: public export
replicate : Nat -> a -> Colist a
  Create a `Colist` of `n` replications of the given element.

  Totality: total
  Visibility: public export
cycle : List a -> Colist a
  Produce a `Colist` by repeating a sequence.

  Totality: total
  Visibility: public export
iterate : (a -> a) -> a -> Colist a
  Generate an infinite `Colist` by repeatedly applying a function.

  Totality: total
  Visibility: public export
iterateMaybe : (a -> Maybe a) -> Maybe a -> Colist a
  Generate a `Colist` by repeatedly applying a function.
  This stops once the function returns `Nothing`.

  Totality: total
  Visibility: public export
unfold : (s -> Maybe (s, a)) -> s -> Colist a
  Generate an `Colist` by repeatedly applying a function
  to a seed value.
  This stops once the function returns `Nothing`.

  Totality: total
  Visibility: public export
isNil : Colist a -> Bool
  True, if this is the empty `Colist`.

  Totality: total
  Visibility: public export
isCons : Colist a -> Bool
  True, if the given `Colist` is non-empty.

  Totality: total
  Visibility: public export
append : Colist a -> Colist a -> Colist a
  Concatenate two `Colist`s.

  Totality: total
  Visibility: public export
lappend : List a -> Colist a -> Colist a
  Append a `Colist` to a `List`.

  Totality: total
  Visibility: public export
appendl : Colist a -> List a -> Colist a
  Append a `List` to a `Colist`.

  Totality: total
  Visibility: public export
uncons : Colist a -> Maybe (a, Colist a)
  Try to extract the head and tail of a `Colist`.

  Totality: total
  Visibility: public export
head : Colist a -> Maybe a
  Try to extract the first element from a `Colist`.

  Totality: total
  Visibility: public export
tail : Colist a -> Maybe (Colist a)
  Try to drop the first element from a `Colist`.
  This returns `Nothing` if the given `Colist` is
  empty.

  Totality: total
  Visibility: public export
take : Nat -> Colist a -> List a
  Take up to `n` elements from a `Colist`.

  Totality: total
  Visibility: public export
takeUntil : (a -> Bool) -> Colist a -> Colist a
  Take elements from a `Colist` up to and including the
  first element, for which `p` returns `True`.

  Totality: total
  Visibility: public export
takeBefore : (a -> Bool) -> Colist a -> Colist a
  Take elements from a `Colist` up to (but not including) the
  first element, for which `p` returns `True`.

  Totality: total
  Visibility: public export
takeWhile : (a -> Bool) -> Colist a -> Colist a
  Take elements from a `Colist` while the given predicate
  returns `True`.

  Totality: total
  Visibility: public export
takeWhileJust : Colist (Maybe a) -> Colist a
  Extract all values wrapped in `Just` from the beginning
  of a `Colist`. This stops, once the first `Nothing` is encountered.

  Totality: total
  Visibility: public export
drop : Nat -> Colist a -> Colist a
  Drop up to `n` elements from the beginning of the `Colist`.

  Totality: total
  Visibility: public export
index : Nat -> Colist a -> Maybe a
  Try to extract the `n`-th element from a `Colist`.

  Totality: total
  Visibility: public export
scanl : (a -> b -> a) -> a -> Colist b -> Colist a
  Produce a `Colist` of left folds of prefixes of the given `Colist`.
  @ f the combining function
  @ acc the initial value
  @ xs the `Colist` to process

  Totality: total
  Visibility: public export
data InBounds : Nat -> Colist a -> Type
  Satisfiable if `k` is a valid index into `xs`
  
  @ k the potential index
  @ xs the Colist into which k may be an index

  Totality: total
  Visibility: public export
  Constructors:
  
InFirst : InBounds 0 (x :: xs)
  Z is a valid index into any cons cell
  
InLater : InBounds k (Force xs) -> InBounds (S k) (x :: xs)
  Valid indices can be extended

  Hints:
  
Uninhabited (InBounds k [])
  
Uninhabited (InBounds k xs) => Uninhabited (InBounds (S k) (x :: Delay xs))
inBounds : (k : Nat) -> (xs : Colist a) -> Dec (InBounds k xs)
  Decide whether `k` is a valid index into Colist `xs`

  Totality: total
  Visibility: public export
index' : (k : Nat) -> (xs : Colist a) -> {auto 0 _ : InBounds k xs} -> a
  Find a particular element of a Colist using InBounds
  
  @ ok a proof that the index is within bounds

  Totality: total
  Visibility: public export
ZippableColist : Zippable Colist
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Colist1.html b/base/docs/Data.Colist1.html
index da11b6d0e8..02d5a62869 100644
--- a/base/docs/Data.Colist1.html
+++ b/base/docs/Data.Colist1.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Colist1(source)
Reexports
import public Data.Zippable
Definitions
data Colist1 : Type -> Type
  A possibly finite, non-empty Stream.

  Totality: total
  Visibility: public export
  Constructor: 
(:::) : a -> Colist a -> Colist1 a

  Hints:
  
Applicative Colist1
  
Functor Colist1
  
Semigroup (Colist1 a)
  
Zippable Colist1
fromList1 : List1 a -> Colist1 a
  Convert a `List1` to a `Colist1`.

  Totality: total
  Visibility: public export
fromStream : Stream a -> Colist1 a
  Convert a stream to a `Colist1`.

  Totality: total
  Visibility: public export
fromColist : Colist a -> Maybe (Colist1 a)
  Try to convert a `Colist` to a `Colist1`. Returns `Nothing` if
  the given `Colist` is empty.

  Totality: total
  Visibility: public export
fromList : List a -> Maybe (Colist1 a)
  Try to convert a list to a `Colist1`. Returns `Nothing` if
  the given list is empty.

  Totality: total
  Visibility: public export
singleton : a -> Colist1 a
  Create a `Colist1` of only a single element.

  Totality: total
  Visibility: public export
repeat : a -> Colist1 a
  An infinite `Colist1` of repetitions of the same element.

  Totality: total
  Visibility: public export
replicate : (n : Nat) -> {auto 0 _ : IsSucc n} -> a -> Colist1 a
  Create a `Colist1` of `n` replications of the given element.

  Totality: total
  Visibility: public export
cycle : List1 a -> Colist1 a
  Produce a `Colist1` by repeating a sequence

  Totality: total
  Visibility: public export
iterate : (a -> a) -> a -> Colist1 a
  Generate an infinite `Colist1` by repeatedly applying a function.

  Totality: total
  Visibility: public export
iterateMaybe : (a -> Maybe a) -> a -> Colist1 a
  Generate a `Colist1` by repeatedly applying a function.
  This stops once the function returns `Nothing`.

  Totality: total
  Visibility: public export
unfold : (s -> Maybe (s, a)) -> s -> a -> Colist1 a
  Generate a `Colist1` by repeatedly applying a function
  to a seed value.
  This stops once the function returns `Nothing`.

  Totality: total
  Visibility: public export
forget : Colist1 a -> Colist a
  Convert a `Colist1` to a `Colist`

  Totality: total
  Visibility: public export
forgetInf : Inf (Colist1 a) -> Inf (Colist a)
  Convert an `Inf (Colist1 a)` to an `Inf (Colist a)`

  Totality: total
  Visibility: public export
cons : a -> Colist1 a -> Colist1 a
  Prepends an element to a `Colist1`.

  Totality: total
  Visibility: public export
append : Colist1 a -> Colist1 a -> Colist1 a
  Concatenate two `Colist1`s

  Totality: total
  Visibility: public export
lappend : List a -> Colist1 a -> Colist1 a
  Append a `Colist1` to a `List`.

  Totality: total
  Visibility: public export
appendl : Colist1 a -> List a -> Colist1 a
  Append a `List` to a `Colist1`.

  Totality: total
  Visibility: public export
uncons : Colist1 a -> (a, Colist a)
  Take a `Colist1` apart

  Totality: total
  Visibility: public export
head : Colist1 a -> a
  Extract the first element from a `Colist1`

  Totality: total
  Visibility: public export
tail : Colist1 a -> Colist a
  Drop the first element from a `Colist1`

  Totality: total
  Visibility: public export
take : (n : Nat) -> {auto 0 _ : IsSucc n} -> Colist1 a -> List1 a
  Take up to `n` elements from a `Colist1`

  Totality: total
  Visibility: public export
takeUntil : (a -> Bool) -> Colist1 a -> Colist1 a
  Take elements from a `Colist1` up to and including the
  first element, for which `p` returns `True`.

  Totality: total
  Visibility: public export
takeBefore : (a -> Bool) -> Colist1 a -> Colist a
  Take elements from a `Colist1` up to (but not including) the
  first element, for which `p` returns `True`.

  Totality: total
  Visibility: public export
takeWhile : (a -> Bool) -> Colist1 a -> Colist a
  Take elements from a `Colist1` while the given predicate `p`
  returns `True`.

  Totality: total
  Visibility: public export
takeWhileJust : Colist1 (Maybe a) -> Colist a
  Extract all values wrapped in `Just` from the beginning
  of a `Colist1`. This stops, once the first `Nothing` is encountered.

  Totality: total
  Visibility: public export
drop : Nat -> Colist1 a -> Colist a
  Drop up to `n` elements from the beginning of the `Colist1`.

  Totality: total
  Visibility: public export
index : Nat -> Colist1 a -> Maybe a
  Try to extract the `n`-th element from a `Colist1`.

  Totality: total
  Visibility: public export
scanl : (a -> b -> a) -> a -> Colist1 b -> Colist1 a
  Produce a `Colist1` of left folds of prefixes of the given `Colist1`.
  @ f the combining function
  @ acc the initial value
  @ xs the `Colist1` to process

  Totality: total
  Visibility: export
ZippableColist1 : Zippable Colist1
  Totality: total
  Visibility: public export
zig : List1 (Colist1 a) -> Colist (Colist1 a) -> Colist a
  Totality: total
  Visibility: public export
zag : List1 a -> List (Colist1 a) -> Colist (Colist1 a) -> Colist a
  Totality: total
  Visibility: public export
cantor : Colist1 (Colist1 a) -> Colist1 a
  Totality: total
  Visibility: public export
cantor : List (Colist a) -> Colist a
  Totality: total
  Visibility: public export
planeWith : {0 p : a -> Type} -> ((x : a) -> p x -> c) -> Colist1 a -> ((x : a) -> Colist1 (p x)) -> Colist1 c
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export
plane : {0 p : a -> Type} -> Colist1 a -> ((x : a) -> Colist1 (p x)) -> Colist1 (x : a ** p x)
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export
planeWith : (a -> b -> c) -> Colist1 a -> (a -> Colist1 b) -> Colist1 c
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export
plane : Colist1 a -> (a -> Colist1 b) -> Colist1 (a, b)
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Colist1(source)
Reexports
import public Data.Zippable
Definitions
data Colist1 : Type -> Type
  A possibly finite, non-empty Stream.

  Totality: total
  Visibility: public export
  Constructor: 
(:::) : a -> Colist a -> Colist1 a

  Hints:
  
Applicative Colist1
  
Functor Colist1
  
Semigroup (Colist1 a)
  
Zippable Colist1
fromList1 : List1 a -> Colist1 a
  Convert a `List1` to a `Colist1`.

  Totality: total
  Visibility: public export
fromStream : Stream a -> Colist1 a
  Convert a stream to a `Colist1`.

  Totality: total
  Visibility: public export
fromColist : Colist a -> Maybe (Colist1 a)
  Try to convert a `Colist` to a `Colist1`. Returns `Nothing` if
  the given `Colist` is empty.

  Totality: total
  Visibility: public export
fromList : List a -> Maybe (Colist1 a)
  Try to convert a list to a `Colist1`. Returns `Nothing` if
  the given list is empty.

  Totality: total
  Visibility: public export
singleton : a -> Colist1 a
  Create a `Colist1` of only a single element.

  Totality: total
  Visibility: public export
repeat : a -> Colist1 a
  An infinite `Colist1` of repetitions of the same element.

  Totality: total
  Visibility: public export
replicate : (n : Nat) -> {auto 0 _ : IsSucc n} -> a -> Colist1 a
  Create a `Colist1` of `n` replications of the given element.

  Totality: total
  Visibility: public export
cycle : List1 a -> Colist1 a
  Produce a `Colist1` by repeating a sequence

  Totality: total
  Visibility: public export
iterate : (a -> a) -> a -> Colist1 a
  Generate an infinite `Colist1` by repeatedly applying a function.

  Totality: total
  Visibility: public export
iterateMaybe : (a -> Maybe a) -> a -> Colist1 a
  Generate a `Colist1` by repeatedly applying a function.
  This stops once the function returns `Nothing`.

  Totality: total
  Visibility: public export
unfold : (s -> Maybe (s, a)) -> s -> a -> Colist1 a
  Generate a `Colist1` by repeatedly applying a function
  to a seed value.
  This stops once the function returns `Nothing`.

  Totality: total
  Visibility: public export
forget : Colist1 a -> Colist a
  Convert a `Colist1` to a `Colist`

  Totality: total
  Visibility: public export
forgetInf : Inf (Colist1 a) -> Inf (Colist a)
  Convert an `Inf (Colist1 a)` to an `Inf (Colist a)`

  Totality: total
  Visibility: public export
cons : a -> Colist1 a -> Colist1 a
  Prepends an element to a `Colist1`.

  Totality: total
  Visibility: public export
append : Colist1 a -> Colist1 a -> Colist1 a
  Concatenate two `Colist1`s

  Totality: total
  Visibility: public export
lappend : List a -> Colist1 a -> Colist1 a
  Append a `Colist1` to a `List`.

  Totality: total
  Visibility: public export
appendl : Colist1 a -> List a -> Colist1 a
  Append a `List` to a `Colist1`.

  Totality: total
  Visibility: public export
uncons : Colist1 a -> (a, Colist a)
  Take a `Colist1` apart

  Totality: total
  Visibility: public export
head : Colist1 a -> a
  Extract the first element from a `Colist1`

  Totality: total
  Visibility: public export
tail : Colist1 a -> Colist a
  Drop the first element from a `Colist1`

  Totality: total
  Visibility: public export
take : (n : Nat) -> {auto 0 _ : IsSucc n} -> Colist1 a -> List1 a
  Take up to `n` elements from a `Colist1`

  Totality: total
  Visibility: public export
takeUntil : (a -> Bool) -> Colist1 a -> Colist1 a
  Take elements from a `Colist1` up to and including the
  first element, for which `p` returns `True`.

  Totality: total
  Visibility: public export
takeBefore : (a -> Bool) -> Colist1 a -> Colist a
  Take elements from a `Colist1` up to (but not including) the
  first element, for which `p` returns `True`.

  Totality: total
  Visibility: public export
takeWhile : (a -> Bool) -> Colist1 a -> Colist a
  Take elements from a `Colist1` while the given predicate `p`
  returns `True`.

  Totality: total
  Visibility: public export
takeWhileJust : Colist1 (Maybe a) -> Colist a
  Extract all values wrapped in `Just` from the beginning
  of a `Colist1`. This stops, once the first `Nothing` is encountered.

  Totality: total
  Visibility: public export
drop : Nat -> Colist1 a -> Colist a
  Drop up to `n` elements from the beginning of the `Colist1`.

  Totality: total
  Visibility: public export
index : Nat -> Colist1 a -> Maybe a
  Try to extract the `n`-th element from a `Colist1`.

  Totality: total
  Visibility: public export
scanl : (a -> b -> a) -> a -> Colist1 b -> Colist1 a
  Produce a `Colist1` of left folds of prefixes of the given `Colist1`.
  @ f the combining function
  @ acc the initial value
  @ xs the `Colist1` to process

  Totality: total
  Visibility: export
ZippableColist1 : Zippable Colist1
  Totality: total
  Visibility: public export
zig : List1 (Colist1 a) -> Colist (Colist1 a) -> Colist a
  Totality: total
  Visibility: public export
zag : List1 a -> List (Colist1 a) -> Colist (Colist1 a) -> Colist a
  Totality: total
  Visibility: public export
cantor : Colist1 (Colist1 a) -> Colist1 a
  Totality: total
  Visibility: public export
cantor : List (Colist a) -> Colist a
  Totality: total
  Visibility: public export
planeWith : {0 p : a -> Type} -> ((x : a) -> p x -> c) -> Colist1 a -> ((x : a) -> Colist1 (p x)) -> Colist1 c
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export
plane : {0 p : a -> Type} -> Colist1 a -> ((x : a) -> Colist1 (p x)) -> Colist1 (x : a ** p x)
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export
planeWith : (a -> b -> c) -> Colist1 a -> (a -> Colist1 b) -> Colist1 c
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export
plane : Colist1 a -> (a -> Colist1 b) -> Colist1 (a, b)
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Contravariant.html b/base/docs/Data.Contravariant.html
index 9f0526cf28..30ac81bbbe 100644
--- a/base/docs/Data.Contravariant.html
+++ b/base/docs/Data.Contravariant.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Contravariant(source)
Definitions
interface Contravariant : (Type -> Type) -> Type
  Contravariant functors

  Parameters: f
Methods:
  
contramap : (a -> b) -> f b -> f a
  
(>$) : b -> f b -> f a
  Fixity Declaration: infixl operator, level 4

Implementation: 
Contravariant (Const a)
contramap : Contravariant f => (a -> b) -> f b -> f a
  Totality: total
  Visibility: public export
(>$) : Contravariant f => b -> f b -> f a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 4
phantom : Contravariant f => Functor f => f a -> f b
  If `f` is both `Functor` and `Contravariant` then by the time you factor in the
  laws of each of those classes, it can't actually use its argument in any
  meaningful capacity.

  Totality: total
  Visibility: public export
(>$<) : Contravariant f => (a -> b) -> f b -> f a
  This is an infix alias for `contramap`.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 4
(>&<) : Contravariant f => f b -> (a -> b) -> f a
  This is an infix version of `contramap` with the arguments flipped.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 4
($<) : Contravariant f => f b -> b -> f a
  This is `>$` with its arguments flipped.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 4

\ No newline at end of file
+
Data.Contravariant(source)
Definitions
interface Contravariant : (Type -> Type) -> Type
  Contravariant functors

  Parameters: f
Methods:
  
contramap : (a -> b) -> f b -> f a
  
(>$) : b -> f b -> f a
  Fixity Declaration: infixl operator, level 4

Implementation: 
Contravariant (Const a)
contramap : Contravariant f => (a -> b) -> f b -> f a
  Totality: total
  Visibility: public export
(>$) : Contravariant f => b -> f b -> f a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 4
phantom : Contravariant f => Functor f => f a -> f b
  If `f` is both `Functor` and `Contravariant` then by the time you factor in the
  laws of each of those classes, it can't actually use its argument in any
  meaningful capacity.

  Totality: total
  Visibility: public export
(>$<) : Contravariant f => (a -> b) -> f b -> f a
  This is an infix alias for `contramap`.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 4
(>&<) : Contravariant f => f b -> (a -> b) -> f a
  This is an infix version of `contramap` with the arguments flipped.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 4
($<) : Contravariant f => f b -> b -> f a
  This is `>$` with its arguments flipped.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 4

\ No newline at end of file
diff --git a/base/docs/Data.DPair.html b/base/docs/Data.DPair.html
index f060ce78f3..fedb104af5 100644
--- a/base/docs/Data.DPair.html
+++ b/base/docs/Data.DPair.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.DPair(source)
Definitions
choice : {0 p : a -> b -> Type} -> ((x : a) -> (b : b ** p x b)) -> (f : a -> b ** (x : a) -> p x (f x))
  Constructive choice: a function producing pairs of a value and a proof
  can be split into a function producing a value and a family of proofs
  for the images of that function.

  Totality: total
  Visibility: public export
choice : {0 b : a -> Type} -> {0 p : (x : a) -> b x -> Type} -> ((x : a) -> (y : b x ** p x y)) -> (f : (x : a) -> b x ** (x : a) -> p x (f x))
  Constructive choice: a function producing pairs of a value and a proof
  can be split into a function producing a value and a family of proofs
  for the images of that function.

  Totality: total
  Visibility: public export
curry : {0 p : a -> Type} -> ((x : a ** p x) -> c) -> (x : a) -> p x -> c
  A function taking a pair of a value and a proof as an argument can be turned
  into a function taking a value and a proof as two separate arguments.
  Use `uncurry` to go in the other direction

  Totality: total
  Visibility: public export
uncurry : {0 p : a -> Type} -> ((x : a) -> p x -> c) -> (x : a ** p x) -> c
  A function taking a value and a proof as two separates arguments can be turned
  into a function taking a pair of that value and its proof as a single argument.
  Use `curry` to go in the other direction.

  Totality: total
  Visibility: public export
bimap : {0 p : a -> Type} -> {0 q : b -> Type} -> (f : (a -> b)) -> (p x -> q (f x)) -> (x : a ** p x) -> (y : b ** q y)
  Given a function on values and a family of proofs that this function takes
  p-respecting inputs to q-respecting outputs,
  we can turn:  a pair of a value and a proof it is p-respecting
  into:         a pair of a value and a proof it is q-respecting

  Totality: total
  Visibility: public export
record Exists : (type -> Type) -> Type
  A dependent pair in which the first field (witness) should be
  erased at runtime.
  
  We can use `Exists` to construct dependent types in which the
  type-level value is erased at runtime but used at compile time.
  This type-level value could represent, for instance, a value
  required for an intrinsic invariant required as part of the
  dependent type's representation.
  
  @type The type of the type-level value in the proof.
  @this The dependent type that requires an instance of `type`.

  Totality: total
  Visibility: public export
  Constructor: 
Evidence : (0 fst : type) -> this fst -> Exists this

  Projections:
  
0 .fst : Exists this -> type
  
.snd : ({rec:0} : Exists this) -> this (fst {rec:0})
0 .fst : Exists this -> type
  Totality: total
  Visibility: public export
0 fst : Exists this -> type
  Totality: total
  Visibility: public export
.snd : ({rec:0} : Exists this) -> this (fst {rec:0})
  Totality: total
  Visibility: public export
snd : ({rec:0} : Exists this) -> this (fst {rec:0})
  Totality: total
  Visibility: public export
curry : (Exists p -> c) -> p x -> c
  Totality: total
  Visibility: public export
uncurry : (p x -> c) -> Exists p -> c
  Totality: total
  Visibility: public export
evidenceInjectiveFst : Evidence x p = Evidence y q -> x = y
  Totality: total
  Visibility: export
evidenceInjectiveSnd : Evidence x p = Evidence x q -> p = q
  Totality: total
  Visibility: export
bimap : (0 f : (a -> b)) -> (p x -> q (f x)) -> Exists p -> Exists q
  Totality: total
  Visibility: public export
record Subset : (type : Type) -> (type -> Type) -> Type
  A dependent pair in which the second field (evidence) should not
  be required at runtime.
  
  We can use `Subset` to provide extrinsic invariants about a
  value and know that these invariants are erased at
  runtime but used at compile time.
  
  @type The type-level value's type.
  @pred The dependent type that requires an instance of `type`.

  Totality: total
  Visibility: public export
  Constructor: 
Element : (fst : type) -> (0 _ : pred fst) -> Subset type pred

  Projections:
  
.fst : Subset type pred -> type
  
0 .snd : ({rec:0} : Subset type pred) -> pred (fst {rec:0})

  Hints:
  
Eq type => Eq (Subset type pred)
  
Ord type => Ord (Subset type pred)
  
Show type => Show (Subset type pred)
.fst : Subset type pred -> type
  Totality: total
  Visibility: public export
fst : Subset type pred -> type
  Totality: total
  Visibility: public export
0 .snd : ({rec:0} : Subset type pred) -> pred (fst {rec:0})
  Totality: total
  Visibility: public export
0 snd : ({rec:0} : Subset type pred) -> pred (fst {rec:0})
  Totality: total
  Visibility: public export
curry : (Subset a p -> c) -> (x : a) -> (0 _ : p x) -> c
  Totality: total
  Visibility: public export
uncurry : ((x : a) -> (0 _ : p x) -> c) -> Subset a p -> c
  Totality: total
  Visibility: public export
elementInjectiveFst : Element x p = Element y q -> x = y
  Totality: total
  Visibility: export
elementInjectiveSnd : Element x p = Element x q -> p = q
  Totality: total
  Visibility: export
bimap : (f : (a -> b)) -> (0 _ : (p x -> q (f x))) -> Subset a p -> Subset b q
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.DPair(source)
Definitions
choice : {0 p : a -> b -> Type} -> ((x : a) -> (b : b ** p x b)) -> (f : a -> b ** (x : a) -> p x (f x))
  Constructive choice: a function producing pairs of a value and a proof
  can be split into a function producing a value and a family of proofs
  for the images of that function.

  Totality: total
  Visibility: public export
choice : {0 b : a -> Type} -> {0 p : (x : a) -> b x -> Type} -> ((x : a) -> (y : b x ** p x y)) -> (f : (x : a) -> b x ** (x : a) -> p x (f x))
  Constructive choice: a function producing pairs of a value and a proof
  can be split into a function producing a value and a family of proofs
  for the images of that function.

  Totality: total
  Visibility: public export
curry : {0 p : a -> Type} -> ((x : a ** p x) -> c) -> (x : a) -> p x -> c
  A function taking a pair of a value and a proof as an argument can be turned
  into a function taking a value and a proof as two separate arguments.
  Use `uncurry` to go in the other direction

  Totality: total
  Visibility: public export
uncurry : {0 p : a -> Type} -> ((x : a) -> p x -> c) -> (x : a ** p x) -> c
  A function taking a value and a proof as two separates arguments can be turned
  into a function taking a pair of that value and its proof as a single argument.
  Use `curry` to go in the other direction.

  Totality: total
  Visibility: public export
bimap : {0 p : a -> Type} -> {0 q : b -> Type} -> (f : (a -> b)) -> (p x -> q (f x)) -> (x : a ** p x) -> (y : b ** q y)
  Given a function on values and a family of proofs that this function takes
  p-respecting inputs to q-respecting outputs,
  we can turn:  a pair of a value and a proof it is p-respecting
  into:         a pair of a value and a proof it is q-respecting

  Totality: total
  Visibility: public export
record Exists : (type -> Type) -> Type
  A dependent pair in which the first field (witness) should be
  erased at runtime.
  
  We can use `Exists` to construct dependent types in which the
  type-level value is erased at runtime but used at compile time.
  This type-level value could represent, for instance, a value
  required for an intrinsic invariant required as part of the
  dependent type's representation.
  
  @type The type of the type-level value in the proof.
  @this The dependent type that requires an instance of `type`.

  Totality: total
  Visibility: public export
  Constructor: 
Evidence : (0 fst : type) -> this fst -> Exists this

  Projections:
  
0 .fst : Exists this -> type
  
.snd : ({rec:0} : Exists this) -> this (fst {rec:0})
0 .fst : Exists this -> type
  Totality: total
  Visibility: public export
0 fst : Exists this -> type
  Totality: total
  Visibility: public export
.snd : ({rec:0} : Exists this) -> this (fst {rec:0})
  Totality: total
  Visibility: public export
snd : ({rec:0} : Exists this) -> this (fst {rec:0})
  Totality: total
  Visibility: public export
curry : (Exists p -> c) -> p x -> c
  Totality: total
  Visibility: public export
uncurry : (p x -> c) -> Exists p -> c
  Totality: total
  Visibility: public export
evidenceInjectiveFst : Evidence x p = Evidence y q -> x = y
  Totality: total
  Visibility: export
evidenceInjectiveSnd : Evidence x p = Evidence x q -> p = q
  Totality: total
  Visibility: export
bimap : (0 f : (a -> b)) -> (p x -> q (f x)) -> Exists p -> Exists q
  Totality: total
  Visibility: public export
record Subset : (type : Type) -> (type -> Type) -> Type
  A dependent pair in which the second field (evidence) should not
  be required at runtime.
  
  We can use `Subset` to provide extrinsic invariants about a
  value and know that these invariants are erased at
  runtime but used at compile time.
  
  @type The type-level value's type.
  @pred The dependent type that requires an instance of `type`.

  Totality: total
  Visibility: public export
  Constructor: 
Element : (fst : type) -> (0 _ : pred fst) -> Subset type pred

  Projections:
  
.fst : Subset type pred -> type
  
0 .snd : ({rec:0} : Subset type pred) -> pred (fst {rec:0})

  Hints:
  
Eq type => Eq (Subset type pred)
  
Ord type => Ord (Subset type pred)
  
Show type => Show (Subset type pred)
.fst : Subset type pred -> type
  Totality: total
  Visibility: public export
fst : Subset type pred -> type
  Totality: total
  Visibility: public export
0 .snd : ({rec:0} : Subset type pred) -> pred (fst {rec:0})
  Totality: total
  Visibility: public export
0 snd : ({rec:0} : Subset type pred) -> pred (fst {rec:0})
  Totality: total
  Visibility: public export
curry : (Subset a p -> c) -> (x : a) -> (0 _ : p x) -> c
  Totality: total
  Visibility: public export
uncurry : ((x : a) -> (0 _ : p x) -> c) -> Subset a p -> c
  Totality: total
  Visibility: public export
elementInjectiveFst : Element x p = Element y q -> x = y
  Totality: total
  Visibility: export
elementInjectiveSnd : Element x p = Element x q -> p = q
  Totality: total
  Visibility: export
bimap : (f : (a -> b)) -> (0 _ : (p x -> q (f x))) -> Subset a p -> Subset b q
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Double.html b/base/docs/Data.Double.html
index dea08662b3..0b77a00fc1 100644
--- a/base/docs/Data.Double.html
+++ b/base/docs/Data.Double.html
@@ -62,4 +62,4 @@
 
 
 
Data.Double(source)
Various IEEE floating-point number constants
-
Definitions
unitRoundoff : Double
  Largest number that can be added to a floating-point number without changing
  its value, i.e. `1.0 + unitRoundoff == 1.0`.
epsilon : Double
  Machine epsilon is the smallest floating-point number that distinguishes two
  floating-point numbers; the step size on the floating-point number line.
nan : Double
  Not a number, e.g. `0.0 / 0.0`. Never equal to anything, including itself.
inf : Double
  Positive Infinity. Can be negated to obtain Negative Infinity.

\ No newline at end of file
+
Definitions
unitRoundoff : Double
  Largest number that can be added to a floating-point number without changing
  its value, i.e. `1.0 + unitRoundoff == 1.0`.
epsilon : Double
  Machine epsilon is the smallest floating-point number that distinguishes two
  floating-point numbers; the step size on the floating-point number line.
nan : Double
  Not a number, e.g. `0.0 / 0.0`. Never equal to anything, including itself.
inf : Double
  Positive Infinity. Can be negated to obtain Negative Infinity.

\ No newline at end of file
diff --git a/base/docs/Data.Either.html b/base/docs/Data.Either.html
index d012fd5fe3..af477fd66e 100644
--- a/base/docs/Data.Either.html
+++ b/base/docs/Data.Either.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Either(source)
Reexports
import public Control.Function
Definitions
getLeft : Either a b -> Maybe a
  Extract the Left value, if possible

  Totality: total
  Visibility: public export
getRight : Either a b -> Maybe b
  Extract the Right value, if possible

  Totality: total
  Visibility: public export
isLeft : Either a b -> Bool
  True if the argument is Left, False otherwise

  Totality: total
  Visibility: public export
isRight : Either a b -> Bool
  True if the argument is Right, False otherwise

  Totality: total
  Visibility: public export
data IsRight : Either a b -> Type
  Proof that an `Either` is actually a Right value

  Totality: total
  Visibility: public export
  Constructor: 
ItIsRight : IsRight (Right x)

  Hint: 
Uninhabited (IsRight (Left x))
data IsLeft : Either a b -> Type
  Proof that an `Either` is actually a Left value

  Totality: total
  Visibility: public export
  Constructor: 
ItIsLeft : IsLeft (Left x)

  Hint: 
Uninhabited (IsLeft (Right x))
compress : List (Either a b) -> List (Either (List1 a) (List1 b))
  Compress the list of Lefts and Rights by accumulating
  all of the lefts and rights into non-empty blocks.

  Totality: total
  Visibility: export
decompress : List (Either (List1 a) (List1 b)) -> List (Either a b)
  Decompress a compressed list. This is the left inverse of `compress` but not its
  right inverse because nothing forces the input to be maximally compressed!

  Totality: total
  Visibility: export
lefts : List (Either a b) -> List a
  Keep the payloads of all Left constructors in a list of Eithers

  Totality: total
  Visibility: public export
rights : List (Either a b) -> List b
  Keep the payloads of all Right constructors in a list of Eithers

  Totality: total
  Visibility: public export
partitionEithers : List (Either a b) -> (List a, List b)
  Split a list of Eithers into a list of the left elements and a list of the right elements

  Totality: total
  Visibility: public export
fromEither : Either a a -> a
  Remove a "useless" Either by collapsing the case distinction

  Totality: total
  Visibility: public export
mirror : Either a b -> Either b a
  Right becomes left and left becomes right

  Totality: total
  Visibility: public export
pushInto : c -> Either a b -> Either (c, a) (c, b)
  Totality: total
  Visibility: export
maybeToEither : Lazy e -> Maybe a -> Either e a
  Convert a Maybe to an Either by using a default value in case of Nothing
  @ e the default value

  Totality: total
  Visibility: public export
eitherToMaybe : Either e a -> Maybe a
  Convert an Either to a Maybe from Right injection

  Totality: total
  Visibility: public export
eitherMapFusion : (f : (a -> {a:4822})) -> (g : ({b:4820} -> {a:4822})) -> (p : (b -> {b:4820})) -> (e : Either a b) -> either (Delay f) (Delay g) (map p e) = either (Delay f) (Delay (g . p)) e
  Totality: total
  Visibility: export
eitherBimapFusion : (f : ({a:4920} -> {a:4926})) -> (g : ({b:4921} -> {a:4926})) -> (p : ({a:4918} -> {a:4920})) -> (q : ({b:4919} -> {b:4921})) -> (e : Either {a:4918} {b:4919}) -> either (Delay f) (Delay g) (bimap p q e) = either (Delay (f . p)) (Delay (g . q)) e
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Either(source)
Reexports
import public Control.Function
Definitions
getLeft : Either a b -> Maybe a
  Extract the Left value, if possible

  Totality: total
  Visibility: public export
getRight : Either a b -> Maybe b
  Extract the Right value, if possible

  Totality: total
  Visibility: public export
isLeft : Either a b -> Bool
  True if the argument is Left, False otherwise

  Totality: total
  Visibility: public export
isRight : Either a b -> Bool
  True if the argument is Right, False otherwise

  Totality: total
  Visibility: public export
data IsRight : Either a b -> Type
  Proof that an `Either` is actually a Right value

  Totality: total
  Visibility: public export
  Constructor: 
ItIsRight : IsRight (Right x)

  Hint: 
Uninhabited (IsRight (Left x))
data IsLeft : Either a b -> Type
  Proof that an `Either` is actually a Left value

  Totality: total
  Visibility: public export
  Constructor: 
ItIsLeft : IsLeft (Left x)

  Hint: 
Uninhabited (IsLeft (Right x))
compress : List (Either a b) -> List (Either (List1 a) (List1 b))
  Compress the list of Lefts and Rights by accumulating
  all of the lefts and rights into non-empty blocks.

  Totality: total
  Visibility: export
decompress : List (Either (List1 a) (List1 b)) -> List (Either a b)
  Decompress a compressed list. This is the left inverse of `compress` but not its
  right inverse because nothing forces the input to be maximally compressed!

  Totality: total
  Visibility: export
lefts : List (Either a b) -> List a
  Keep the payloads of all Left constructors in a list of Eithers

  Totality: total
  Visibility: public export
rights : List (Either a b) -> List b
  Keep the payloads of all Right constructors in a list of Eithers

  Totality: total
  Visibility: public export
partitionEithers : List (Either a b) -> (List a, List b)
  Split a list of Eithers into a list of the left elements and a list of the right elements

  Totality: total
  Visibility: public export
fromEither : Either a a -> a
  Remove a "useless" Either by collapsing the case distinction

  Totality: total
  Visibility: public export
mirror : Either a b -> Either b a
  Right becomes left and left becomes right

  Totality: total
  Visibility: public export
pushInto : c -> Either a b -> Either (c, a) (c, b)
  Totality: total
  Visibility: export
maybeToEither : Lazy e -> Maybe a -> Either e a
  Convert a Maybe to an Either by using a default value in case of Nothing
  @ e the default value

  Totality: total
  Visibility: public export
eitherToMaybe : Either e a -> Maybe a
  Convert an Either to a Maybe from Right injection

  Totality: total
  Visibility: public export
eitherMapFusion : (f : (a -> {a:4822})) -> (g : ({b:4820} -> {a:4822})) -> (p : (b -> {b:4820})) -> (e : Either a b) -> either (Delay f) (Delay g) (map p e) = either (Delay f) (Delay (g . p)) e
  Totality: total
  Visibility: export
eitherBimapFusion : (f : ({a:4920} -> {a:4926})) -> (g : ({b:4921} -> {a:4926})) -> (p : ({a:4918} -> {a:4920})) -> (q : ({b:4919} -> {b:4921})) -> (e : Either {a:4918} {b:4919}) -> either (Delay f) (Delay g) (bimap p q e) = either (Delay (f . p)) (Delay (g . q)) e
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.Fin.Order.html b/base/docs/Data.Fin.Order.html
index a3bd5abce0..236df66ec8 100644
--- a/base/docs/Data.Fin.Order.html
+++ b/base/docs/Data.Fin.Order.html
@@ -62,4 +62,4 @@
 
 
 
Data.Fin.Order(source)
Implementation  of ordering relations for `Fin`ite numbers
-
Definitions
data FinLTE : Fin k -> Fin k -> Type
  Totality: total
  Visibility: public export
  Constructor: 
FromNatPrf : LTE (finToNat m) (finToNat n) -> FinLTE m n

  Hints:
  
Antisymmetric (Fin k) FinLTE
  
Connex (Fin k) FinLTE
  
Decidable 2 [Fin k, Fin k] FinLTE
  
PartialOrder (Fin k) FinLTE
  
Preorder (Fin k) FinLTE
  
Reflexive (Fin k) FinLTE
  
Transitive (Fin k) FinLTE

\ No newline at end of file
+
Definitions
data FinLTE : Fin k -> Fin k -> Type
  Totality: total
  Visibility: public export
  Constructor: 
FromNatPrf : LTE (finToNat m) (finToNat n) -> FinLTE m n

  Hints:
  
Antisymmetric (Fin k) FinLTE
  
Connex (Fin k) FinLTE
  
Decidable 2 [Fin k, Fin k] FinLTE
  
PartialOrder (Fin k) FinLTE
  
Preorder (Fin k) FinLTE
  
Reflexive (Fin k) FinLTE
  
Transitive (Fin k) FinLTE

\ No newline at end of file
diff --git a/base/docs/Data.Fin.html b/base/docs/Data.Fin.html
index 7369143087..149de3466c 100644
--- a/base/docs/Data.Fin.html
+++ b/base/docs/Data.Fin.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Fin(source)
Reexports
import public Control.Ord
import public Data.Maybe
import public Data.Nat
import public Data.So
Definitions
data Fin : Nat -> Type
  Numbers strictly less than some bound.  The name comes from "finite sets".
  
  It's probably not a good idea to use `Fin` for arithmetic, and they will be
  exceedingly inefficient at run time.
  @ n the upper bound

  Totality: total
  Visibility: public export
  Constructors:
  
FZ : Fin (S k)
  
FS : Fin k -> Fin (S k)

  Hints:
  
Cast (Fin n) Nat
  
Cast (Fin n) Integer
  
DecEq (Fin n)
  
Eq (Fin n)
  
Injective FS
  
Injective finToNat
  
Neg (Fin (S n))
  
Num (Fin (S n))
  
Ord (Fin n)
  
Show (Fin n)
  
Uninhabited (Fin 0)
  
Uninhabited (FZ = FS k)
  
Uninhabited (FS k = FZ)
  
Uninhabited (n = m) => Uninhabited (FS n = FS m)
  
Uninhabited (FS k ~~~ FZ)
  
Uninhabited (FZ ~~~ FS k)
coerce : (0 _ : m = n) -> Fin m -> Fin n
  Coerce between Fins with equal indices

  Totality: total
  Visibility: public export
finToNat : Fin n -> Nat
  Convert a Fin to a Nat

  Totality: total
  Visibility: public export
finToInteger : Fin n -> Integer
  Convert a Fin to an Integer

  Totality: total
  Visibility: public export
weaken : Fin n -> Fin (S n)
  Weaken the bound on a Fin by 1

  Totality: total
  Visibility: public export
weakenN : (0 n : Nat) -> Fin m -> Fin (m + n)
  Weaken the bound on a Fin by some amount

  Totality: total
  Visibility: public export
weakenLTE : Fin n -> LTE n m -> Fin m
  Weaken the bound on a Fin using a constructive comparison

  Totality: total
  Visibility: public export
strengthen : Fin (S n) -> Maybe (Fin n)
  Attempt to tighten the bound on a Fin.
  Return the tightened bound if there is one, else nothing.

  Totality: total
  Visibility: export
shift : (m : Nat) -> Fin n -> Fin (m + n)
  Add some natural number to a Fin, extending the bound accordingly
  @ n the previous bound
  @ m the number to increase the Fin by

  Totality: total
  Visibility: public export
finS : Fin n -> Fin n
  Increment a Fin, wrapping on overflow

  Totality: total
  Visibility: public export
last : Fin (S n)
  The largest element of some Fin type

  Totality: total
  Visibility: public export
complement : Fin n -> Fin n
  The finite complement of some Fin.
  The number as far along as the input, but starting from the other end.

  Totality: total
  Visibility: public export
allFins : (n : Nat) -> List (Fin n)
  All of the Fin elements

  Totality: total
  Visibility: public export
allFins : (n : Nat) -> List1 (Fin (S n))
  All of the Fin elements

  Totality: total
  Visibility: public export
natToFinLT : (x : Nat) -> {auto 0 _ : LT x n} -> Fin n
  Totality: total
  Visibility: public export
natToFinLt : (x : Nat) -> {auto 0 _ : So (x < n)} -> Fin n
  Totality: total
  Visibility: public export
natToFin : Nat -> (n : Nat) -> Maybe (Fin n)
  Totality: total
  Visibility: public export
integerToFin : Integer -> (n : Nat) -> Maybe (Fin n)
  Convert an `Integer` to a `Fin`, provided the integer is within bounds.
  @n The upper bound of the Fin

  Totality: total
  Visibility: public export
maybeLTE : (x : Nat) -> (y : Nat) -> Maybe (LTE x y)
  Totality: total
  Visibility: public export
maybeLT : (x : Nat) -> (y : Nat) -> Maybe (LT x y)
  Totality: total
  Visibility: public export
finFromInteger : (x : Integer) -> {auto 0 _ : So (fromInteger x < n)} -> Fin n
  Totality: total
  Visibility: public export
integerLessThanNat : Integer -> Nat -> Bool
  Totality: total
  Visibility: public export
fromInteger : (x : Integer) -> {auto 0 _ : So (integerLessThanNat x n)} -> Fin n
  Allow overloading of Integer literals for Fin.
  @ x the Integer that the user typed
  @ prf an automatically-constructed proof that `x` is in bounds

  Totality: total
  Visibility: public export
restrict : (n : Nat) -> Integer -> Fin (S n)
  Convert an Integer to a Fin in the required bounds/
  This is essentially a composition of `mod` and `fromInteger`

  Totality: total
  Visibility: public export
data Pointwise : Fin m -> Fin n -> Type
  Pointwise equality of Fins
  It is sometimes complicated to prove equalities on type-changing
  operations on Fins.
  This inductive definition can be used to simplify proof. We can
  recover proofs of equalities by using `homoPointwiseIsEqual`.

  Totality: total
  Visibility: public export
  Constructors:
  
FZ : Pointwise FZ FZ
  
FS : Pointwise k l -> Pointwise (FS k) (FS l)
(~~~) : Fin m -> Fin n -> Type
  Convenient infix notation for the notion of pointwise equality of Fins

  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
reflexive : k ~~~ k
  Pointwise equality is reflexive

  Totality: total
  Visibility: export
symmetric : k ~~~ l -> l ~~~ k
  Pointwise equality is symmetric

  Totality: total
  Visibility: export
transitive : j ~~~ k -> k ~~~ l -> j ~~~ l
  Pointwise equality is transitive

  Totality: total
  Visibility: export
coerceEq : (0 eq : m = n) -> coerce eq k ~~~ k
  Pointwise equality is compatible with coerce

  Totality: total
  Visibility: export
congCoerce : k ~~~ l -> coerce eq1 k ~~~ coerce eq2 l
  The actual proof used by coerce is irrelevant

  Totality: total
  Visibility: export
congLast : (0 _ : m = n) -> last ~~~ last
  Last is congruent wrt index equality

  Totality: total
  Visibility: export
congShift : (m : Nat) -> k ~~~ l -> shift m k ~~~ shift m l
  Totality: total
  Visibility: export
congWeakenN : k ~~~ l -> weakenN n k ~~~ weakenN n l
  WeakenN is congruent wrt pointwise equality

  Totality: total
  Visibility: export
homoPointwiseIsEqual : k ~~~ l -> k = l
  Pointwise equality is propositional equality on Fins that have the same type

  Totality: total
  Visibility: export
hetPointwiseIsTransport : (0 eq : m = n) -> k ~~~ l -> k = rewrite__impl {_:5275} {_:5274} l
  Pointwise equality is propositional equality modulo transport on Fins that
  have provably equal types

  Totality: total
  Visibility: export
finToNatQuotient : k ~~~ l -> finToNat k = finToNat l
  Totality: total
  Visibility: export
finToNatEqualityAsPointwise : (k : Fin m) -> (l : Fin n) -> finToNat k = finToNat l -> k ~~~ l
  Propositional equality on `finToNat`s implies pointwise equality on the `Fin`s themselves

  Totality: total
  Visibility: export
weakenNeutral : (k : Fin n) -> weaken k ~~~ k
  Totality: total
  Visibility: export
weakenNNeutral : (0 m : Nat) -> (k : Fin n) -> weakenN m k ~~~ k
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Fin(source)
Reexports
import public Control.Ord
import public Data.Maybe
import public Data.Nat
import public Data.So
Definitions
data Fin : Nat -> Type
  Numbers strictly less than some bound.  The name comes from "finite sets".
  
  It's probably not a good idea to use `Fin` for arithmetic, and they will be
  exceedingly inefficient at run time.
  @ n the upper bound

  Totality: total
  Visibility: public export
  Constructors:
  
FZ : Fin (S k)
  
FS : Fin k -> Fin (S k)

  Hints:
  
Cast (Fin n) Nat
  
Cast (Fin n) Integer
  
DecEq (Fin n)
  
Eq (Fin n)
  
Injective FS
  
Injective finToNat
  
Neg (Fin (S n))
  
Num (Fin (S n))
  
Ord (Fin n)
  
Show (Fin n)
  
Uninhabited (Fin 0)
  
Uninhabited (FZ = FS k)
  
Uninhabited (FS k = FZ)
  
Uninhabited (n = m) => Uninhabited (FS n = FS m)
  
Uninhabited (FS k ~~~ FZ)
  
Uninhabited (FZ ~~~ FS k)
coerce : (0 _ : m = n) -> Fin m -> Fin n
  Coerce between Fins with equal indices

  Totality: total
  Visibility: public export
finToNat : Fin n -> Nat
  Convert a Fin to a Nat

  Totality: total
  Visibility: public export
finToInteger : Fin n -> Integer
  Convert a Fin to an Integer

  Totality: total
  Visibility: public export
weaken : Fin n -> Fin (S n)
  Weaken the bound on a Fin by 1

  Totality: total
  Visibility: public export
weakenN : (0 n : Nat) -> Fin m -> Fin (m + n)
  Weaken the bound on a Fin by some amount

  Totality: total
  Visibility: public export
weakenLTE : Fin n -> LTE n m -> Fin m
  Weaken the bound on a Fin using a constructive comparison

  Totality: total
  Visibility: public export
strengthen : Fin (S n) -> Maybe (Fin n)
  Attempt to tighten the bound on a Fin.
  Return the tightened bound if there is one, else nothing.

  Totality: total
  Visibility: export
shift : (m : Nat) -> Fin n -> Fin (m + n)
  Add some natural number to a Fin, extending the bound accordingly
  @ n the previous bound
  @ m the number to increase the Fin by

  Totality: total
  Visibility: public export
finS : Fin n -> Fin n
  Increment a Fin, wrapping on overflow

  Totality: total
  Visibility: public export
last : Fin (S n)
  The largest element of some Fin type

  Totality: total
  Visibility: public export
complement : Fin n -> Fin n
  The finite complement of some Fin.
  The number as far along as the input, but starting from the other end.

  Totality: total
  Visibility: public export
allFins : (n : Nat) -> List (Fin n)
  All of the Fin elements

  Totality: total
  Visibility: public export
allFins : (n : Nat) -> List1 (Fin (S n))
  All of the Fin elements

  Totality: total
  Visibility: public export
natToFinLT : (x : Nat) -> {auto 0 _ : LT x n} -> Fin n
  Totality: total
  Visibility: public export
natToFinLt : (x : Nat) -> {auto 0 _ : So (x < n)} -> Fin n
  Totality: total
  Visibility: public export
natToFin : Nat -> (n : Nat) -> Maybe (Fin n)
  Totality: total
  Visibility: public export
integerToFin : Integer -> (n : Nat) -> Maybe (Fin n)
  Convert an `Integer` to a `Fin`, provided the integer is within bounds.
  @n The upper bound of the Fin

  Totality: total
  Visibility: public export
maybeLTE : (x : Nat) -> (y : Nat) -> Maybe (LTE x y)
  Totality: total
  Visibility: public export
maybeLT : (x : Nat) -> (y : Nat) -> Maybe (LT x y)
  Totality: total
  Visibility: public export
finFromInteger : (x : Integer) -> {auto 0 _ : So (fromInteger x < n)} -> Fin n
  Totality: total
  Visibility: public export
integerLessThanNat : Integer -> Nat -> Bool
  Totality: total
  Visibility: public export
fromInteger : (x : Integer) -> {auto 0 _ : So (integerLessThanNat x n)} -> Fin n
  Allow overloading of Integer literals for Fin.
  @ x the Integer that the user typed
  @ prf an automatically-constructed proof that `x` is in bounds

  Totality: total
  Visibility: public export
restrict : (n : Nat) -> Integer -> Fin (S n)
  Convert an Integer to a Fin in the required bounds/
  This is essentially a composition of `mod` and `fromInteger`

  Totality: total
  Visibility: public export
data Pointwise : Fin m -> Fin n -> Type
  Pointwise equality of Fins
  It is sometimes complicated to prove equalities on type-changing
  operations on Fins.
  This inductive definition can be used to simplify proof. We can
  recover proofs of equalities by using `homoPointwiseIsEqual`.

  Totality: total
  Visibility: public export
  Constructors:
  
FZ : Pointwise FZ FZ
  
FS : Pointwise k l -> Pointwise (FS k) (FS l)
(~~~) : Fin m -> Fin n -> Type
  Convenient infix notation for the notion of pointwise equality of Fins

  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
reflexive : k ~~~ k
  Pointwise equality is reflexive

  Totality: total
  Visibility: export
symmetric : k ~~~ l -> l ~~~ k
  Pointwise equality is symmetric

  Totality: total
  Visibility: export
transitive : j ~~~ k -> k ~~~ l -> j ~~~ l
  Pointwise equality is transitive

  Totality: total
  Visibility: export
coerceEq : (0 eq : m = n) -> coerce eq k ~~~ k
  Pointwise equality is compatible with coerce

  Totality: total
  Visibility: export
congCoerce : k ~~~ l -> coerce eq1 k ~~~ coerce eq2 l
  The actual proof used by coerce is irrelevant

  Totality: total
  Visibility: export
congLast : (0 _ : m = n) -> last ~~~ last
  Last is congruent wrt index equality

  Totality: total
  Visibility: export
congShift : (m : Nat) -> k ~~~ l -> shift m k ~~~ shift m l
  Totality: total
  Visibility: export
congWeakenN : k ~~~ l -> weakenN n k ~~~ weakenN n l
  WeakenN is congruent wrt pointwise equality

  Totality: total
  Visibility: export
homoPointwiseIsEqual : k ~~~ l -> k = l
  Pointwise equality is propositional equality on Fins that have the same type

  Totality: total
  Visibility: export
hetPointwiseIsTransport : (0 eq : m = n) -> k ~~~ l -> k = rewrite__impl {_:5275} {_:5274} l
  Pointwise equality is propositional equality modulo transport on Fins that
  have provably equal types

  Totality: total
  Visibility: export
finToNatQuotient : k ~~~ l -> finToNat k = finToNat l
  Totality: total
  Visibility: export
finToNatEqualityAsPointwise : (k : Fin m) -> (l : Fin n) -> finToNat k = finToNat l -> k ~~~ l
  Propositional equality on `finToNat`s implies pointwise equality on the `Fin`s themselves

  Totality: total
  Visibility: export
weakenNeutral : (k : Fin n) -> weaken k ~~~ k
  Totality: total
  Visibility: export
weakenNNeutral : (0 m : Nat) -> (k : Fin n) -> weakenN m k ~~~ k
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.Fuel.html b/base/docs/Data.Fuel.html
index aa49169cbe..6878fc9d1b 100644
--- a/base/docs/Data.Fuel.html
+++ b/base/docs/Data.Fuel.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Fuel(source)
Definitions
data Fuel : Type
  Fuel for running total operations potentially indefinitely.

  Totality: total
  Visibility: public export
  Constructors:
  
Dry : Fuel
  
More : Lazy Fuel -> Fuel
limit : Nat -> Fuel
  Provide `n` units of fuel.

  Totality: total
  Visibility: public export
forever : Fuel
  Provide fuel indefinitely.
  This function is fundamentally partial.

  Visibility: export

\ No newline at end of file
+
Data.Fuel(source)
Definitions
data Fuel : Type
  Fuel for running total operations potentially indefinitely.

  Totality: total
  Visibility: public export
  Constructors:
  
Dry : Fuel
  
More : Lazy Fuel -> Fuel
limit : Nat -> Fuel
  Provide `n` units of fuel.

  Totality: total
  Visibility: public export
forever : Fuel
  Provide fuel indefinitely.
  This function is fundamentally partial.

  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.Fun.html b/base/docs/Data.Fun.html
index a43c31b1cb..3c5207dc30 100644
--- a/base/docs/Data.Fun.html
+++ b/base/docs/Data.Fun.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Fun(source)
Reexports
import public Data.Vect
Definitions
Fun : Vect n Type -> Type -> Type
  Build an n-ary function type from a Vect of Types and a result type

  Totality: total
  Visibility: public export
chain : Fun [r] r' -> Fun ts r -> Fun ts r'
  Totality: total
  Visibility: public export
target : Fun ts r -> Type
  Returns the co-domain of a n-ary function.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Fun(source)
Reexports
import public Data.Vect
Definitions
Fun : Vect n Type -> Type -> Type
  Build an n-ary function type from a Vect of Types and a result type

  Totality: total
  Visibility: public export
chain : Fun [r] r' -> Fun ts r -> Fun ts r'
  Totality: total
  Visibility: public export
target : Fun ts r -> Type
  Returns the co-domain of a n-ary function.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.IOArray.Prims.html b/base/docs/Data.IOArray.Prims.html
index 11888d00ec..5d4e753e31 100644
--- a/base/docs/Data.IOArray.Prims.html
+++ b/base/docs/Data.IOArray.Prims.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.IOArray.Prims(source)
Definitions
data ArrayData : Type -> Type
  Totality: total
  Visibility: export
prim__newArray : Int -> a -> PrimIO (ArrayData a)
prim__arrayGet : ArrayData a -> Int -> PrimIO a
prim__arraySet : ArrayData a -> Int -> a -> PrimIO ()

\ No newline at end of file
+
Data.IOArray.Prims(source)
Definitions
data ArrayData : Type -> Type
  Totality: total
  Visibility: export
prim__newArray : Int -> a -> PrimIO (ArrayData a)
prim__arrayGet : ArrayData a -> Int -> PrimIO a
prim__arraySet : ArrayData a -> Int -> a -> PrimIO ()

\ No newline at end of file
diff --git a/base/docs/Data.IOArray.html b/base/docs/Data.IOArray.html
index 1c70a5a89d..a7098b73d7 100644
--- a/base/docs/Data.IOArray.html
+++ b/base/docs/Data.IOArray.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.IOArray(source)
Definitions
record IOArray : Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkIOArray : Int -> ArrayData (Maybe elem) -> IOArray elem

  Projections:
  
.content : IOArray elem -> ArrayData (Maybe elem)
  
.maxSize : IOArray elem -> Int
max : IOArray elem -> Int
  Totality: total
  Visibility: export
newArray : HasIO io => Int -> io (IOArray elem)
  Totality: total
  Visibility: export
writeArray : HasIO io => IOArray elem -> Int -> elem -> io Bool
  Totality: total
  Visibility: export
readArray : HasIO io => IOArray elem -> Int -> io (Maybe elem)
  Totality: total
  Visibility: export
newArrayCopy : HasIO io => Int -> IOArray elem -> io (IOArray elem)
  Totality: total
  Visibility: export
toList : HasIO io => IOArray elem -> io (List (Maybe elem))
  Totality: total
  Visibility: export
fromList : HasIO io => List (Maybe elem) -> io (IOArray elem)
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.IOArray(source)
Definitions
record IOArray : Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkIOArray : Int -> ArrayData (Maybe elem) -> IOArray elem

  Projections:
  
.content : IOArray elem -> ArrayData (Maybe elem)
  
.maxSize : IOArray elem -> Int
max : IOArray elem -> Int
  Totality: total
  Visibility: export
newArray : HasIO io => Int -> io (IOArray elem)
  Totality: total
  Visibility: export
writeArray : HasIO io => IOArray elem -> Int -> elem -> io Bool
  Totality: total
  Visibility: export
readArray : HasIO io => IOArray elem -> Int -> io (Maybe elem)
  Totality: total
  Visibility: export
newArrayCopy : HasIO io => Int -> IOArray elem -> io (IOArray elem)
  Totality: total
  Visibility: export
toList : HasIO io => IOArray elem -> io (List (Maybe elem))
  Totality: total
  Visibility: export
fromList : HasIO io => List (Maybe elem) -> io (IOArray elem)
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.IORef.html b/base/docs/Data.IORef.html
index fd5c3ddabe..009dc0b6b6 100644
--- a/base/docs/Data.IORef.html
+++ b/base/docs/Data.IORef.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.IORef(source)
Definitions
data IORef : Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkRef : Mut a -> IORef a
newIORef : HasIO io => a -> io (IORef a)
  Totality: total
  Visibility: export
readIORef : HasIO io => IORef a -> io a
  Totality: total
  Visibility: export
writeIORef : HasIO io => IORef a -> a -> io ()
  Totality: total
  Visibility: export
writeIORef1 : HasLinearIO io => IORef a -> (1 _ : a) -> io ()
  Totality: total
  Visibility: export
modifyIORef : HasIO io => IORef a -> (a -> a) -> io ()
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.IORef(source)
Definitions
data IORef : Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkRef : Mut a -> IORef a
newIORef : HasIO io => a -> io (IORef a)
  Totality: total
  Visibility: export
readIORef : HasIO io => IORef a -> io a
  Totality: total
  Visibility: export
writeIORef : HasIO io => IORef a -> a -> io ()
  Totality: total
  Visibility: export
writeIORef1 : HasLinearIO io => IORef a -> (1 _ : a) -> io ()
  Totality: total
  Visibility: export
modifyIORef : HasIO io => IORef a -> (a -> a) -> io ()
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.Integral.html b/base/docs/Data.Integral.html
index ae711d1d87..95b32f02b9 100644
--- a/base/docs/Data.Integral.html
+++ b/base/docs/Data.Integral.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Integral(source)
Definitions
even : Integral n => Eq n => n -> Bool
  Visibility: export
odd : Integral n => Eq n => n -> Bool
  Visibility: export

\ No newline at end of file
+
Data.Integral(source)
Definitions
even : Integral n => Eq n => n -> Bool
  Visibility: export
odd : Integral n => Eq n => n -> Bool
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.List.Elem.html b/base/docs/Data.List.Elem.html
index e8df461664..22a5f3e77a 100644
--- a/base/docs/Data.List.Elem.html
+++ b/base/docs/Data.List.Elem.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List.Elem(source)
Definitions
data Elem : a -> List a -> Type
  A proof that some element is found in a list.

  Totality: total
  Visibility: public export
  Constructors:
  
Here : Elem x (x :: xs)
  A proof that the element is at the head of the list
  
There : Elem x xs -> Elem x (y :: xs)
  A proof that the element is in the tail of the list

  Hints:
  
DecEq (Elem x xs)
  
Injective There
  
Uninhabited (Here = There e)
  
Uninhabited (There e = Here)
  
Uninhabited (Elem x [])
  
Uninhabited (x = z) => Uninhabited (Elem z xs) => Uninhabited (Elem z (x :: xs))
neitherHereNorThere : Not (x = y) -> Not (Elem x xs) -> Not (Elem x (y :: xs))
  An item not in the head and not in the tail is not in the list at all.

  Totality: total
  Visibility: export
isElem : DecEq a => (x : a) -> (xs : List a) -> Dec (Elem x xs)
  Check whether the given element is a member of the given list.

  Totality: total
  Visibility: public export
get : (xs : List a) -> Elem x xs -> a
  Get the element at the given position.

  Totality: total
  Visibility: public export
lookup : (xs : List a) -> Elem x xs -> Singleton x
  Get the element at the given position, with proof that it is the desired element.

  Totality: total
  Visibility: public export
dropElem : (xs : List a) -> Elem x xs -> List a
  Remove the element at the given position.

  Totality: total
  Visibility: public export
elemToNat : Elem x xs -> Nat
  Erase the indices, returning the numeric position of the element

  Totality: total
  Visibility: public export
indexElem : Nat -> (xs : List a) -> Maybe (x : a ** Elem x xs)
  Find the element with a proof at a given position, if it is valid

  Totality: total
  Visibility: public export
elemMap : (0 f : (a -> b)) -> Elem x xs -> Elem (f x) (map f xs)
  Lift the membership proof to a mapped list

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.List.Elem(source)
Definitions
data Elem : a -> List a -> Type
  A proof that some element is found in a list.

  Totality: total
  Visibility: public export
  Constructors:
  
Here : Elem x (x :: xs)
  A proof that the element is at the head of the list
  
There : Elem x xs -> Elem x (y :: xs)
  A proof that the element is in the tail of the list

  Hints:
  
DecEq (Elem x xs)
  
Injective There
  
Uninhabited (Here = There e)
  
Uninhabited (There e = Here)
  
Uninhabited (Elem x [])
  
Uninhabited (x = z) => Uninhabited (Elem z xs) => Uninhabited (Elem z (x :: xs))
neitherHereNorThere : Not (x = y) -> Not (Elem x xs) -> Not (Elem x (y :: xs))
  An item not in the head and not in the tail is not in the list at all.

  Totality: total
  Visibility: export
isElem : DecEq a => (x : a) -> (xs : List a) -> Dec (Elem x xs)
  Check whether the given element is a member of the given list.

  Totality: total
  Visibility: public export
get : (xs : List a) -> Elem x xs -> a
  Get the element at the given position.

  Totality: total
  Visibility: public export
lookup : (xs : List a) -> Elem x xs -> Singleton x
  Get the element at the given position, with proof that it is the desired element.

  Totality: total
  Visibility: public export
dropElem : (xs : List a) -> Elem x xs -> List a
  Remove the element at the given position.

  Totality: total
  Visibility: public export
elemToNat : Elem x xs -> Nat
  Erase the indices, returning the numeric position of the element

  Totality: total
  Visibility: public export
indexElem : Nat -> (xs : List a) -> Maybe (x : a ** Elem x xs)
  Find the element with a proof at a given position, if it is valid

  Totality: total
  Visibility: public export
elemMap : (0 f : (a -> b)) -> Elem x xs -> Elem (f x) (map f xs)
  Lift the membership proof to a mapped list

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.List.HasLength.html b/base/docs/Data.List.HasLength.html
index 409dacb5c8..672495686d 100644
--- a/base/docs/Data.List.HasLength.html
+++ b/base/docs/Data.List.HasLength.html
@@ -81,4 +81,4 @@
 
 See `sucR` for an example where the update to the runtime-relevant Nat is O(1)
 but the udpate to the list (were we to keep it around) an O(n) traversal.
-
Definitions
data HasLength : Nat -> List a -> Type
  Ensure that the list's length is the provided natural number

  Totality: total
  Visibility: public export
  Constructors:
  
Z : HasLength 0 []
  
S : HasLength n xs -> HasLength (S n) (x :: xs)
hasLength : (xs : List a) -> HasLength (length xs) xs
  This specification corresponds to the length function

  Totality: total
  Visibility: export
take : (n : Nat) -> (xs : Stream a) -> HasLength n (take n xs)
  Totality: total
  Visibility: export
hasLengthUnique : HasLength m xs -> HasLength n xs -> m = n
  The length is unique

  Totality: total
  Visibility: export
hasLengthAppend : HasLength m xs -> HasLength n ys -> HasLength (m + n) (xs ++ ys)
  Totality: total
  Visibility: export
hasLengthReverse : HasLength m acc -> HasLength m (reverse acc)
  Totality: total
  Visibility: export
map : (f : (a -> b)) -> HasLength n xs -> HasLength n (map f xs)
  Totality: total
  Visibility: export
sucR : HasLength n xs -> HasLength (S n) (snoc xs x)
  @sucR demonstrates that snoc only increases the lenght by one
  So performing this operation while carrying the list around would cost O(n)
  but relying on n together with an erased HasLength proof instead is O(1)

  Totality: total
  Visibility: export
data View : (xs : List a) -> Subset Nat (flip HasLength xs) -> Type
  We provide this view as a convenient way to perform nested pattern-matching
  on values of type `Subset Nat (flip HasLength xs)`. Functions using this view will
  be seen as terminating as long as the index list `xs` is left untouched.
  See e.g. listTerminating below for such a function.

  Totality: total
  Visibility: public export
  Constructors:
  
Z : View [] (Element 0 Z)
  
S : (p : Subset Nat (flip HasLength xs)) -> View (x :: xs) (Element (S (fst p)) (S (snd p)))
view : (p : Subset Nat (flip HasLength xs)) -> View xs p
  Proof that the view covers all possible cases.

  Totality: total
  Visibility: export
data View : (xs : List a) -> (n : Nat) -> HasLength n xs -> Type
  We provide this view as a convenient way to perform nested pattern-matching
  on pairs of values of type `n : Nat` and `HasLength xs n`. If transformations
  to the list between recursive calls (e.g. mapping over the list) that prevent
  it from being a valid termination metric, it is best to take the Nat argument
  separately from the HasLength proof and the Subset view is not as useful anymore.
  See e.g. natTerminating below for (a contrived example of) such a function.

  Totality: total
  Visibility: public export
  Constructors:
  
Z : View [] 0 Z
  
S : (n : Nat) -> (0 p : HasLength n xs) -> View (x :: xs) (S n) (S p)
view : (n : Nat) -> (0 p : HasLength n xs) -> View xs n p
  Proof that the view covers all possible cases.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
data HasLength : Nat -> List a -> Type
  Ensure that the list's length is the provided natural number

  Totality: total
  Visibility: public export
  Constructors:
  
Z : HasLength 0 []
  
S : HasLength n xs -> HasLength (S n) (x :: xs)
hasLength : (xs : List a) -> HasLength (length xs) xs
  This specification corresponds to the length function

  Totality: total
  Visibility: export
take : (n : Nat) -> (xs : Stream a) -> HasLength n (take n xs)
  Totality: total
  Visibility: export
hasLengthUnique : HasLength m xs -> HasLength n xs -> m = n
  The length is unique

  Totality: total
  Visibility: export
hasLengthAppend : HasLength m xs -> HasLength n ys -> HasLength (m + n) (xs ++ ys)
  Totality: total
  Visibility: export
hasLengthReverse : HasLength m acc -> HasLength m (reverse acc)
  Totality: total
  Visibility: export
map : (f : (a -> b)) -> HasLength n xs -> HasLength n (map f xs)
  Totality: total
  Visibility: export
sucR : HasLength n xs -> HasLength (S n) (snoc xs x)
  @sucR demonstrates that snoc only increases the lenght by one
  So performing this operation while carrying the list around would cost O(n)
  but relying on n together with an erased HasLength proof instead is O(1)

  Totality: total
  Visibility: export
data View : (xs : List a) -> Subset Nat (flip HasLength xs) -> Type
  We provide this view as a convenient way to perform nested pattern-matching
  on values of type `Subset Nat (flip HasLength xs)`. Functions using this view will
  be seen as terminating as long as the index list `xs` is left untouched.
  See e.g. listTerminating below for such a function.

  Totality: total
  Visibility: public export
  Constructors:
  
Z : View [] (Element 0 Z)
  
S : (p : Subset Nat (flip HasLength xs)) -> View (x :: xs) (Element (S (fst p)) (S (snd p)))
view : (p : Subset Nat (flip HasLength xs)) -> View xs p
  Proof that the view covers all possible cases.

  Totality: total
  Visibility: export
data View : (xs : List a) -> (n : Nat) -> HasLength n xs -> Type
  We provide this view as a convenient way to perform nested pattern-matching
  on pairs of values of type `n : Nat` and `HasLength xs n`. If transformations
  to the list between recursive calls (e.g. mapping over the list) that prevent
  it from being a valid termination metric, it is best to take the Nat argument
  separately from the HasLength proof and the Subset view is not as useful anymore.
  See e.g. natTerminating below for (a contrived example of) such a function.

  Totality: total
  Visibility: public export
  Constructors:
  
Z : View [] 0 Z
  
S : (n : Nat) -> (0 p : HasLength n xs) -> View (x :: xs) (S n) (S p)
view : (n : Nat) -> (0 p : HasLength n xs) -> View xs n p
  Proof that the view covers all possible cases.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.List.Lazy.Quantifiers.html b/base/docs/Data.List.Lazy.Quantifiers.html
index a5580c10d0..23a42dc7e4 100644
--- a/base/docs/Data.List.Lazy.Quantifiers.html
+++ b/base/docs/Data.List.Lazy.Quantifiers.html
@@ -62,4 +62,4 @@
 
 
 
Data.List.Lazy.Quantifiers(source)
WIP: same as Data.List.Quantifiers but for lazy lists
-
Definitions
data Any : (a -> Type) -> LazyList a -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Here : p x -> Any p (x :: xs)
  
There : Any p (Force xs) -> Any p (x :: xs)
toExists : Any p xs -> Exists p
  Totality: total
  Visibility: public export
toDPair : Any p xs -> DPair a p
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
data Any : (a -> Type) -> LazyList a -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Here : p x -> Any p (x :: xs)
  
There : Any p (Force xs) -> Any p (x :: xs)
toExists : Any p xs -> Exists p
  Totality: total
  Visibility: public export
toDPair : Any p xs -> DPair a p
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.List.Lazy.html b/base/docs/Data.List.Lazy.html
index 3bbf369fa9..dc807f655b 100644
--- a/base/docs/Data.List.Lazy.html
+++ b/base/docs/Data.List.Lazy.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List.Lazy(source)
Definitions
data LazyList : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : LazyList a
  
(::) : a -> Lazy (LazyList a) -> LazyList a

  Hints:
  
Alternative LazyList
  
Applicative LazyList
  
Eq a => Eq (LazyList a)
  
Foldable LazyList
  
Functor LazyList
  
Monad LazyList
  
Monoid (LazyList a)
  
Ord a => Ord (LazyList a)
  
Semigroup (LazyList a)
  
Show a => Show (LazyList a)
  
Zippable LazyList
foldrLazy : (a -> Lazy acc -> acc) -> Lazy acc -> LazyList a -> acc
  Totality: total
  Visibility: public export
(++) : LazyList a -> Lazy (LazyList a) -> LazyList a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
bindLazy : (a -> LazyList b) -> LazyList a -> LazyList b
  Totality: total
  Visibility: public export
choice : Alternative f => LazyList (f a) -> f a
  Totality: total
  Visibility: public export
choiceMap : Alternative f => (a -> f b) -> LazyList a -> f b
  Totality: total
  Visibility: public export
any : (a -> Bool) -> LazyList a -> Bool
  Totality: total
  Visibility: public export
all : (a -> Bool) -> LazyList a -> Bool
  Totality: total
  Visibility: public export
traverse : Monad f => (a -> f b) -> LazyList a -> f (List b)
  Totality: total
  Visibility: public export
for : Monad f => LazyList a -> (a -> f b) -> f (List b)
  Totality: total
  Visibility: public export
sequence : Monad f => LazyList (f a) -> f (List a)
  Totality: total
  Visibility: public export
traverse_ : Monad m => (a -> m b) -> LazyList a -> m ()
  Totality: total
  Visibility: public export
for_ : Monad m => LazyList a -> (a -> m b) -> m ()
  Totality: total
  Visibility: public export
sequence_ : Monad m => LazyList (m a) -> m ()
  Totality: total
  Visibility: public export
fromList : List a -> LazyList a
  Totality: total
  Visibility: public export
iterate : (a -> Maybe a) -> a -> LazyList a
  Visibility: public export
unfoldr : (b -> Maybe (a, b)) -> b -> LazyList a
  Visibility: public export
iterateN : Nat -> (a -> a) -> a -> LazyList a
  Totality: total
  Visibility: public export
replicate : Nat -> a -> LazyList a
  Totality: total
  Visibility: public export
head' : LazyList a -> Maybe a
  Totality: total
  Visibility: public export
tail' : LazyList a -> Maybe (LazyList a)
  Totality: total
  Visibility: public export
take : Nat -> LazyList a -> LazyList a
  Totality: total
  Visibility: public export
drop : Nat -> LazyList a -> LazyList a
  Totality: total
  Visibility: public export
takeWhile : (a -> Bool) -> LazyList a -> LazyList a
  Totality: total
  Visibility: public export
dropWhile : (a -> Bool) -> LazyList a -> LazyList a
  Totality: total
  Visibility: public export
filter : (a -> Bool) -> LazyList a -> LazyList a
  Totality: total
  Visibility: public export
mapMaybe : (a -> Maybe b) -> LazyList a -> LazyList b
  Totality: total
  Visibility: public export
take : Fuel -> Stream a -> LazyList a
  Totality: total
  Visibility: public export
take : Fuel -> Colist a -> LazyList a
  Totality: total
  Visibility: public export
take : Fuel -> Colist1 a -> LazyList a
  Totality: total
  Visibility: public export
mergeReplicate : a -> LazyList a -> LazyList a
  Totality: total
  Visibility: public export
intersperse : a -> LazyList a -> LazyList a
  Totality: total
  Visibility: public export
intercalate : LazyList a -> LazyList (LazyList a) -> LazyList a
  Totality: total
  Visibility: public export
toColist : LazyList a -> Colist a
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.List.Lazy(source)
Definitions
data LazyList : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : LazyList a
  
(::) : a -> Lazy (LazyList a) -> LazyList a

  Hints:
  
Alternative LazyList
  
Applicative LazyList
  
Eq a => Eq (LazyList a)
  
Foldable LazyList
  
Functor LazyList
  
Monad LazyList
  
Monoid (LazyList a)
  
Ord a => Ord (LazyList a)
  
Semigroup (LazyList a)
  
Show a => Show (LazyList a)
  
Zippable LazyList
foldrLazy : (a -> Lazy acc -> acc) -> Lazy acc -> LazyList a -> acc
  Totality: total
  Visibility: public export
(++) : LazyList a -> Lazy (LazyList a) -> LazyList a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
bindLazy : (a -> LazyList b) -> LazyList a -> LazyList b
  Totality: total
  Visibility: public export
choice : Alternative f => LazyList (f a) -> f a
  Totality: total
  Visibility: public export
choiceMap : Alternative f => (a -> f b) -> LazyList a -> f b
  Totality: total
  Visibility: public export
any : (a -> Bool) -> LazyList a -> Bool
  Totality: total
  Visibility: public export
all : (a -> Bool) -> LazyList a -> Bool
  Totality: total
  Visibility: public export
traverse : Monad f => (a -> f b) -> LazyList a -> f (List b)
  Totality: total
  Visibility: public export
for : Monad f => LazyList a -> (a -> f b) -> f (List b)
  Totality: total
  Visibility: public export
sequence : Monad f => LazyList (f a) -> f (List a)
  Totality: total
  Visibility: public export
traverse_ : Monad m => (a -> m b) -> LazyList a -> m ()
  Totality: total
  Visibility: public export
for_ : Monad m => LazyList a -> (a -> m b) -> m ()
  Totality: total
  Visibility: public export
sequence_ : Monad m => LazyList (m a) -> m ()
  Totality: total
  Visibility: public export
fromList : List a -> LazyList a
  Totality: total
  Visibility: public export
iterate : (a -> Maybe a) -> a -> LazyList a
  Visibility: public export
unfoldr : (b -> Maybe (a, b)) -> b -> LazyList a
  Visibility: public export
iterateN : Nat -> (a -> a) -> a -> LazyList a
  Totality: total
  Visibility: public export
replicate : Nat -> a -> LazyList a
  Totality: total
  Visibility: public export
head' : LazyList a -> Maybe a
  Totality: total
  Visibility: public export
tail' : LazyList a -> Maybe (LazyList a)
  Totality: total
  Visibility: public export
take : Nat -> LazyList a -> LazyList a
  Totality: total
  Visibility: public export
drop : Nat -> LazyList a -> LazyList a
  Totality: total
  Visibility: public export
takeWhile : (a -> Bool) -> LazyList a -> LazyList a
  Totality: total
  Visibility: public export
dropWhile : (a -> Bool) -> LazyList a -> LazyList a
  Totality: total
  Visibility: public export
filter : (a -> Bool) -> LazyList a -> LazyList a
  Totality: total
  Visibility: public export
mapMaybe : (a -> Maybe b) -> LazyList a -> LazyList b
  Totality: total
  Visibility: public export
take : Fuel -> Stream a -> LazyList a
  Totality: total
  Visibility: public export
take : Fuel -> Colist a -> LazyList a
  Totality: total
  Visibility: public export
take : Fuel -> Colist1 a -> LazyList a
  Totality: total
  Visibility: public export
mergeReplicate : a -> LazyList a -> LazyList a
  Totality: total
  Visibility: public export
intersperse : a -> LazyList a -> LazyList a
  Totality: total
  Visibility: public export
intercalate : LazyList a -> LazyList (LazyList a) -> LazyList a
  Totality: total
  Visibility: public export
toColist : LazyList a -> Colist a
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.List.Quantifiers.html b/base/docs/Data.List.Quantifiers.html
index 4b72e9ec76..1859325f85 100644
--- a/base/docs/Data.List.Quantifiers.html
+++ b/base/docs/Data.List.Quantifiers.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List.Quantifiers(source)
Definitions
data Any : (0 _ : (a -> Type)) -> List a -> Type
  A proof that some element of a list satisfies some property
  
  @ p the property to be satisfied

  Totality: total
  Visibility: public export
  Constructors:
  
Here : p x -> Any p (x :: xs)
  A proof that the satisfying element is the first one in the `List`
  
There : Any p xs -> Any p (x :: xs)
  A proof that the satisfying element is in the tail of the `List`

  Hints:
  
Uninhabited (Any p [])
  
Uninhabited (p x) => Uninhabited (Any p xs) => Uninhabited (Any p (x :: xs))
mapProperty : (p x -> q x) -> Any p l -> Any q l
  Modify the property given a pointwise function

  Totality: total
  Visibility: export
any : ((x : a) -> Dec (p x)) -> (xs : List a) -> Dec (Any p xs)
  Given a decision procedure for a property, determine if an element of a
  list satisfies it.
  
  @ p the property to be satisfied
  @ dec the decision procedure
  @ xs the list to examine

  Totality: total
  Visibility: public export
toExists : Any p xs -> Exists p
  Forget the membership proof

  Totality: total
  Visibility: export
data All : (0 _ : (a -> Type)) -> List a -> Type
  A proof that all elements of a list satisfy a property. It is a list of
  proofs, corresponding element-wise to the `List`.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : All p []
  
(::) : p x -> All p xs -> All p (x :: xs)

  Hints:
  
All (Ord . p) xs => All (Eq . p) xs
  
All (Monoid . p) xs => All (Semigroup . p) xs
  
All (Eq . p) xs => Eq (All p xs)
  
All (Monoid . p) xs => Monoid (All p xs)
  
All (Ord . p) xs => Ord (All p xs)
  
All (Semigroup . p) xs => Semigroup (All p xs)
  
All (Show . p) xs => Show (All p xs)
  
Either (Uninhabited (p x)) (Uninhabited (All p xs)) => Uninhabited (All p (x :: xs))
mapProperty : (p x -> q x) -> All p l -> All q l
  Modify the property given a pointwise function

  Totality: total
  Visibility: export
imapProperty : (0 i : (a -> Type)) -> (i x => p x -> q x) -> All i as => All p as -> All q as
  Modify the property given a pointwise interface function

  Totality: total
  Visibility: public export
forget : All (const type) types -> List type
  Forget property source for a homogeneous collection of properties

  Totality: total
  Visibility: public export
all : ((x : a) -> Dec (p x)) -> (xs : List a) -> Dec (All p xs)
  Given a decision procedure for a property, decide whether all elements of
  a list satisfy it.
  
  @ p the property
  @ dec the decision procedure
  @ xs the list to examine

  Totality: total
  Visibility: public export
zipPropertyWith : (p x -> q x -> r x) -> All p xs -> All q xs -> All r xs
  Totality: total
  Visibility: export
HList : List Type -> Type
  A heterogeneous list of arbitrary types

  Totality: total
  Visibility: public export
(++) : All p xs -> All p ys -> All p (xs ++ ys)
  Concatenate lists of proofs.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
splitAt : (xs : List a) -> All p (xs ++ ys) -> (All p xs, All p ys)
  Totality: total
  Visibility: export
take : (xs : List a) -> All p (xs ++ ys) -> All p xs
  Totality: total
  Visibility: export
drop : (xs : List a) -> All p (xs ++ ys) -> All p ys
  Totality: total
  Visibility: export
negAnyAll : Not (Any p xs) -> All (Not . p) xs
  If there does not exist an element that satifies the property, then it is
  the case that all elements do not satisfy it.

  Totality: total
  Visibility: export
anyNegAll : Any (Not . p) xs -> Not (All p xs)
  If there exists an element that doesn't satify the property, then it is
  not the case that all elements satisfy it.

  Totality: total
  Visibility: export
allNegAny : All (Not . p) xs -> Not (Any p xs)
  If none of the elements satisfy the property, then not any single one can.

  Totality: total
  Visibility: export
indexAll : Elem x xs -> All p xs -> p x
  Given a proof of membership for some element, extract the property proof for it

  Totality: total
  Visibility: public export
pushIn : (xs : List a) -> (0 _ : All p xs) -> List (Subset a p)
  Push in the property from the list level with element level

  Totality: total
  Visibility: public export
pullOut : List (Subset a p) -> Subset (List a) (All p)
  Pull the elementwise property out to the list level

  Totality: total
  Visibility: public export
pushInOutInverse : (xs : List a) -> (0 prf : All p xs) -> pullOut (pushIn xs prf) = Element xs prf
  Totality: total
  Visibility: export
pushOutInInverse : (xs : List (Subset a p)) -> uncurry pushIn (pullOut xs) = xs
  Totality: total
  Visibility: export
data Interleaving : List a -> List a -> List a -> Type
  Two lists, `xs` and `ys`, whose elements are interleaved in the list `xys`.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Interleaving [] [] []
  
Left : Interleaving xs ys xys -> Interleaving (x :: xs) ys (x :: xys)
  
Right : Interleaving xs ys xys -> Interleaving xs (y :: ys) (y :: xys)
record Split : (a -> Type) -> List a -> Type
  A record for storing the result of splitting a list `xys` according to some
  property `p`.
  The `prfs` and `contras` are related to the original list (`xys`) via
  `Interleaving`.
  
  @ xys the list which has been split
  @ p   the property used for the split

  Totality: total
  Visibility: public export
  Constructor: 
MkSplit : Interleaving ayes naws xys => All p ayes -> All (Not . p) naws -> Split p xys

  Projections:
  
.ayes : Split p xys -> List a
  
.contras : ({rec:0} : Split p xys) -> All (Not . p) (naws {rec:0})
  A proof that all elements in `naws` do not satisfy the property used for
  the split.
  
.interleaving : ({rec:0} : Split p xys) -> Interleaving (ayes {rec:0}) (naws {rec:0}) xys
  
.naws : Split p xys -> List a
  
.prfs : ({rec:0} : Split p xys) -> All p (ayes {rec:0})
  A proof that all elements in `ayes` satisfies the property used for the
  split.
.naws : Split p xys -> List a
  Totality: total
  Visibility: public export
.ayes : Split p xys -> List a
  Totality: total
  Visibility: public export
naws : Split p xys -> List a
  Totality: total
  Visibility: public export
ayes : Split p xys -> List a
  Totality: total
  Visibility: public export
.interleaving : ({rec:0} : Split p xys) -> Interleaving (ayes {rec:0}) (naws {rec:0}) xys
  Totality: total
  Visibility: public export
interleaving : ({rec:0} : Split p xys) -> Interleaving (ayes {rec:0}) (naws {rec:0}) xys
  Totality: total
  Visibility: public export
.prfs : ({rec:0} : Split p xys) -> All p (ayes {rec:0})
  A proof that all elements in `ayes` satisfies the property used for the
  split.

  Totality: total
  Visibility: public export
prfs : ({rec:0} : Split p xys) -> All p (ayes {rec:0})
  A proof that all elements in `ayes` satisfies the property used for the
  split.

  Totality: total
  Visibility: public export
.contras : ({rec:0} : Split p xys) -> All (Not . p) (naws {rec:0})
  A proof that all elements in `naws` do not satisfy the property used for
  the split.

  Totality: total
  Visibility: public export
contras : ({rec:0} : Split p xys) -> All (Not . p) (naws {rec:0})
  A proof that all elements in `naws` do not satisfy the property used for
  the split.

  Totality: total
  Visibility: public export
splitOnto : ((x : a) -> Dec (p x)) -> (xs : List a) -> Split p acc -> Split p (reverseOnto acc xs)
  Split the list according to the given decidable property, putting the
  resulting proofs and contras in an accumulator.
  
  @ dec a function which returns a decidable property
  @ xs  a list of elements to split
  @ a   the accumulator

  Totality: total
  Visibility: public export
split : ((x : a) -> Dec (p x)) -> (xs : List a) -> Split p (reverse xs)
  Split the list according to the given decidable property, starting with an
  empty accumulator.
  Use `splitOnto` if you want to specify the accumulator.
  
  @ dec a function which returns a decidable property
  @ xs  a list of elements to split
  @ a   the accumulator

  Totality: total
  Visibility: public export
decide : ((x : a) -> Either (p x) (q x)) -> (xs : List a) -> Either (All p xs) (Any q xs)
  If any `a` either satisfies p or q then given a List of as,
  either all values satisfy p
  or at least one of them sastifies q

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.List.Quantifiers(source)
Definitions
data Any : (0 _ : (a -> Type)) -> List a -> Type
  A proof that some element of a list satisfies some property
  
  @ p the property to be satisfied

  Totality: total
  Visibility: public export
  Constructors:
  
Here : p x -> Any p (x :: xs)
  A proof that the satisfying element is the first one in the `List`
  
There : Any p xs -> Any p (x :: xs)
  A proof that the satisfying element is in the tail of the `List`

  Hints:
  
Uninhabited (Any p [])
  
Uninhabited (p x) => Uninhabited (Any p xs) => Uninhabited (Any p (x :: xs))
mapProperty : (p x -> q x) -> Any p l -> Any q l
  Modify the property given a pointwise function

  Totality: total
  Visibility: export
any : ((x : a) -> Dec (p x)) -> (xs : List a) -> Dec (Any p xs)
  Given a decision procedure for a property, determine if an element of a
  list satisfies it.
  
  @ p the property to be satisfied
  @ dec the decision procedure
  @ xs the list to examine

  Totality: total
  Visibility: public export
toExists : Any p xs -> Exists p
  Forget the membership proof

  Totality: total
  Visibility: export
data All : (0 _ : (a -> Type)) -> List a -> Type
  A proof that all elements of a list satisfy a property. It is a list of
  proofs, corresponding element-wise to the `List`.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : All p []
  
(::) : p x -> All p xs -> All p (x :: xs)

  Hints:
  
All (Ord . p) xs => All (Eq . p) xs
  
All (Monoid . p) xs => All (Semigroup . p) xs
  
All (Eq . p) xs => Eq (All p xs)
  
All (Monoid . p) xs => Monoid (All p xs)
  
All (Ord . p) xs => Ord (All p xs)
  
All (Semigroup . p) xs => Semigroup (All p xs)
  
All (Show . p) xs => Show (All p xs)
  
Either (Uninhabited (p x)) (Uninhabited (All p xs)) => Uninhabited (All p (x :: xs))
mapProperty : (p x -> q x) -> All p l -> All q l
  Modify the property given a pointwise function

  Totality: total
  Visibility: export
imapProperty : (0 i : (a -> Type)) -> (i x => p x -> q x) -> All i as => All p as -> All q as
  Modify the property given a pointwise interface function

  Totality: total
  Visibility: public export
forget : All (const type) types -> List type
  Forget property source for a homogeneous collection of properties

  Totality: total
  Visibility: public export
all : ((x : a) -> Dec (p x)) -> (xs : List a) -> Dec (All p xs)
  Given a decision procedure for a property, decide whether all elements of
  a list satisfy it.
  
  @ p the property
  @ dec the decision procedure
  @ xs the list to examine

  Totality: total
  Visibility: public export
zipPropertyWith : (p x -> q x -> r x) -> All p xs -> All q xs -> All r xs
  Totality: total
  Visibility: export
HList : List Type -> Type
  A heterogeneous list of arbitrary types

  Totality: total
  Visibility: public export
(++) : All p xs -> All p ys -> All p (xs ++ ys)
  Concatenate lists of proofs.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
splitAt : (xs : List a) -> All p (xs ++ ys) -> (All p xs, All p ys)
  Totality: total
  Visibility: export
take : (xs : List a) -> All p (xs ++ ys) -> All p xs
  Totality: total
  Visibility: export
drop : (xs : List a) -> All p (xs ++ ys) -> All p ys
  Totality: total
  Visibility: export
negAnyAll : Not (Any p xs) -> All (Not . p) xs
  If there does not exist an element that satifies the property, then it is
  the case that all elements do not satisfy it.

  Totality: total
  Visibility: export
anyNegAll : Any (Not . p) xs -> Not (All p xs)
  If there exists an element that doesn't satify the property, then it is
  not the case that all elements satisfy it.

  Totality: total
  Visibility: export
allNegAny : All (Not . p) xs -> Not (Any p xs)
  If none of the elements satisfy the property, then not any single one can.

  Totality: total
  Visibility: export
indexAll : Elem x xs -> All p xs -> p x
  Given a proof of membership for some element, extract the property proof for it

  Totality: total
  Visibility: public export
pushIn : (xs : List a) -> (0 _ : All p xs) -> List (Subset a p)
  Push in the property from the list level with element level

  Totality: total
  Visibility: public export
pullOut : List (Subset a p) -> Subset (List a) (All p)
  Pull the elementwise property out to the list level

  Totality: total
  Visibility: public export
pushInOutInverse : (xs : List a) -> (0 prf : All p xs) -> pullOut (pushIn xs prf) = Element xs prf
  Totality: total
  Visibility: export
pushOutInInverse : (xs : List (Subset a p)) -> uncurry pushIn (pullOut xs) = xs
  Totality: total
  Visibility: export
data Interleaving : List a -> List a -> List a -> Type
  Two lists, `xs` and `ys`, whose elements are interleaved in the list `xys`.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Interleaving [] [] []
  
Left : Interleaving xs ys xys -> Interleaving (x :: xs) ys (x :: xys)
  
Right : Interleaving xs ys xys -> Interleaving xs (y :: ys) (y :: xys)
record Split : (a -> Type) -> List a -> Type
  A record for storing the result of splitting a list `xys` according to some
  property `p`.
  The `prfs` and `contras` are related to the original list (`xys`) via
  `Interleaving`.
  
  @ xys the list which has been split
  @ p   the property used for the split

  Totality: total
  Visibility: public export
  Constructor: 
MkSplit : Interleaving ayes naws xys => All p ayes -> All (Not . p) naws -> Split p xys

  Projections:
  
.ayes : Split p xys -> List a
  
.contras : ({rec:0} : Split p xys) -> All (Not . p) (naws {rec:0})
  A proof that all elements in `naws` do not satisfy the property used for
  the split.
  
.interleaving : ({rec:0} : Split p xys) -> Interleaving (ayes {rec:0}) (naws {rec:0}) xys
  
.naws : Split p xys -> List a
  
.prfs : ({rec:0} : Split p xys) -> All p (ayes {rec:0})
  A proof that all elements in `ayes` satisfies the property used for the
  split.
.naws : Split p xys -> List a
  Totality: total
  Visibility: public export
.ayes : Split p xys -> List a
  Totality: total
  Visibility: public export
naws : Split p xys -> List a
  Totality: total
  Visibility: public export
ayes : Split p xys -> List a
  Totality: total
  Visibility: public export
.interleaving : ({rec:0} : Split p xys) -> Interleaving (ayes {rec:0}) (naws {rec:0}) xys
  Totality: total
  Visibility: public export
interleaving : ({rec:0} : Split p xys) -> Interleaving (ayes {rec:0}) (naws {rec:0}) xys
  Totality: total
  Visibility: public export
.prfs : ({rec:0} : Split p xys) -> All p (ayes {rec:0})
  A proof that all elements in `ayes` satisfies the property used for the
  split.

  Totality: total
  Visibility: public export
prfs : ({rec:0} : Split p xys) -> All p (ayes {rec:0})
  A proof that all elements in `ayes` satisfies the property used for the
  split.

  Totality: total
  Visibility: public export
.contras : ({rec:0} : Split p xys) -> All (Not . p) (naws {rec:0})
  A proof that all elements in `naws` do not satisfy the property used for
  the split.

  Totality: total
  Visibility: public export
contras : ({rec:0} : Split p xys) -> All (Not . p) (naws {rec:0})
  A proof that all elements in `naws` do not satisfy the property used for
  the split.

  Totality: total
  Visibility: public export
splitOnto : ((x : a) -> Dec (p x)) -> (xs : List a) -> Split p acc -> Split p (reverseOnto acc xs)
  Split the list according to the given decidable property, putting the
  resulting proofs and contras in an accumulator.
  
  @ dec a function which returns a decidable property
  @ xs  a list of elements to split
  @ a   the accumulator

  Totality: total
  Visibility: public export
split : ((x : a) -> Dec (p x)) -> (xs : List a) -> Split p (reverse xs)
  Split the list according to the given decidable property, starting with an
  empty accumulator.
  Use `splitOnto` if you want to specify the accumulator.
  
  @ dec a function which returns a decidable property
  @ xs  a list of elements to split
  @ a   the accumulator

  Totality: total
  Visibility: public export
decide : ((x : a) -> Either (p x) (q x)) -> (xs : List a) -> Either (All p xs) (Any q xs)
  If any `a` either satisfies p or q then given a List of as,
  either all values satisfy p
  or at least one of them sastifies q

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.List.Views.html b/base/docs/Data.List.Views.html
index c459ecb5f5..ac45fbe7b9 100644
--- a/base/docs/Data.List.Views.html
+++ b/base/docs/Data.List.Views.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List.Views(source)
Definitions
data Split : List a -> Type
  View for splitting a list in half, non-recursively

  Totality: total
  Visibility: public export
  Constructors:
  
SplitNil : Split []
  
SplitOne : (x : a) -> Split [x]
  
SplitPair : (x : a) -> (xs : List a) -> (y : a) -> (ys : List a) -> Split (x :: (xs ++ (y :: ys)))
split : (xs : List a) -> Split xs
  Covering function for the `Split` view
  Constructs the view in linear time

  Totality: total
  Visibility: export
data SplitRec : List a -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
SplitRecNil : SplitRec []
  
SplitRecOne : (x : a) -> SplitRec [x]
  
SplitRecPair : (lefts : List a) -> (rights : List a) -> Lazy (SplitRec lefts) -> Lazy (SplitRec rights) -> SplitRec (lefts ++ rights)
splitRec : (xs : List a) -> SplitRec xs
  Covering function for the `SplitRec` view
  Constructs the view in O(n lg n)

  Totality: total
  Visibility: public export
data SnocList : List a -> Type
  View for traversing a list backwards

  Totality: total
  Visibility: public export
  Constructors:
  
Empty : SnocList []
  
Snoc : (x : a) -> (xs : List a) -> SnocList xs -> SnocList (xs ++ [x])
snocList : (xs : List a) -> SnocList xs
  Covering function for the `SnocList` view
  Constructs the view in linear time

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.List.Views(source)
Definitions
data Split : List a -> Type
  View for splitting a list in half, non-recursively

  Totality: total
  Visibility: public export
  Constructors:
  
SplitNil : Split []
  
SplitOne : (x : a) -> Split [x]
  
SplitPair : (x : a) -> (xs : List a) -> (y : a) -> (ys : List a) -> Split (x :: (xs ++ (y :: ys)))
split : (xs : List a) -> Split xs
  Covering function for the `Split` view
  Constructs the view in linear time

  Totality: total
  Visibility: export
data SplitRec : List a -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
SplitRecNil : SplitRec []
  
SplitRecOne : (x : a) -> SplitRec [x]
  
SplitRecPair : (lefts : List a) -> (rights : List a) -> Lazy (SplitRec lefts) -> Lazy (SplitRec rights) -> SplitRec (lefts ++ rights)
splitRec : (xs : List a) -> SplitRec xs
  Covering function for the `SplitRec` view
  Constructs the view in O(n lg n)

  Totality: total
  Visibility: public export
data SnocList : List a -> Type
  View for traversing a list backwards

  Totality: total
  Visibility: public export
  Constructors:
  
Empty : SnocList []
  
Snoc : (x : a) -> (xs : List a) -> SnocList xs -> SnocList (xs ++ [x])
snocList : (xs : List a) -> SnocList xs
  Covering function for the `SnocList` view
  Constructs the view in linear time

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.List.html b/base/docs/Data.List.html
index e43b3b6eff..6f04f5d152 100644
--- a/base/docs/Data.List.html
+++ b/base/docs/Data.List.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List(source)
Reexports
import public Control.Function
import public Data.Zippable
Definitions
isNil : List a -> Bool
  Boolean check for whether the list is the empty list.

  Totality: total
  Visibility: public export
isCons : List a -> Bool
  Boolean check for whether the list contains a cons (::) / is non-empty.

  Totality: total
  Visibility: public export
snoc : List a -> a -> List a
  Add an element to the end of a list.
  O(n). See the `Data.SnocList` module if you need to perform `snoc` often.

  Totality: total
  Visibility: public export
take : Nat -> List a -> List a
  Take `n` first elements from `xs`, returning the whole list if
  `n` >= length `xs`.
  
  @ n  the number of elements to take
  @ xs the list to take the elements from

  Totality: total
  Visibility: public export
drop : Nat -> List a -> List a
  Remove `n` first elements from `xs`, returning the empty list if
  `n >= length xs`
  
  @ n  the number of elements to remove
  @ xs the list to drop the elements from

  Totality: total
  Visibility: public export
data InBounds : Nat -> List a -> Type
  Satisfiable if `k` is a valid index into `xs`.
  
  @ k  the potential index
  @ xs the list into which k may be an index

  Totality: total
  Visibility: public export
  Constructors:
  
InFirst : InBounds 0 (x :: xs)
  Z is a valid index into any cons cell
  
InLater : InBounds k xs -> InBounds (S k) (x :: xs)
  Valid indices can be extended

  Hints:
  
Uninhabited (InBounds k [])
  
Uninhabited (InBounds k xs) => Uninhabited (InBounds (S k) (x :: xs))
inBounds : (k : Nat) -> (xs : List a) -> Dec (InBounds k xs)
  Decide whether `k` is a valid index into `xs`.

  Totality: total
  Visibility: public export
index : (n : Nat) -> (xs : List a) -> {auto 0 _ : InBounds n xs} -> a
  Find a particular element of a list.
  
  @ ok a proof that the index is within bounds

  Totality: total
  Visibility: public export
index' : (xs : List a) -> Fin (length xs) -> a
  Totality: total
  Visibility: public export
iterate : (a -> Maybe a) -> a -> List a
  Generate a list by repeatedly applying a partial function until exhausted.
  @ f the function to iterate
  @ x the initial value that will be the head of the list

  Visibility: public export
unfoldr : (b -> Maybe (a, b)) -> b -> List a
  Given a function `f` which extracts an element of `b` and `b`'s
  continuation, return the list consisting of the extracted elements.
  CAUTION: Only terminates if `f` eventually returns `Nothing`.
  
  @ f  a function which provides an element of `b` and the rest of `b`
  @ b  a structure contanining any number of elements

  Visibility: public export
iterateN : Nat -> (a -> a) -> a -> List a
  Returns the list of elements obtained by applying `f` to `x` `0` to `n-1` times,
  starting with `x`.
  
  @ n  the number of times to iterate `f` over `x`
  @ f  a function producing a series
  @ x  the initial element of the series

  Totality: total
  Visibility: public export
takeWhile : (a -> Bool) -> List a -> List a
  Get the longest prefix of the list that satisfies the predicate.
  
  @ p  a custom predicate for the elements of the list
  @ xs the list of elements

  Totality: total
  Visibility: public export
dropWhile : (a -> Bool) -> List a -> List a
  Remove elements from the list until an element no longer satisfies the
  predicate.
  
  @ p  a custom predicate for the elements of the list
  @ xs the list of elements to remove from

  Totality: total
  Visibility: public export
find : (a -> Bool) -> List a -> Maybe a
  Find the first element of the list that satisfies the predicate.

  Totality: total
  Visibility: public export
findIndex : (a -> Bool) -> (xs : List a) -> Maybe (Fin (length xs))
  Find the index and proof of InBounds of the first element (if exists) of a
  list that satisfies the given test, else `Nothing`.

  Totality: total
  Visibility: public export
findIndices : (a -> Bool) -> List a -> List Nat
  Find indices of all elements that satisfy the given test.

  Totality: total
  Visibility: public export
lookupBy : (a -> b -> Bool) -> a -> List (b, v) -> Maybe v
  Find associated information in a list using a custom comparison.

  Totality: total
  Visibility: public export
lookup : Eq a => a -> List (a, b) -> Maybe b
  Find associated information in a list using Boolean equality.

  Totality: total
  Visibility: public export
nubBy : (a -> a -> Bool) -> List a -> List a
  Remove duplicate elements from a list using a custom comparison. The general
  case of `nub`.
  O(n^2).
  
  @ p  a custom comparison for detecting duplicate elements
  @ xs the list to remove the duplicates from

  Totality: total
  Visibility: public export
nub : Eq a => List a -> List a
  The nub function removes duplicate elements from a list using
  boolean equality. In particular, it keeps only the first occurrence of each
  element. It is a special case of `nubBy`, which allows the programmer to
  supply their own equality test.
  O(n^2).
  
  ```idris example
  nub (the (List _) [1,2,1,3])
  ```

  Totality: total
  Visibility: public export
insertAt : (idx : Nat) -> a -> (xs : List a) -> {auto 0 _ : LTE idx (length xs)} -> List a
  Insert an element at a particular index.
  
  ```idris example
  insertAt 1 [6, 8, 9] 7
  ```
  
  @idx The index of the inserted value in the resulting list.
  @x The value to insert.
  @xs The list to insert the value into.

  Totality: total
  Visibility: public export
deleteAt : (idx : Nat) -> (xs : List a) -> {auto 0 _ : InBounds idx xs} -> List a
  Construct a new list consisting of all but the indicated element.
  
  ```idris example
  deleteAt 3 [5, 6, 7, 8, 9]
  ```
  
  @ idx The index of the value to delete.
  @ xs The list to delete the value from.

  Totality: total
  Visibility: public export
deleteBy : (a -> b -> Bool) -> a -> List b -> List b
  The deleteBy function behaves like delete, but takes a user-supplied equality predicate.

  Totality: total
  Visibility: public export
delete : Eq a => a -> List a -> List a
  `delete x` removes the first occurrence of `x` from its list argument. For
  example,
  
  ````idris example
  delete 'a' ['b', 'a', 'n', 'a', 'n', 'a']
  ````
  
  It is a special case of deleteBy, which allows the programmer to supply
  their own equality test.

  Totality: total
  Visibility: public export
deleteFirstsBy : (a -> b -> Bool) -> List b -> List a -> List b
  Delete the first occurrence of each element from the second list in the first
  list where equality is determined by the predicate passed as the first argument.
  @ p            A function that returns true when its two arguments should be considered equal.
  @ source       The list to delete elements from.
  @ undesirables The list of elements to delete.

  Totality: total
  Visibility: public export
(\\) : Eq a => List a -> List a -> List a
  The non-associative list-difference.
  A specialized form of @deleteFirstsBy@ where the predicate is equality under the @Eq@
  interface.
  Deletes the first occurrence of each element of the second list from the first list.
  
  In the following example, the result is `[2, 4]`.
  ```idris example
  [1, 2, 3, 4] \\ [1, 3]
  ```
  

  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 7
unionBy : (a -> a -> Bool) -> List a -> List a -> List a
  The unionBy function returns the union of two lists by user-supplied equality predicate.

  Totality: total
  Visibility: public export
union : Eq a => List a -> List a -> List a
  Compute the union of two lists according to their `Eq` implementation.
  
  ```idris example
  union ['d', 'o', 'g'] ['c', 'o', 'w']
  ```
  

  Totality: total
  Visibility: public export
spanBy : (a -> Maybe b) -> List a -> (List b, List a)
  Like @span@ but using a predicate that might convert a to b, i.e. given a
  predicate from a to Maybe b and a list of as, returns a tuple consisting of
  the longest prefix of the list where a -> Just b, and the rest of the list.

  Totality: total
  Visibility: public export
span : (a -> Bool) -> List a -> (List a, List a)
  Given a predicate and a list, returns a tuple consisting of the longest
  prefix of the list whose elements satisfy the predicate, and the rest of the
  list.

  Totality: total
  Visibility: public export
break : (a -> Bool) -> List a -> (List a, List a)
  Similar to `span` but negates the predicate, i.e.: returns a tuple
  consisting of the longest prefix of the list whose elements don't satisfy
  the predicate, and the rest of the list.

  Totality: total
  Visibility: public export
singleton : a -> List a
  Totality: total
  Visibility: public export
split : (a -> Bool) -> List a -> List1 (List a)
  Totality: total
  Visibility: public export
splitAt : Nat -> List a -> (List a, List a)
  Split the list `xs` at the index `n`. If `n > length xs`, returns a tuple
  consisting of `xs` and `[]`.
  
  @ n  the index to split the list at
  @ xs the list to split

  Totality: total
  Visibility: public export
partition : (a -> Bool) -> List a -> (List a, List a)
  Divide the list into a tuple containing two smaller lists: one with the
  elements that satisfies the given predicate and another with the elements
  that don't.
  
  @ p  the predicate to partition according to
  @ xs the list to partition

  Totality: total
  Visibility: public export
inits : List a -> List (List a)
  The inits function returns all initial segments of the argument, shortest
  first. For example,
  
  ```idris example
  inits [1,2,3]
  ```

  Totality: total
  Visibility: public export
tails : List a -> List (List a)
  The tails function returns all final segments of the argument, longest
  first. For example,
  
  ```idris example
  tails [1,2,3] == [[1,2,3], [2,3], [3], []]
  ```

  Totality: total
  Visibility: public export
splitOn : Eq a => a -> List a -> List1 (List a)
  Split on the given element.
  
  ```idris example
  splitOn 0 [1,0,2,0,0,3]
  ```
  

  Totality: total
  Visibility: public export
replaceAt : (idx : Nat) -> a -> (xs : List a) -> {auto 0 _ : InBounds idx xs} -> List a
  Replace an element at a particlar index with another.
  
  ```idris example
  replaceAt 2 6 [1, 2, 3, 4]
  ```
  
  @idx The index of the value to replace.
  @x The value to insert.
  @xs The list in which to replace an element.

  Totality: total
  Visibility: public export
replaceWhen : (a -> Bool) -> a -> List a -> List a
  Replace the elements in the list that satisfy the predicate with the given
  value. The general case of `replaceOn`.
  
  @ p  the predicate to replace elements in the list according to
  @ b  the element to replace with
  @ l  the list to perform the replacements on

  Totality: total
  Visibility: public export
replaceOn : Eq a => a -> a -> List a -> List a
  Replace the elements in the list that are equal to `e`, using boolean
  equality, with `b`. A special case of `replaceWhen`, using `== e` as the
  predicate.
  
  ```idris example
  > replaceOn '-' ',' ['1', '-', '2', '-', '3']
  ['1', ',', '2', ',', '3']
  ```
  
  @ e  the element to find and replace
  @ b  the element to replace with
  @ l  the list to perform the replacements on

  Totality: total
  Visibility: public export
replicate : Nat -> a -> List a
  Construct a list with `n` copies of `x`.
  
  @ n how many copies
  @ x the element to replicate

  Totality: total
  Visibility: public export
intersectBy : (a -> a -> Bool) -> List a -> List a -> List a
  Compute the intersect of two lists by user-supplied equality predicate.

  Totality: total
  Visibility: export
intersect : Eq a => List a -> List a -> List a
  Compute the intersection of two lists according to the `Eq` implementation for
  the elements.

  Totality: total
  Visibility: export
intersectAllBy : (a -> a -> Bool) -> List (List a) -> List a
  Compute the intersect of all the lists in the given list of lists, according
  to the user-supplied equality predicate.
  
  @ eq the predicate for computing the intersection
  @ ls the list of lists to compute the intersect of

  Totality: total
  Visibility: export
intersectAll : Eq a => List (List a) -> List a
  Compute the intersect of all the lists in the given list of lists, according
  to boolean equality. A special case of `intersectAllBy`, using `==` as the
  equality predicate.
  
  @ ls the list of lists to compute the intersect of

  Totality: total
  Visibility: export
data NonEmpty : List a -> Type
  Proof that a given list is non-empty.

  Totality: total
  Visibility: public export
  Constructor: 
IsNonEmpty : NonEmpty (x :: xs)

  Hint: 
Uninhabited (NonEmpty [])
head : (l : List a) -> {auto 0 _ : NonEmpty l} -> a
  Get the head of a non-empty list.
  @ ok proof the list is non-empty

  Totality: total
  Visibility: public export
tail : (l : List a) -> {auto 0 _ : NonEmpty l} -> List a
  Get the tail of a non-empty list.
  @ ok proof the list is non-empty

  Totality: total
  Visibility: public export
last : (l : List a) -> {auto 0 _ : NonEmpty l} -> a
  Retrieve the last element of a non-empty list.
  @ ok proof that the list is non-empty

  Totality: total
  Visibility: public export
init : (l : List a) -> {auto 0 _ : NonEmpty l} -> List a
  Return all but the last element of a non-empty list.
  @ ok proof the list is non-empty

  Totality: total
  Visibility: public export
minimum : Ord a => (xs : List a) -> {auto 0 _ : NonEmpty xs} -> a
  Computes the minimum of a non-empty list

  Totality: total
  Visibility: public export
uncons' : List a -> Maybe (a, List a)
  Attempt to deconstruct the list into a head and a tail.

  Totality: total
  Visibility: public export
head' : List a -> Maybe a
  Attempt to get the head of a list. If the list is empty, return `Nothing`.

  Totality: total
  Visibility: public export
tail' : List a -> Maybe (List a)
  Attempt to get the tail of a list. If the list is empty, return `Nothing`.

  Totality: total
  Visibility: export
last' : List a -> Maybe a
  Attempt to retrieve the last element of a non-empty list.
  
  If the list is empty, return `Nothing`.

  Totality: total
  Visibility: export
init' : List a -> Maybe (List a)
  Attempt to return all but the last element of a non-empty list.
  
  If the list is empty, return `Nothing`.

  Totality: total
  Visibility: export
foldr1By : (a -> b -> b) -> (a -> b) -> (l : List a) -> {auto 0 _ : NonEmpty l} -> b
  Foldr a non-empty list, using `map` to transform the first accumulated
  element to something of the desired type and `func` to accumulate the
  elements.
  
  @ func the function used to accumulate the elements
  @ map  an initial transformation from the element to the accumulated type
  @ l    the non-empty list to foldr
  @ ok   proof that the list is non-empty

  Totality: total
  Visibility: public export
foldl1By : (b -> a -> b) -> (a -> b) -> (l : List a) -> {auto 0 _ : NonEmpty l} -> b
  Foldl a non-empty list, using `map` to transform the first accumulated
  element to something of the desired type and `func` to accumulate the
  elements.
  
  @ func the function used to accumulate the elements
  @ map  an initial transformation from the element to the accumulated type
  @ l    the non-empty list to foldl
  @ ok   proof that the list is non-empty

  Totality: total
  Visibility: public export
foldr1 : (a -> a -> a) -> (l : List a) -> {auto 0 _ : NonEmpty l} -> a
  Foldr a non-empty list without seeding the accumulator.
  
  @ ok proof that the list is non-empty

  Totality: total
  Visibility: public export
foldl1 : (a -> a -> a) -> (l : List a) -> {auto 0 _ : NonEmpty l} -> a
  Foldl a non-empty list without seeding the accumulator.
  
  @ ok proof that the list is non-empty

  Totality: total
  Visibility: public export
toList1 : (l : List a) -> {auto 0 _ : NonEmpty l} -> List1 a
  Convert to a non-empty list.
  
  @ ok proof the list is non-empty

  Totality: total
  Visibility: export
toList1' : List a -> Maybe (List1 a)
  Convert to a non-empty list, returning Nothing if the list is empty.

  Totality: total
  Visibility: public export
interleave : List a -> List a -> List a
  Interleave two lists.
  ```idris example
  > interleave ["a", "c", "e"]  ["b", "d", "f"]
  ["a", "b", "c", "d", "e", "f"]
  ```

  Totality: total
  Visibility: public export
mergeReplicate : a -> List a -> List a
  Prefix every element in the list with the given element.
  
  @ sep the value to prefix
  @ xs  the list of elements to prefix with the given element
  
  ```idris example
  > with List (mergeReplicate '>' ['a', 'b', 'c', 'd', 'e'])
  ['>', 'a', '>', 'b', '>', 'c', '>', 'd', '>', 'e']
  ```

  Totality: total
  Visibility: public export
intersperse : a -> List a -> List a
  Insert some separator between the elements of a list.
  
  @ sep the value to intersperse
  @ xs  the list of elements to intersperse with the separator
  
  ```idris example
  > with List (intersperse ',' ['a', 'b', 'c', 'd', 'e'])
  ['a', ',', 'b', ',', 'c', ',', 'd', ',', 'e']
  ```

  Totality: total
  Visibility: public export
intercalate : List a -> List (List a) -> List a
  Given a separator list and some more lists, produce a new list by
  placing the separator between each of the lists.
  
  @ sep the separator
  @ xss the lists between which the separator will be placed
  
  ```idris example
  intercalate [0, 0, 0] [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ]
  ```

  Totality: total
  Visibility: export
catMaybes : List (Maybe a) -> List a
  Extract all of the values contained in a List of Maybes

  Totality: total
  Visibility: public export
sorted : Ord a => List a -> Bool
  Check whether a list is sorted with respect to the default ordering for the type of its elements.

  Totality: total
  Visibility: export
mergeBy : (a -> a -> Ordering) -> List a -> List a -> List a
  Merge two sorted lists using an arbitrary comparison
  predicate. Note that the lists must have been sorted using this
  predicate already.

  Totality: total
  Visibility: export
merge : Ord a => List a -> List a -> List a
  Merge two sorted lists using the default ordering for the type of their elements.

  Totality: total
  Visibility: export
sortBy : (a -> a -> Ordering) -> List a -> List a
  Sort a list using some arbitrary comparison predicate.
  
  @ cmp how to compare elements
  @ xs the list to sort

  Totality: total
  Visibility: export
sort : Ord a => List a -> List a
  Sort a list using the default ordering for the type of its elements.

  Totality: total
  Visibility: export
prefixOfBy : (a -> b -> Maybe m) -> List a -> List b -> Maybe (List m, List b)
  Check whether the `left` list is a prefix of the `right` one, according to
  `match`. Returns the matched prefix together with the leftover suffix.
  
  @ match a custom matching function for checking the elements are convertible
  @ left  the list which might be a prefix of `right`
  @ right the list of elements to compare against

  Totality: total
  Visibility: public export
isPrefixOfBy : (a -> b -> Bool) -> List a -> List b -> Bool
  Check whether the `left` list is a prefix of the `right` one, using the
  provided equality function to compare elements.
  
  @ eq    a custom equality function for comparing the elements
  @ left  the list which might be a prefix of `right`
  @ right the list of elements to compare againts

  Totality: total
  Visibility: public export
isPrefixOf : Eq a => List a -> List a -> Bool
  The isPrefixOf function takes two lists and returns True iff the first list
  is a prefix of the second when comparing elements using `==`.

  Totality: total
  Visibility: public export
suffixOfBy : (a -> b -> Maybe m) -> List a -> List b -> Maybe (List b, List m)
  Check whether the `left` is a suffix of the `right` one, according to
  `match`. Returns the matched suffix together with the leftover prefix.
  
  @ match a custom matching function for checking the elements are convertible
  @ left  the list which might be a prefix of `right`
  @ right the list of elements to compare against

  Totality: total
  Visibility: public export
isSuffixOfBy : (a -> b -> Bool) -> List a -> List b -> Bool
  Check whether the `left` is a suffix of the `right` one, using the provided
  equality function to compare elements.
  
  @ eq    a custom equality function for comparing the elements
  @ left  the list which might be a suffix of `right`
  @ right the list of elements to compare againts

  Totality: total
  Visibility: public export
isSuffixOf : Eq a => List a -> List a -> Bool
  The isSuffixOf function takes two lists and returns True iff the first list
  is a suffix of the second when comparing elements using `==`.

  Totality: total
  Visibility: public export
infixOfBy : (a -> b -> Maybe m) -> List a -> List b -> Maybe (List b, (List m, List b))
  Check whether the `left` list is an infix of the `right` one, according to
  `match`. Returns the shortest unmatched prefix, matched infix and the leftover suffix.

  Totality: total
  Visibility: public export
isInfixOfBy : (a -> b -> Bool) -> List a -> List b -> Bool
  Check whether the `left` is an infix of the `right` one, using the provided
  equality function to compare elements.

  Totality: total
  Visibility: public export
isInfixOf : Eq a => List a -> List a -> Bool
  The isInfixOf function takes two lists and returns True iff the first list
  is contained, wholly and intact, anywhere within the second.
  
  ```idris example
  isInfixOf ['b','c'] ['a', 'b', 'c', 'd']
  ```
  ```idris example
  isInfixOf ['b','d'] ['a', 'b', 'c', 'd']
  ```
  

  Totality: total
  Visibility: public export
transpose : List (List a) -> List (List a)
  Transposes rows and columns of a list of lists.
  
  ```idris example
  with List transpose [[1, 2], [3, 4]]
  ```
  
  This also works for non square scenarios, thus
  involution does not always hold:
  
      transpose [[], [1, 2]] = [[1], [2]]
      transpose (transpose [[], [1, 2]]) = [[1, 2]]

  Totality: total
  Visibility: export
groupBy : (a -> a -> Bool) -> List a -> List (List1 a)
  `groupBy` operates like `group`, but uses the provided equality
  predicate instead of `==`.

  Totality: total
  Visibility: public export
group : Eq a => List a -> List (List1 a)
  The `group` function takes a list of values and returns a list of
  lists such that flattening the resulting list is equal to the
  argument.  Moreover, each list in the resulting list
  contains only equal elements.

  Totality: total
  Visibility: public export
groupWith : Eq b => (a -> b) -> List a -> List (List1 a)
  `groupWith` operates like `group`, but uses the provided projection when
  comparing for equality

  Totality: total
  Visibility: public export
groupAllWith : Ord b => (a -> b) -> List a -> List (List1 a)
  `groupAllWith` operates like `groupWith`, but sorts the list
  first so that each equivalence class has, at most, one list in the
  output

  Totality: total
  Visibility: public export
grouped : (n : Nat) -> {auto 0 _ : IsSucc n} -> List a -> List (List a)
  Partitions a list into fixed sized sublists.
  
  Note: The last list in the result might be shorter than the rest if
        the input cannot evenly be split into groups of the same size.
  
  ```idris example
  grouped 3 [1..10] === [[1,2,3],[4,5,6],[7,8,9],[10]]
  ```

  Totality: total
  Visibility: public export
consInjective : the (List a) (x :: xs) = the (List b) (y :: ys) -> (x = y, xs = ys)
  Heterogeneous injectivity for (::)

  Totality: total
  Visibility: export
reverseInvolutive : (xs : List a) -> reverse (reverse xs) = xs
  List `reverse` applied twice yields the identity function.

  Totality: total
  Visibility: export
appendNilRightNeutral : (l : List a) -> l ++ [] = l
  The empty list is a right identity for append.

  Totality: total
  Visibility: export
appendAssociative : (l : List a) -> (c : List a) -> (r : List a) -> l ++ (c ++ r) = (l ++ c) ++ r
  Appending lists is associative.

  Totality: total
  Visibility: export
revAppend : (vs : List a) -> (ns : List a) -> reverse ns ++ reverse vs = reverse (vs ++ ns)
  `reverse` is distributive

  Totality: total
  Visibility: export
dropFusion : (n : Nat) -> (m : Nat) -> (l : List t) -> drop n (drop m l) = drop (n + m) l
  Dropping `m` elements from `l` and then dropping `n` elements from the
  result, is the same as simply dropping `n+m` elements from `l`

  Totality: total
  Visibility: export
lengthMap : (xs : List a) -> length (map f xs) = length xs
  Mapping a function over a list does not change the length of the list.

  Totality: total
  Visibility: export
lengthReplicate : (n : Nat) -> length (replicate n x) = n
  Proof that replicate produces a list of the requested length.

  Totality: total
  Visibility: export
foldlAppend : (f : (acc -> a -> acc)) -> (init : acc) -> (xs : List a) -> (ys : List a) -> foldl f init (xs ++ ys) = foldl f (foldl f init xs) ys
  Totality: total
  Visibility: export
filterAppend : (f : (a -> Bool)) -> (xs : List a) -> (ys : List a) -> filter f (xs ++ ys) = filter f xs ++ filter f ys
  Totality: total
  Visibility: export
mapMaybeFusion : (g : (b -> Maybe c)) -> (f : (a -> Maybe b)) -> (xs : List a) -> mapMaybe g (mapMaybe f xs) = mapMaybe (f >=> g) xs
  Totality: total
  Visibility: export
mapMaybeAppend : (f : (a -> Maybe b)) -> (xs : List a) -> (ys : List a) -> mapMaybe f (xs ++ ys) = mapMaybe f xs ++ mapMaybe f ys
  Totality: total
  Visibility: export
mapFusion : (g : (b -> c)) -> (f : (a -> b)) -> (xs : List a) -> map g (map f xs) = map (g . f) xs
  Totality: total
  Visibility: export
mapAppend : (f : (a -> b)) -> (xs : List a) -> (ys : List a) -> map f (xs ++ ys) = map f xs ++ map f ys
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.List(source)
Reexports
import public Control.Function
import public Data.Zippable
Definitions
isNil : List a -> Bool
  Boolean check for whether the list is the empty list.

  Totality: total
  Visibility: public export
isCons : List a -> Bool
  Boolean check for whether the list contains a cons (::) / is non-empty.

  Totality: total
  Visibility: public export
snoc : List a -> a -> List a
  Add an element to the end of a list.
  O(n). See the `Data.SnocList` module if you need to perform `snoc` often.

  Totality: total
  Visibility: public export
take : Nat -> List a -> List a
  Take `n` first elements from `xs`, returning the whole list if
  `n` >= length `xs`.
  
  @ n  the number of elements to take
  @ xs the list to take the elements from

  Totality: total
  Visibility: public export
drop : Nat -> List a -> List a
  Remove `n` first elements from `xs`, returning the empty list if
  `n >= length xs`
  
  @ n  the number of elements to remove
  @ xs the list to drop the elements from

  Totality: total
  Visibility: public export
data InBounds : Nat -> List a -> Type
  Satisfiable if `k` is a valid index into `xs`.
  
  @ k  the potential index
  @ xs the list into which k may be an index

  Totality: total
  Visibility: public export
  Constructors:
  
InFirst : InBounds 0 (x :: xs)
  Z is a valid index into any cons cell
  
InLater : InBounds k xs -> InBounds (S k) (x :: xs)
  Valid indices can be extended

  Hints:
  
Uninhabited (InBounds k [])
  
Uninhabited (InBounds k xs) => Uninhabited (InBounds (S k) (x :: xs))
inBounds : (k : Nat) -> (xs : List a) -> Dec (InBounds k xs)
  Decide whether `k` is a valid index into `xs`.

  Totality: total
  Visibility: public export
index : (n : Nat) -> (xs : List a) -> {auto 0 _ : InBounds n xs} -> a
  Find a particular element of a list.
  
  @ ok a proof that the index is within bounds

  Totality: total
  Visibility: public export
index' : (xs : List a) -> Fin (length xs) -> a
  Totality: total
  Visibility: public export
iterate : (a -> Maybe a) -> a -> List a
  Generate a list by repeatedly applying a partial function until exhausted.
  @ f the function to iterate
  @ x the initial value that will be the head of the list

  Visibility: public export
unfoldr : (b -> Maybe (a, b)) -> b -> List a
  Given a function `f` which extracts an element of `b` and `b`'s
  continuation, return the list consisting of the extracted elements.
  CAUTION: Only terminates if `f` eventually returns `Nothing`.
  
  @ f  a function which provides an element of `b` and the rest of `b`
  @ b  a structure contanining any number of elements

  Visibility: public export
iterateN : Nat -> (a -> a) -> a -> List a
  Returns the list of elements obtained by applying `f` to `x` `0` to `n-1` times,
  starting with `x`.
  
  @ n  the number of times to iterate `f` over `x`
  @ f  a function producing a series
  @ x  the initial element of the series

  Totality: total
  Visibility: public export
takeWhile : (a -> Bool) -> List a -> List a
  Get the longest prefix of the list that satisfies the predicate.
  
  @ p  a custom predicate for the elements of the list
  @ xs the list of elements

  Totality: total
  Visibility: public export
dropWhile : (a -> Bool) -> List a -> List a
  Remove elements from the list until an element no longer satisfies the
  predicate.
  
  @ p  a custom predicate for the elements of the list
  @ xs the list of elements to remove from

  Totality: total
  Visibility: public export
find : (a -> Bool) -> List a -> Maybe a
  Find the first element of the list that satisfies the predicate.

  Totality: total
  Visibility: public export
findIndex : (a -> Bool) -> (xs : List a) -> Maybe (Fin (length xs))
  Find the index and proof of InBounds of the first element (if exists) of a
  list that satisfies the given test, else `Nothing`.

  Totality: total
  Visibility: public export
findIndices : (a -> Bool) -> List a -> List Nat
  Find indices of all elements that satisfy the given test.

  Totality: total
  Visibility: public export
lookupBy : (a -> b -> Bool) -> a -> List (b, v) -> Maybe v
  Find associated information in a list using a custom comparison.

  Totality: total
  Visibility: public export
lookup : Eq a => a -> List (a, b) -> Maybe b
  Find associated information in a list using Boolean equality.

  Totality: total
  Visibility: public export
nubBy : (a -> a -> Bool) -> List a -> List a
  Remove duplicate elements from a list using a custom comparison. The general
  case of `nub`.
  O(n^2).
  
  @ p  a custom comparison for detecting duplicate elements
  @ xs the list to remove the duplicates from

  Totality: total
  Visibility: public export
nub : Eq a => List a -> List a
  The nub function removes duplicate elements from a list using
  boolean equality. In particular, it keeps only the first occurrence of each
  element. It is a special case of `nubBy`, which allows the programmer to
  supply their own equality test.
  O(n^2).
  
  ```idris example
  nub (the (List _) [1,2,1,3])
  ```

  Totality: total
  Visibility: public export
insertAt : (idx : Nat) -> a -> (xs : List a) -> {auto 0 _ : LTE idx (length xs)} -> List a
  Insert an element at a particular index.
  
  ```idris example
  insertAt 1 [6, 8, 9] 7
  ```
  
  @idx The index of the inserted value in the resulting list.
  @x The value to insert.
  @xs The list to insert the value into.

  Totality: total
  Visibility: public export
deleteAt : (idx : Nat) -> (xs : List a) -> {auto 0 _ : InBounds idx xs} -> List a
  Construct a new list consisting of all but the indicated element.
  
  ```idris example
  deleteAt 3 [5, 6, 7, 8, 9]
  ```
  
  @ idx The index of the value to delete.
  @ xs The list to delete the value from.

  Totality: total
  Visibility: public export
deleteBy : (a -> b -> Bool) -> a -> List b -> List b
  The deleteBy function behaves like delete, but takes a user-supplied equality predicate.

  Totality: total
  Visibility: public export
delete : Eq a => a -> List a -> List a
  `delete x` removes the first occurrence of `x` from its list argument. For
  example,
  
  ````idris example
  delete 'a' ['b', 'a', 'n', 'a', 'n', 'a']
  ````
  
  It is a special case of deleteBy, which allows the programmer to supply
  their own equality test.

  Totality: total
  Visibility: public export
deleteFirstsBy : (a -> b -> Bool) -> List b -> List a -> List b
  Delete the first occurrence of each element from the second list in the first
  list where equality is determined by the predicate passed as the first argument.
  @ p            A function that returns true when its two arguments should be considered equal.
  @ source       The list to delete elements from.
  @ undesirables The list of elements to delete.

  Totality: total
  Visibility: public export
(\\) : Eq a => List a -> List a -> List a
  The non-associative list-difference.
  A specialized form of @deleteFirstsBy@ where the predicate is equality under the @Eq@
  interface.
  Deletes the first occurrence of each element of the second list from the first list.
  
  In the following example, the result is `[2, 4]`.
  ```idris example
  [1, 2, 3, 4] \\ [1, 3]
  ```
  

  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 7
unionBy : (a -> a -> Bool) -> List a -> List a -> List a
  The unionBy function returns the union of two lists by user-supplied equality predicate.

  Totality: total
  Visibility: public export
union : Eq a => List a -> List a -> List a
  Compute the union of two lists according to their `Eq` implementation.
  
  ```idris example
  union ['d', 'o', 'g'] ['c', 'o', 'w']
  ```
  

  Totality: total
  Visibility: public export
spanBy : (a -> Maybe b) -> List a -> (List b, List a)
  Like @span@ but using a predicate that might convert a to b, i.e. given a
  predicate from a to Maybe b and a list of as, returns a tuple consisting of
  the longest prefix of the list where a -> Just b, and the rest of the list.

  Totality: total
  Visibility: public export
span : (a -> Bool) -> List a -> (List a, List a)
  Given a predicate and a list, returns a tuple consisting of the longest
  prefix of the list whose elements satisfy the predicate, and the rest of the
  list.

  Totality: total
  Visibility: public export
break : (a -> Bool) -> List a -> (List a, List a)
  Similar to `span` but negates the predicate, i.e.: returns a tuple
  consisting of the longest prefix of the list whose elements don't satisfy
  the predicate, and the rest of the list.

  Totality: total
  Visibility: public export
singleton : a -> List a
  Totality: total
  Visibility: public export
split : (a -> Bool) -> List a -> List1 (List a)
  Totality: total
  Visibility: public export
splitAt : Nat -> List a -> (List a, List a)
  Split the list `xs` at the index `n`. If `n > length xs`, returns a tuple
  consisting of `xs` and `[]`.
  
  @ n  the index to split the list at
  @ xs the list to split

  Totality: total
  Visibility: public export
partition : (a -> Bool) -> List a -> (List a, List a)
  Divide the list into a tuple containing two smaller lists: one with the
  elements that satisfies the given predicate and another with the elements
  that don't.
  
  @ p  the predicate to partition according to
  @ xs the list to partition

  Totality: total
  Visibility: public export
inits : List a -> List (List a)
  The inits function returns all initial segments of the argument, shortest
  first. For example,
  
  ```idris example
  inits [1,2,3]
  ```

  Totality: total
  Visibility: public export
tails : List a -> List (List a)
  The tails function returns all final segments of the argument, longest
  first. For example,
  
  ```idris example
  tails [1,2,3] == [[1,2,3], [2,3], [3], []]
  ```

  Totality: total
  Visibility: public export
splitOn : Eq a => a -> List a -> List1 (List a)
  Split on the given element.
  
  ```idris example
  splitOn 0 [1,0,2,0,0,3]
  ```
  

  Totality: total
  Visibility: public export
replaceAt : (idx : Nat) -> a -> (xs : List a) -> {auto 0 _ : InBounds idx xs} -> List a
  Replace an element at a particlar index with another.
  
  ```idris example
  replaceAt 2 6 [1, 2, 3, 4]
  ```
  
  @idx The index of the value to replace.
  @x The value to insert.
  @xs The list in which to replace an element.

  Totality: total
  Visibility: public export
replaceWhen : (a -> Bool) -> a -> List a -> List a
  Replace the elements in the list that satisfy the predicate with the given
  value. The general case of `replaceOn`.
  
  @ p  the predicate to replace elements in the list according to
  @ b  the element to replace with
  @ l  the list to perform the replacements on

  Totality: total
  Visibility: public export
replaceOn : Eq a => a -> a -> List a -> List a
  Replace the elements in the list that are equal to `e`, using boolean
  equality, with `b`. A special case of `replaceWhen`, using `== e` as the
  predicate.
  
  ```idris example
  > replaceOn '-' ',' ['1', '-', '2', '-', '3']
  ['1', ',', '2', ',', '3']
  ```
  
  @ e  the element to find and replace
  @ b  the element to replace with
  @ l  the list to perform the replacements on

  Totality: total
  Visibility: public export
replicate : Nat -> a -> List a
  Construct a list with `n` copies of `x`.
  
  @ n how many copies
  @ x the element to replicate

  Totality: total
  Visibility: public export
intersectBy : (a -> a -> Bool) -> List a -> List a -> List a
  Compute the intersect of two lists by user-supplied equality predicate.

  Totality: total
  Visibility: export
intersect : Eq a => List a -> List a -> List a
  Compute the intersection of two lists according to the `Eq` implementation for
  the elements.

  Totality: total
  Visibility: export
intersectAllBy : (a -> a -> Bool) -> List (List a) -> List a
  Compute the intersect of all the lists in the given list of lists, according
  to the user-supplied equality predicate.
  
  @ eq the predicate for computing the intersection
  @ ls the list of lists to compute the intersect of

  Totality: total
  Visibility: export
intersectAll : Eq a => List (List a) -> List a
  Compute the intersect of all the lists in the given list of lists, according
  to boolean equality. A special case of `intersectAllBy`, using `==` as the
  equality predicate.
  
  @ ls the list of lists to compute the intersect of

  Totality: total
  Visibility: export
data NonEmpty : List a -> Type
  Proof that a given list is non-empty.

  Totality: total
  Visibility: public export
  Constructor: 
IsNonEmpty : NonEmpty (x :: xs)

  Hint: 
Uninhabited (NonEmpty [])
head : (l : List a) -> {auto 0 _ : NonEmpty l} -> a
  Get the head of a non-empty list.
  @ ok proof the list is non-empty

  Totality: total
  Visibility: public export
tail : (l : List a) -> {auto 0 _ : NonEmpty l} -> List a
  Get the tail of a non-empty list.
  @ ok proof the list is non-empty

  Totality: total
  Visibility: public export
last : (l : List a) -> {auto 0 _ : NonEmpty l} -> a
  Retrieve the last element of a non-empty list.
  @ ok proof that the list is non-empty

  Totality: total
  Visibility: public export
init : (l : List a) -> {auto 0 _ : NonEmpty l} -> List a
  Return all but the last element of a non-empty list.
  @ ok proof the list is non-empty

  Totality: total
  Visibility: public export
minimum : Ord a => (xs : List a) -> {auto 0 _ : NonEmpty xs} -> a
  Computes the minimum of a non-empty list

  Totality: total
  Visibility: public export
uncons' : List a -> Maybe (a, List a)
  Attempt to deconstruct the list into a head and a tail.

  Totality: total
  Visibility: public export
head' : List a -> Maybe a
  Attempt to get the head of a list. If the list is empty, return `Nothing`.

  Totality: total
  Visibility: public export
tail' : List a -> Maybe (List a)
  Attempt to get the tail of a list. If the list is empty, return `Nothing`.

  Totality: total
  Visibility: export
last' : List a -> Maybe a
  Attempt to retrieve the last element of a non-empty list.
  
  If the list is empty, return `Nothing`.

  Totality: total
  Visibility: export
init' : List a -> Maybe (List a)
  Attempt to return all but the last element of a non-empty list.
  
  If the list is empty, return `Nothing`.

  Totality: total
  Visibility: export
foldr1By : (a -> b -> b) -> (a -> b) -> (l : List a) -> {auto 0 _ : NonEmpty l} -> b
  Foldr a non-empty list, using `map` to transform the first accumulated
  element to something of the desired type and `func` to accumulate the
  elements.
  
  @ func the function used to accumulate the elements
  @ map  an initial transformation from the element to the accumulated type
  @ l    the non-empty list to foldr
  @ ok   proof that the list is non-empty

  Totality: total
  Visibility: public export
foldl1By : (b -> a -> b) -> (a -> b) -> (l : List a) -> {auto 0 _ : NonEmpty l} -> b
  Foldl a non-empty list, using `map` to transform the first accumulated
  element to something of the desired type and `func` to accumulate the
  elements.
  
  @ func the function used to accumulate the elements
  @ map  an initial transformation from the element to the accumulated type
  @ l    the non-empty list to foldl
  @ ok   proof that the list is non-empty

  Totality: total
  Visibility: public export
foldr1 : (a -> a -> a) -> (l : List a) -> {auto 0 _ : NonEmpty l} -> a
  Foldr a non-empty list without seeding the accumulator.
  
  @ ok proof that the list is non-empty

  Totality: total
  Visibility: public export
foldl1 : (a -> a -> a) -> (l : List a) -> {auto 0 _ : NonEmpty l} -> a
  Foldl a non-empty list without seeding the accumulator.
  
  @ ok proof that the list is non-empty

  Totality: total
  Visibility: public export
toList1 : (l : List a) -> {auto 0 _ : NonEmpty l} -> List1 a
  Convert to a non-empty list.
  
  @ ok proof the list is non-empty

  Totality: total
  Visibility: export
toList1' : List a -> Maybe (List1 a)
  Convert to a non-empty list, returning Nothing if the list is empty.

  Totality: total
  Visibility: public export
interleave : List a -> List a -> List a
  Interleave two lists.
  ```idris example
  > interleave ["a", "c", "e"]  ["b", "d", "f"]
  ["a", "b", "c", "d", "e", "f"]
  ```

  Totality: total
  Visibility: public export
mergeReplicate : a -> List a -> List a
  Prefix every element in the list with the given element.
  
  @ sep the value to prefix
  @ xs  the list of elements to prefix with the given element
  
  ```idris example
  > with List (mergeReplicate '>' ['a', 'b', 'c', 'd', 'e'])
  ['>', 'a', '>', 'b', '>', 'c', '>', 'd', '>', 'e']
  ```

  Totality: total
  Visibility: public export
intersperse : a -> List a -> List a
  Insert some separator between the elements of a list.
  
  @ sep the value to intersperse
  @ xs  the list of elements to intersperse with the separator
  
  ```idris example
  > with List (intersperse ',' ['a', 'b', 'c', 'd', 'e'])
  ['a', ',', 'b', ',', 'c', ',', 'd', ',', 'e']
  ```

  Totality: total
  Visibility: public export
intercalate : List a -> List (List a) -> List a
  Given a separator list and some more lists, produce a new list by
  placing the separator between each of the lists.
  
  @ sep the separator
  @ xss the lists between which the separator will be placed
  
  ```idris example
  intercalate [0, 0, 0] [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ]
  ```

  Totality: total
  Visibility: export
catMaybes : List (Maybe a) -> List a
  Extract all of the values contained in a List of Maybes

  Totality: total
  Visibility: public export
sorted : Ord a => List a -> Bool
  Check whether a list is sorted with respect to the default ordering for the type of its elements.

  Totality: total
  Visibility: export
mergeBy : (a -> a -> Ordering) -> List a -> List a -> List a
  Merge two sorted lists using an arbitrary comparison
  predicate. Note that the lists must have been sorted using this
  predicate already.

  Totality: total
  Visibility: export
merge : Ord a => List a -> List a -> List a
  Merge two sorted lists using the default ordering for the type of their elements.

  Totality: total
  Visibility: export
sortBy : (a -> a -> Ordering) -> List a -> List a
  Sort a list using some arbitrary comparison predicate.
  
  @ cmp how to compare elements
  @ xs the list to sort

  Totality: total
  Visibility: export
sort : Ord a => List a -> List a
  Sort a list using the default ordering for the type of its elements.

  Totality: total
  Visibility: export
prefixOfBy : (a -> b -> Maybe m) -> List a -> List b -> Maybe (List m, List b)
  Check whether the `left` list is a prefix of the `right` one, according to
  `match`. Returns the matched prefix together with the leftover suffix.
  
  @ match a custom matching function for checking the elements are convertible
  @ left  the list which might be a prefix of `right`
  @ right the list of elements to compare against

  Totality: total
  Visibility: public export
isPrefixOfBy : (a -> b -> Bool) -> List a -> List b -> Bool
  Check whether the `left` list is a prefix of the `right` one, using the
  provided equality function to compare elements.
  
  @ eq    a custom equality function for comparing the elements
  @ left  the list which might be a prefix of `right`
  @ right the list of elements to compare againts

  Totality: total
  Visibility: public export
isPrefixOf : Eq a => List a -> List a -> Bool
  The isPrefixOf function takes two lists and returns True iff the first list
  is a prefix of the second when comparing elements using `==`.

  Totality: total
  Visibility: public export
suffixOfBy : (a -> b -> Maybe m) -> List a -> List b -> Maybe (List b, List m)
  Check whether the `left` is a suffix of the `right` one, according to
  `match`. Returns the matched suffix together with the leftover prefix.
  
  @ match a custom matching function for checking the elements are convertible
  @ left  the list which might be a prefix of `right`
  @ right the list of elements to compare against

  Totality: total
  Visibility: public export
isSuffixOfBy : (a -> b -> Bool) -> List a -> List b -> Bool
  Check whether the `left` is a suffix of the `right` one, using the provided
  equality function to compare elements.
  
  @ eq    a custom equality function for comparing the elements
  @ left  the list which might be a suffix of `right`
  @ right the list of elements to compare againts

  Totality: total
  Visibility: public export
isSuffixOf : Eq a => List a -> List a -> Bool
  The isSuffixOf function takes two lists and returns True iff the first list
  is a suffix of the second when comparing elements using `==`.

  Totality: total
  Visibility: public export
infixOfBy : (a -> b -> Maybe m) -> List a -> List b -> Maybe (List b, (List m, List b))
  Check whether the `left` list is an infix of the `right` one, according to
  `match`. Returns the shortest unmatched prefix, matched infix and the leftover suffix.

  Totality: total
  Visibility: public export
isInfixOfBy : (a -> b -> Bool) -> List a -> List b -> Bool
  Check whether the `left` is an infix of the `right` one, using the provided
  equality function to compare elements.

  Totality: total
  Visibility: public export
isInfixOf : Eq a => List a -> List a -> Bool
  The isInfixOf function takes two lists and returns True iff the first list
  is contained, wholly and intact, anywhere within the second.
  
  ```idris example
  isInfixOf ['b','c'] ['a', 'b', 'c', 'd']
  ```
  ```idris example
  isInfixOf ['b','d'] ['a', 'b', 'c', 'd']
  ```
  

  Totality: total
  Visibility: public export
transpose : List (List a) -> List (List a)
  Transposes rows and columns of a list of lists.
  
  ```idris example
  with List transpose [[1, 2], [3, 4]]
  ```
  
  This also works for non square scenarios, thus
  involution does not always hold:
  
      transpose [[], [1, 2]] = [[1], [2]]
      transpose (transpose [[], [1, 2]]) = [[1, 2]]

  Totality: total
  Visibility: export
groupBy : (a -> a -> Bool) -> List a -> List (List1 a)
  `groupBy` operates like `group`, but uses the provided equality
  predicate instead of `==`.

  Totality: total
  Visibility: public export
group : Eq a => List a -> List (List1 a)
  The `group` function takes a list of values and returns a list of
  lists such that flattening the resulting list is equal to the
  argument.  Moreover, each list in the resulting list
  contains only equal elements.

  Totality: total
  Visibility: public export
groupWith : Eq b => (a -> b) -> List a -> List (List1 a)
  `groupWith` operates like `group`, but uses the provided projection when
  comparing for equality

  Totality: total
  Visibility: public export
groupAllWith : Ord b => (a -> b) -> List a -> List (List1 a)
  `groupAllWith` operates like `groupWith`, but sorts the list
  first so that each equivalence class has, at most, one list in the
  output

  Totality: total
  Visibility: public export
grouped : (n : Nat) -> {auto 0 _ : IsSucc n} -> List a -> List (List a)
  Partitions a list into fixed sized sublists.
  
  Note: The last list in the result might be shorter than the rest if
        the input cannot evenly be split into groups of the same size.
  
  ```idris example
  grouped 3 [1..10] === [[1,2,3],[4,5,6],[7,8,9],[10]]
  ```

  Totality: total
  Visibility: public export
consInjective : the (List a) (x :: xs) = the (List b) (y :: ys) -> (x = y, xs = ys)
  Heterogeneous injectivity for (::)

  Totality: total
  Visibility: export
reverseInvolutive : (xs : List a) -> reverse (reverse xs) = xs
  List `reverse` applied twice yields the identity function.

  Totality: total
  Visibility: export
appendNilRightNeutral : (l : List a) -> l ++ [] = l
  The empty list is a right identity for append.

  Totality: total
  Visibility: export
appendAssociative : (l : List a) -> (c : List a) -> (r : List a) -> l ++ (c ++ r) = (l ++ c) ++ r
  Appending lists is associative.

  Totality: total
  Visibility: export
revAppend : (vs : List a) -> (ns : List a) -> reverse ns ++ reverse vs = reverse (vs ++ ns)
  `reverse` is distributive

  Totality: total
  Visibility: export
dropFusion : (n : Nat) -> (m : Nat) -> (l : List t) -> drop n (drop m l) = drop (n + m) l
  Dropping `m` elements from `l` and then dropping `n` elements from the
  result, is the same as simply dropping `n+m` elements from `l`

  Totality: total
  Visibility: export
lengthMap : (xs : List a) -> length (map f xs) = length xs
  Mapping a function over a list does not change the length of the list.

  Totality: total
  Visibility: export
lengthReplicate : (n : Nat) -> length (replicate n x) = n
  Proof that replicate produces a list of the requested length.

  Totality: total
  Visibility: export
foldlAppend : (f : (acc -> a -> acc)) -> (init : acc) -> (xs : List a) -> (ys : List a) -> foldl f init (xs ++ ys) = foldl f (foldl f init xs) ys
  Totality: total
  Visibility: export
filterAppend : (f : (a -> Bool)) -> (xs : List a) -> (ys : List a) -> filter f (xs ++ ys) = filter f xs ++ filter f ys
  Totality: total
  Visibility: export
mapMaybeFusion : (g : (b -> Maybe c)) -> (f : (a -> Maybe b)) -> (xs : List a) -> mapMaybe g (mapMaybe f xs) = mapMaybe (f >=> g) xs
  Totality: total
  Visibility: export
mapMaybeAppend : (f : (a -> Maybe b)) -> (xs : List a) -> (ys : List a) -> mapMaybe f (xs ++ ys) = mapMaybe f xs ++ mapMaybe f ys
  Totality: total
  Visibility: export
mapFusion : (g : (b -> c)) -> (f : (a -> b)) -> (xs : List a) -> map g (map f xs) = map (g . f) xs
  Totality: total
  Visibility: export
mapAppend : (f : (a -> b)) -> (xs : List a) -> (ys : List a) -> map f (xs ++ ys) = map f xs ++ map f ys
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.List1.Elem.html b/base/docs/Data.List1.Elem.html
index 27c391ed57..406688157d 100644
--- a/base/docs/Data.List1.Elem.html
+++ b/base/docs/Data.List1.Elem.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List1.Elem(source)
Definitions
data Elem : a -> List1 a -> Type
  A proof that some element is found in a list.

  Totality: total
  Visibility: public export
  Constructors:
  
Here : Elem x (x ::: xs)
  A proof that the element is at the head of the list
  
There : Elem x xs -> Elem x (y ::: xs)
  A proof that the element is in the tail of the list

  Hints:
  
DecEq (Elem x xs)
  
Injective There
  
Uninhabited (Here = There e)
  
Uninhabited (There e = Here)
  
Uninhabited (x = z) => Uninhabited (Elem z xs) => Uninhabited (Elem z (x ::: xs))
neitherHereNorThere : Not (x = y) -> Not (Elem x xs) -> Not (Elem x (y ::: xs))
  An item not in the head and not in the tail is not in the list at all.

  Totality: total
  Visibility: export
isElem : DecEq a => (x : a) -> (xs : List1 a) -> Dec (Elem x xs)
  Check whether the given element is a member of the given list.

  Totality: total
  Visibility: public export
dropElem : (xs : List1 a) -> Elem x xs -> List a
  Remove the element at the given position. Forgets that the list is
  non-empty, since there is no guarantee that it will remain non-empty after
  the removal.

  Totality: total
  Visibility: public export
elemToNat : Elem x xs -> Nat
  Erase the indices, returning the numeric position of the element

  Totality: total
  Visibility: public export
indexElem : Nat -> (xs : List1 a) -> Maybe (x : a ** Elem x xs)
  Find the element with a proof at a given position, if it is valid

  Totality: total
  Visibility: public export
elemMap : (0 f : (a -> b)) -> Elem x xs -> Elem (f x) (map f xs)
  Lift the membership proof to a mapped list

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.List1.Elem(source)
Definitions
data Elem : a -> List1 a -> Type
  A proof that some element is found in a list.

  Totality: total
  Visibility: public export
  Constructors:
  
Here : Elem x (x ::: xs)
  A proof that the element is at the head of the list
  
There : Elem x xs -> Elem x (y ::: xs)
  A proof that the element is in the tail of the list

  Hints:
  
DecEq (Elem x xs)
  
Injective There
  
Uninhabited (Here = There e)
  
Uninhabited (There e = Here)
  
Uninhabited (x = z) => Uninhabited (Elem z xs) => Uninhabited (Elem z (x ::: xs))
neitherHereNorThere : Not (x = y) -> Not (Elem x xs) -> Not (Elem x (y ::: xs))
  An item not in the head and not in the tail is not in the list at all.

  Totality: total
  Visibility: export
isElem : DecEq a => (x : a) -> (xs : List1 a) -> Dec (Elem x xs)
  Check whether the given element is a member of the given list.

  Totality: total
  Visibility: public export
dropElem : (xs : List1 a) -> Elem x xs -> List a
  Remove the element at the given position. Forgets that the list is
  non-empty, since there is no guarantee that it will remain non-empty after
  the removal.

  Totality: total
  Visibility: public export
elemToNat : Elem x xs -> Nat
  Erase the indices, returning the numeric position of the element

  Totality: total
  Visibility: public export
indexElem : Nat -> (xs : List1 a) -> Maybe (x : a ** Elem x xs)
  Find the element with a proof at a given position, if it is valid

  Totality: total
  Visibility: public export
elemMap : (0 f : (a -> b)) -> Elem x xs -> Elem (f x) (map f xs)
  Lift the membership proof to a mapped list

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.List1.Properties.html b/base/docs/Data.List1.Properties.html
index 70371f7454..607adc25db 100644
--- a/base/docs/Data.List1.Properties.html
+++ b/base/docs/Data.List1.Properties.html
@@ -64,4 +64,4 @@
 
Data.List1.Properties(source)
This module contains stuff that may use functions from `Data.List`.
 This separation is needed because `Data.List` uses `List1` type inside it,
 thus the core of `List1` must not import `Data.List`.
-
Reexports
import public Data.Maybe
Definitions
consInjective : x ::: xs = y ::: ys -> (x = y, xs = ys)
  Totality: total
  Visibility: export
listLength : (xs : List1 a) -> length xs = length (forget xs)
  Proof that the length of a List1 is the same as the length
  of the List it represents.

  Totality: total
  Visibility: export
appendlNilRightNeutral : (l : List1 a) -> appendl l [] = l
  Totality: total
  Visibility: export
lappendNilLeftNeutral : (l : List1 a) -> lappend [] l = l
  Totality: total
  Visibility: export
appendAssociative : (l : List1 a) -> (c : List1 a) -> (r : List1 a) -> l ++ (c ++ r) = (l ++ c) ++ r
  Totality: total
  Visibility: export
toListAppendl : (xs : List1 a) -> (ys : List a) -> toList (appendl xs ys) = forget xs ++ ys
  Totality: total
  Visibility: export
toListLappend : (xs : List a) -> (ys : List1 a) -> toList (lappend xs ys) = xs ++ forget ys
  Totality: total
  Visibility: export
toListAppend : (xs : List1 a) -> (ys : List1 a) -> toList (xs ++ ys) = toList xs ++ toList ys
  Totality: total
  Visibility: export
fromListAppend : (xs : List a) -> (ys : List a) -> fromList (xs ++ ys) = fromList xs <+> fromList ys
  Totality: total
  Visibility: export

\ No newline at end of file
+
Reexports
import public Data.Maybe
Definitions
consInjective : x ::: xs = y ::: ys -> (x = y, xs = ys)
  Totality: total
  Visibility: export
listLength : (xs : List1 a) -> length xs = length (forget xs)
  Proof that the length of a List1 is the same as the length
  of the List it represents.

  Totality: total
  Visibility: export
appendlNilRightNeutral : (l : List1 a) -> appendl l [] = l
  Totality: total
  Visibility: export
lappendNilLeftNeutral : (l : List1 a) -> lappend [] l = l
  Totality: total
  Visibility: export
appendAssociative : (l : List1 a) -> (c : List1 a) -> (r : List1 a) -> l ++ (c ++ r) = (l ++ c) ++ r
  Totality: total
  Visibility: export
toListAppendl : (xs : List1 a) -> (ys : List a) -> toList (appendl xs ys) = forget xs ++ ys
  Totality: total
  Visibility: export
toListLappend : (xs : List a) -> (ys : List1 a) -> toList (lappend xs ys) = xs ++ forget ys
  Totality: total
  Visibility: export
toListAppend : (xs : List1 a) -> (ys : List1 a) -> toList (xs ++ ys) = toList xs ++ toList ys
  Totality: total
  Visibility: export
fromListAppend : (xs : List a) -> (ys : List a) -> fromList (xs ++ ys) = fromList xs <+> fromList ys
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.List1.Quantifiers.html b/base/docs/Data.List1.Quantifiers.html
index f1864de41a..f4c42a9868 100644
--- a/base/docs/Data.List1.Quantifiers.html
+++ b/base/docs/Data.List1.Quantifiers.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List1.Quantifiers(source)
Definitions
data Any : (0 _ : (a -> Type)) -> List1 a -> Type
  A proof that some element of a list satisfies some property
  
  @ p the property to be satisfied

  Totality: total
  Visibility: public export
  Constructors:
  
Here : p x -> Any p (x ::: xs)
  A proof that the satisfying element is the first one in the `List1`
  
There : Any p xs -> Any p (x ::: xs)
  A proof that the satisfying element is in the tail of the `List1`
mapProperty : (p x -> q x) -> Any p l -> Any q l
  Modify the property given a pointwise function

  Totality: total
  Visibility: export
any : ((x : a) -> Dec (p x)) -> (xs : List1 a) -> Dec (Any p xs)
  Given a decision procedure for a property, determine if an element of a
  list satisfies it.
  
  @ p the property to be satisfied
  @ dec the decision procedure
  @ xs the list to examine

  Totality: total
  Visibility: public export
toExists : Any p xs -> Exists p
  Forget the membership proof

  Totality: total
  Visibility: export
data All : (0 _ : (a -> Type)) -> List1 a -> Type
  A proof that all elements of a list satisfy a property. It is a list of
  proofs, corresponding element-wise to the `List1`.

  Totality: total
  Visibility: public export
  Constructor: 
(:::) : p x -> All p xs -> All p (x ::: xs)

  Hint: 
Either (Uninhabited (p x)) (Uninhabited (All p xs)) => Uninhabited (All p (x ::: xs))
mapProperty : (p x -> q x) -> All p l -> All q l
  Modify the property given a pointwise function

  Totality: total
  Visibility: export
imapProperty : (0 i : (Type -> Type)) -> (i a => p a -> q a) -> All i types => All p types -> All q types
  Modify the property given a pointwise interface function

  Totality: total
  Visibility: public export
forget : All (const type) types -> List1 type
  Forget property source for a homogeneous collection of properties

  Totality: total
  Visibility: public export
all : ((x : a) -> Dec (p x)) -> (xs : List1 a) -> Dec (All p xs)
  Given a decision procedure for a property, decide whether all elements of
  a list satisfy it.
  
  @ p the property
  @ dec the decision procedure
  @ xs the list to examine

  Totality: total
  Visibility: public export
zipPropertyWith : (p x -> q x -> r x) -> All p xs -> All q xs -> All r xs
  Totality: total
  Visibility: export
HList1 : List1 Type -> Type
  A heterogeneous list of arbitrary types

  Totality: total
  Visibility: public export
negAnyAll : Not (Any p xs) -> All (Not . p) xs
  If there does not exist an element that satifies the property, then it is
  the case that all elements do not satisfy it.

  Totality: total
  Visibility: export
anyNegAll : Any (Not . p) xs -> Not (All p xs)
  If there exists an element that doesn't satify the property, then it is
  not the case that all elements satisfy it.

  Totality: total
  Visibility: export
allNegAny : All (Not . p) xs -> Not (Any p xs)
  If none of the elements satisfy the property, then not any single one can.

  Totality: total
  Visibility: export
indexAll : Elem x xs -> All p xs -> p x
  Given a proof of membership for some element, extract the property proof for it

  Totality: total
  Visibility: public export
pushIn : (xs : List1 a) -> (0 _ : All p xs) -> List1 (Subset a p)
  Push in the property from the list level with element level

  Totality: total
  Visibility: public export
pullOut : List1 (Subset a p) -> Subset (List1 a) (All p)
  Pull the elementwise property out to the list level

  Totality: total
  Visibility: public export
pushInOutInverse : (xs : List1 a) -> (0 prf : All p xs) -> pullOut (pushIn xs prf) = Element xs prf
  Totality: total
  Visibility: export
pushOutInInverse : (xs : List1 (Subset a p)) -> uncurry pushIn (pullOut xs) = xs
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.List1.Quantifiers(source)
Definitions
data Any : (0 _ : (a -> Type)) -> List1 a -> Type
  A proof that some element of a list satisfies some property
  
  @ p the property to be satisfied

  Totality: total
  Visibility: public export
  Constructors:
  
Here : p x -> Any p (x ::: xs)
  A proof that the satisfying element is the first one in the `List1`
  
There : Any p xs -> Any p (x ::: xs)
  A proof that the satisfying element is in the tail of the `List1`
mapProperty : (p x -> q x) -> Any p l -> Any q l
  Modify the property given a pointwise function

  Totality: total
  Visibility: export
any : ((x : a) -> Dec (p x)) -> (xs : List1 a) -> Dec (Any p xs)
  Given a decision procedure for a property, determine if an element of a
  list satisfies it.
  
  @ p the property to be satisfied
  @ dec the decision procedure
  @ xs the list to examine

  Totality: total
  Visibility: public export
toExists : Any p xs -> Exists p
  Forget the membership proof

  Totality: total
  Visibility: export
data All : (0 _ : (a -> Type)) -> List1 a -> Type
  A proof that all elements of a list satisfy a property. It is a list of
  proofs, corresponding element-wise to the `List1`.

  Totality: total
  Visibility: public export
  Constructor: 
(:::) : p x -> All p xs -> All p (x ::: xs)

  Hint: 
Either (Uninhabited (p x)) (Uninhabited (All p xs)) => Uninhabited (All p (x ::: xs))
mapProperty : (p x -> q x) -> All p l -> All q l
  Modify the property given a pointwise function

  Totality: total
  Visibility: export
imapProperty : (0 i : (Type -> Type)) -> (i a => p a -> q a) -> All i types => All p types -> All q types
  Modify the property given a pointwise interface function

  Totality: total
  Visibility: public export
forget : All (const type) types -> List1 type
  Forget property source for a homogeneous collection of properties

  Totality: total
  Visibility: public export
all : ((x : a) -> Dec (p x)) -> (xs : List1 a) -> Dec (All p xs)
  Given a decision procedure for a property, decide whether all elements of
  a list satisfy it.
  
  @ p the property
  @ dec the decision procedure
  @ xs the list to examine

  Totality: total
  Visibility: public export
zipPropertyWith : (p x -> q x -> r x) -> All p xs -> All q xs -> All r xs
  Totality: total
  Visibility: export
HList1 : List1 Type -> Type
  A heterogeneous list of arbitrary types

  Totality: total
  Visibility: public export
negAnyAll : Not (Any p xs) -> All (Not . p) xs
  If there does not exist an element that satifies the property, then it is
  the case that all elements do not satisfy it.

  Totality: total
  Visibility: export
anyNegAll : Any (Not . p) xs -> Not (All p xs)
  If there exists an element that doesn't satify the property, then it is
  not the case that all elements satisfy it.

  Totality: total
  Visibility: export
allNegAny : All (Not . p) xs -> Not (Any p xs)
  If none of the elements satisfy the property, then not any single one can.

  Totality: total
  Visibility: export
indexAll : Elem x xs -> All p xs -> p x
  Given a proof of membership for some element, extract the property proof for it

  Totality: total
  Visibility: public export
pushIn : (xs : List1 a) -> (0 _ : All p xs) -> List1 (Subset a p)
  Push in the property from the list level with element level

  Totality: total
  Visibility: public export
pullOut : List1 (Subset a p) -> Subset (List1 a) (All p)
  Pull the elementwise property out to the list level

  Totality: total
  Visibility: public export
pushInOutInverse : (xs : List1 a) -> (0 prf : All p xs) -> pullOut (pushIn xs prf) = Element xs prf
  Totality: total
  Visibility: export
pushOutInInverse : (xs : List1 (Subset a p)) -> uncurry pushIn (pullOut xs) = xs
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.List1.html b/base/docs/Data.List1.html
index f38b239ede..2d461e2b47 100644
--- a/base/docs/Data.List1.html
+++ b/base/docs/Data.List1.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List1(source)
Reexports
import public Data.Zippable
import public Control.Function
Definitions
record List1 : Type -> Type
  Non-empty lists.

  Totality: total
  Visibility: public export
  Constructor: 
(:::) : a -> List a -> List1 a

  Projections:
  
.head : List1 a -> a
  
.tail : List1 a -> List a

  Hints:
  
Applicative List1
  
Biinjective (:::)
  
DecEq a => DecEq (List1 a)
  
Eq a => Eq (List1 a)
  
Foldable List1
  
Functor List1
  
Injective (\{arg:0} => x ::: {arg:0})
  
Injective (\{arg:0} => {arg:0} ::: ys)
  
Monad List1
  
Ord a => Ord (List1 a)
  
Semigroup (List1 a)
  
Show a => Show (List1 a)
  
Traversable List1
  
Uninhabited a => Uninhabited (List1 a)
  
Zippable List1
.head : List1 a -> a
  Totality: total
  Visibility: public export
head : List1 a -> a
  Totality: total
  Visibility: public export
.tail : List1 a -> List a
  Totality: total
  Visibility: public export
tail : List1 a -> List a
  Totality: total
  Visibility: public export
fromList : List a -> Maybe (List1 a)
  Totality: total
  Visibility: public export
singleton : a -> List1 a
  Totality: total
  Visibility: public export
forget : List1 a -> List a
  Forget that a list is non-empty.

  Totality: total
  Visibility: public export
last : List1 a -> a
  Totality: total
  Visibility: export
init : List1 a -> List a
  Totality: total
  Visibility: export
foldr1By : (a -> b -> b) -> (a -> b) -> List1 a -> b
  Totality: total
  Visibility: public export
foldl1By : (b -> a -> b) -> (a -> b) -> List1 a -> b
  Totality: total
  Visibility: public export
foldr1 : (a -> a -> a) -> List1 a -> a
  Totality: total
  Visibility: public export
foldl1 : (a -> a -> a) -> List1 a -> a
  Totality: total
  Visibility: public export
length : List1 a -> Nat
  Totality: total
  Visibility: public export
appendl : List1 a -> List a -> List1 a
  Totality: total
  Visibility: public export
(++) : List1 a -> List1 a -> List1 a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
lappend : List a -> List1 a -> List1 a
  Totality: total
  Visibility: public export
cons : a -> List1 a -> List1 a
  Totality: total
  Visibility: public export
snoc : List1 a -> a -> List1 a
  Totality: total
  Visibility: public export
unsnoc : List1 a -> (List a, a)
  Totality: total
  Visibility: public export
reverseOnto : List1 a -> List a -> List1 a
  Totality: total
  Visibility: public export
reverse : List1 a -> List1 a
  Totality: total
  Visibility: public export
filter : (a -> Bool) -> List1 a -> Maybe (List1 a)
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.List1(source)
Reexports
import public Data.Zippable
import public Control.Function
Definitions
record List1 : Type -> Type
  Non-empty lists.

  Totality: total
  Visibility: public export
  Constructor: 
(:::) : a -> List a -> List1 a

  Projections:
  
.head : List1 a -> a
  
.tail : List1 a -> List a

  Hints:
  
Applicative List1
  
Biinjective (:::)
  
DecEq a => DecEq (List1 a)
  
Eq a => Eq (List1 a)
  
Foldable List1
  
Functor List1
  
Injective (\{arg:0} => x ::: {arg:0})
  
Injective (\{arg:0} => {arg:0} ::: ys)
  
Monad List1
  
Ord a => Ord (List1 a)
  
Semigroup (List1 a)
  
Show a => Show (List1 a)
  
Traversable List1
  
Uninhabited a => Uninhabited (List1 a)
  
Zippable List1
.head : List1 a -> a
  Totality: total
  Visibility: public export
head : List1 a -> a
  Totality: total
  Visibility: public export
.tail : List1 a -> List a
  Totality: total
  Visibility: public export
tail : List1 a -> List a
  Totality: total
  Visibility: public export
fromList : List a -> Maybe (List1 a)
  Totality: total
  Visibility: public export
singleton : a -> List1 a
  Totality: total
  Visibility: public export
forget : List1 a -> List a
  Forget that a list is non-empty.

  Totality: total
  Visibility: public export
last : List1 a -> a
  Totality: total
  Visibility: export
init : List1 a -> List a
  Totality: total
  Visibility: export
foldr1By : (a -> b -> b) -> (a -> b) -> List1 a -> b
  Totality: total
  Visibility: public export
foldl1By : (b -> a -> b) -> (a -> b) -> List1 a -> b
  Totality: total
  Visibility: public export
foldr1 : (a -> a -> a) -> List1 a -> a
  Totality: total
  Visibility: public export
foldl1 : (a -> a -> a) -> List1 a -> a
  Totality: total
  Visibility: public export
length : List1 a -> Nat
  Totality: total
  Visibility: public export
appendl : List1 a -> List a -> List1 a
  Totality: total
  Visibility: public export
(++) : List1 a -> List1 a -> List1 a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
lappend : List a -> List1 a -> List1 a
  Totality: total
  Visibility: public export
cons : a -> List1 a -> List1 a
  Totality: total
  Visibility: public export
snoc : List1 a -> a -> List1 a
  Totality: total
  Visibility: public export
unsnoc : List1 a -> (List a, a)
  Totality: total
  Visibility: public export
reverseOnto : List1 a -> List a -> List1 a
  Totality: total
  Visibility: public export
reverse : List1 a -> List1 a
  Totality: total
  Visibility: public export
filter : (a -> Bool) -> List1 a -> Maybe (List1 a)
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Maybe.html b/base/docs/Data.Maybe.html
index aa757bb318..5f235c3747 100644
--- a/base/docs/Data.Maybe.html
+++ b/base/docs/Data.Maybe.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Maybe(source)
Definitions
isNothing : Maybe a -> Bool
  Totality: total
  Visibility: public export
isJust : Maybe a -> Bool
  Totality: total
  Visibility: public export
data IsJust : Maybe a -> Type
  Proof that some `Maybe` is actually `Just`

  Totality: total
  Visibility: public export
  Constructor: 
ItIsJust : IsJust (Just x)

  Hint: 
Uninhabited (IsJust Nothing)
isItJust : (v : Maybe a) -> Dec (IsJust v)
  Decide whether a 'Maybe' is 'Just'

  Totality: total
  Visibility: public export
fromMaybe : Lazy a -> Maybe a -> a
  Convert a `Maybe a` value to an `a` value by providing a default `a` value
  in the case that the `Maybe` value is `Nothing`.

  Totality: total
  Visibility: public export
fromJust : (v : Maybe a) -> {auto 0 _ : IsJust v} -> a
  Returns the `a` value of a `Maybe a` which is proved `Just`.

  Totality: total
  Visibility: public export
toMaybe : Bool -> Lazy a -> Maybe a
  Returns `Just` the given value if the conditional is `True`
  and `Nothing` if the conditional is `False`.

  Totality: total
  Visibility: public export
lowerMaybe : Monoid a => Maybe a -> a
  Convert a `Maybe a` value to an `a` value, using `neutral` in the case
  that the `Maybe` value is `Nothing`.

  Totality: total
  Visibility: public export
raiseToMaybe : Monoid a => Eq a => a -> Maybe a
  Returns `Nothing` when applied to `neutral`, and `Just` the value otherwise.

  Totality: total
  Visibility: export
filter : (a -> Bool) -> Maybe a -> Maybe a
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Maybe(source)
Definitions
isNothing : Maybe a -> Bool
  Totality: total
  Visibility: public export
isJust : Maybe a -> Bool
  Totality: total
  Visibility: public export
data IsJust : Maybe a -> Type
  Proof that some `Maybe` is actually `Just`

  Totality: total
  Visibility: public export
  Constructor: 
ItIsJust : IsJust (Just x)

  Hint: 
Uninhabited (IsJust Nothing)
isItJust : (v : Maybe a) -> Dec (IsJust v)
  Decide whether a 'Maybe' is 'Just'

  Totality: total
  Visibility: public export
fromMaybe : Lazy a -> Maybe a -> a
  Convert a `Maybe a` value to an `a` value by providing a default `a` value
  in the case that the `Maybe` value is `Nothing`.

  Totality: total
  Visibility: public export
fromJust : (v : Maybe a) -> {auto 0 _ : IsJust v} -> a
  Returns the `a` value of a `Maybe a` which is proved `Just`.

  Totality: total
  Visibility: public export
toMaybe : Bool -> Lazy a -> Maybe a
  Returns `Just` the given value if the conditional is `True`
  and `Nothing` if the conditional is `False`.

  Totality: total
  Visibility: public export
lowerMaybe : Monoid a => Maybe a -> a
  Convert a `Maybe a` value to an `a` value, using `neutral` in the case
  that the `Maybe` value is `Nothing`.

  Totality: total
  Visibility: public export
raiseToMaybe : Monoid a => Eq a => a -> Maybe a
  Returns `Nothing` when applied to `neutral`, and `Just` the value otherwise.

  Totality: total
  Visibility: export
filter : (a -> Bool) -> Maybe a -> Maybe a
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Morphisms.html b/base/docs/Data.Morphisms.html
index bf4e6ca7eb..fd34e7ff19 100644
--- a/base/docs/Data.Morphisms.html
+++ b/base/docs/Data.Morphisms.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Morphisms(source)
Definitions
record Morphism : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
Mor : (a -> b) -> Morphism a b

  Projection: 
.applyMor : Morphism a b -> a -> b

  Hints:
  
Applicative (Morphism r)
  
Cast (Endomorphism a) (Morphism a a)
  
Cast (Morphism a a) (Endomorphism a)
  
Cast (Morphism a (f b)) (Kleislimorphism f a b)
  
Cast (Kleislimorphism f a b) (Morphism a (f b))
  
Cast (Morphism a b) (Op b a)
  
Cast (Op b a) (Morphism a b)
  
Functor (Morphism r)
  
Monad (Morphism r)
  
Monoid a => Monoid (Morphism r a)
  
Semigroup a => Semigroup (Morphism r a)
.applyMor : Morphism a b -> a -> b
  Totality: total
  Visibility: public export
applyMor : Morphism a b -> a -> b
  Totality: total
  Visibility: public export
(~>) : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 1
record Endomorphism : Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
Endo : (a -> a) -> Endomorphism a

  Projection: 
.applyEndo : Endomorphism a -> a -> a

  Hints:
  
Cast (Endomorphism a) (Morphism a a)
  
Cast (Morphism a a) (Endomorphism a)
  
Cast (Endomorphism a) (Op a a)
  
Cast (Op a a) (Endomorphism a)
  
Monoid (Endomorphism a)
  
Semigroup (Endomorphism a)
.applyEndo : Endomorphism a -> a -> a
  Totality: total
  Visibility: public export
applyEndo : Endomorphism a -> a -> a
  Totality: total
  Visibility: public export
record Kleislimorphism : (Type -> Type) -> Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
Kleisli : (a -> f b) -> Kleislimorphism f a b

  Projection: 
.applyKleisli : Kleislimorphism f a b -> a -> f b

  Hints:
  
Applicative f => Applicative (Kleislimorphism f a)
  
Cast (Morphism a (f b)) (Kleislimorphism f a b)
  
Cast (Kleislimorphism f a b) (Morphism a (f b))
  
Cast (Op (f b) a) (Kleislimorphism f a b)
  
Cast (Kleislimorphism f a b) (Op (f b) a)
  
Functor f => Functor (Kleislimorphism f a)
  
Monad f => Monad (Kleislimorphism f a)
  
(Monoid a, Applicative f) => Monoid (Kleislimorphism f r a)
  
(Semigroup a, Applicative f) => Semigroup (Kleislimorphism f r a)
.applyKleisli : Kleislimorphism f a b -> a -> f b
  Totality: total
  Visibility: public export
applyKleisli : Kleislimorphism f a b -> a -> f b
  Totality: total
  Visibility: public export
record Op : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkOp : (a -> b) -> Op b a

  Projection: 
.applyOp : Op b a -> a -> b

  Hints:
  
Cast (Endomorphism a) (Op a a)
  
Cast (Op a a) (Endomorphism a)
  
Cast (Op (f b) a) (Kleislimorphism f a b)
  
Cast (Kleislimorphism f a b) (Op (f b) a)
  
Cast (Morphism a b) (Op b a)
  
Cast (Op b a) (Morphism a b)
  
Contravariant (Op b)
.applyOp : Op b a -> a -> b
  Totality: total
  Visibility: public export
applyOp : Op b a -> a -> b
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Morphisms(source)
Definitions
record Morphism : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
Mor : (a -> b) -> Morphism a b

  Projection: 
.applyMor : Morphism a b -> a -> b

  Hints:
  
Applicative (Morphism r)
  
Cast (Endomorphism a) (Morphism a a)
  
Cast (Morphism a a) (Endomorphism a)
  
Cast (Morphism a (f b)) (Kleislimorphism f a b)
  
Cast (Kleislimorphism f a b) (Morphism a (f b))
  
Cast (Morphism a b) (Op b a)
  
Cast (Op b a) (Morphism a b)
  
Functor (Morphism r)
  
Monad (Morphism r)
  
Monoid a => Monoid (Morphism r a)
  
Semigroup a => Semigroup (Morphism r a)
.applyMor : Morphism a b -> a -> b
  Totality: total
  Visibility: public export
applyMor : Morphism a b -> a -> b
  Totality: total
  Visibility: public export
(~>) : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 1
record Endomorphism : Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
Endo : (a -> a) -> Endomorphism a

  Projection: 
.applyEndo : Endomorphism a -> a -> a

  Hints:
  
Cast (Endomorphism a) (Morphism a a)
  
Cast (Morphism a a) (Endomorphism a)
  
Cast (Endomorphism a) (Op a a)
  
Cast (Op a a) (Endomorphism a)
  
Monoid (Endomorphism a)
  
Semigroup (Endomorphism a)
.applyEndo : Endomorphism a -> a -> a
  Totality: total
  Visibility: public export
applyEndo : Endomorphism a -> a -> a
  Totality: total
  Visibility: public export
record Kleislimorphism : (Type -> Type) -> Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
Kleisli : (a -> f b) -> Kleislimorphism f a b

  Projection: 
.applyKleisli : Kleislimorphism f a b -> a -> f b

  Hints:
  
Applicative f => Applicative (Kleislimorphism f a)
  
Cast (Morphism a (f b)) (Kleislimorphism f a b)
  
Cast (Kleislimorphism f a b) (Morphism a (f b))
  
Cast (Op (f b) a) (Kleislimorphism f a b)
  
Cast (Kleislimorphism f a b) (Op (f b) a)
  
Functor f => Functor (Kleislimorphism f a)
  
Monad f => Monad (Kleislimorphism f a)
  
(Monoid a, Applicative f) => Monoid (Kleislimorphism f r a)
  
(Semigroup a, Applicative f) => Semigroup (Kleislimorphism f r a)
.applyKleisli : Kleislimorphism f a b -> a -> f b
  Totality: total
  Visibility: public export
applyKleisli : Kleislimorphism f a b -> a -> f b
  Totality: total
  Visibility: public export
record Op : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkOp : (a -> b) -> Op b a

  Projection: 
.applyOp : Op b a -> a -> b

  Hints:
  
Cast (Endomorphism a) (Op a a)
  
Cast (Op a a) (Endomorphism a)
  
Cast (Op (f b) a) (Kleislimorphism f a b)
  
Cast (Kleislimorphism f a b) (Op (f b) a)
  
Cast (Morphism a b) (Op b a)
  
Cast (Op b a) (Morphism a b)
  
Contravariant (Op b)
.applyOp : Op b a -> a -> b
  Totality: total
  Visibility: public export
applyOp : Op b a -> a -> b
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Nat.Order.html b/base/docs/Data.Nat.Order.html
index 056940362a..f331d24b78 100644
--- a/base/docs/Data.Nat.Order.html
+++ b/base/docs/Data.Nat.Order.html
@@ -62,4 +62,4 @@
 
 
 
Data.Nat.Order(source)
Implementation of ordering relations for `Nat`ural numbers
-
Definitions
zeroNeverGreater : Not (LTE (S n) 0)
  Totality: total
  Visibility: public export
zeroAlwaysSmaller : LTE 0 n
  Totality: total
  Visibility: public export
ltesuccinjective : Not (LTE n m) -> Not (LTE (S n) (S m))
  Totality: total
  Visibility: public export
decideLTBounded : {0 p : Nat -> Type} -> ((n : Nat) -> Dec (p n)) -> (n : Nat) -> Dec ((k : Nat) -> LT k n -> p k)
  If a predicate is decidable then we can decide whether it holds on
  a bounded domain.

  Totality: total
  Visibility: public export
decideLTEBounded : {0 p : Nat -> Type} -> ((n : Nat) -> Dec (p n)) -> (n : Nat) -> Dec ((k : Nat) -> LTE k n -> p k)
  If a predicate is decidable then we can decide whether it holds on
  a bounded domain.

  Totality: total
  Visibility: public export
lte : (m : Nat) -> (n : Nat) -> Dec (LTE m n)
  Totality: total
  Visibility: public export
shift : (m : Nat) -> (n : Nat) -> LTE m n -> LTE (S m) (S n)
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
zeroNeverGreater : Not (LTE (S n) 0)
  Totality: total
  Visibility: public export
zeroAlwaysSmaller : LTE 0 n
  Totality: total
  Visibility: public export
ltesuccinjective : Not (LTE n m) -> Not (LTE (S n) (S m))
  Totality: total
  Visibility: public export
decideLTBounded : {0 p : Nat -> Type} -> ((n : Nat) -> Dec (p n)) -> (n : Nat) -> Dec ((k : Nat) -> LT k n -> p k)
  If a predicate is decidable then we can decide whether it holds on
  a bounded domain.

  Totality: total
  Visibility: public export
decideLTEBounded : {0 p : Nat -> Type} -> ((n : Nat) -> Dec (p n)) -> (n : Nat) -> Dec ((k : Nat) -> LTE k n -> p k)
  If a predicate is decidable then we can decide whether it holds on
  a bounded domain.

  Totality: total
  Visibility: public export
lte : (m : Nat) -> (n : Nat) -> Dec (LTE m n)
  Totality: total
  Visibility: public export
shift : (m : Nat) -> (n : Nat) -> LTE m n -> LTE (S m) (S n)
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Nat.Views.html b/base/docs/Data.Nat.Views.html
index 2468243e06..ef88a548c3 100644
--- a/base/docs/Data.Nat.Views.html
+++ b/base/docs/Data.Nat.Views.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Nat.Views(source)
Definitions
data Half : Nat -> Type
  View for dividing a Nat in half

  Totality: total
  Visibility: public export
  Constructors:
  
HalfOdd : (n : Nat) -> Half (S (n + n))
  
HalfEven : (n : Nat) -> Half (n + n)
data HalfRec : Nat -> Type
  View for dividing a Nat in half, recursively

  Totality: total
  Visibility: public export
  Constructors:
  
HalfRecZ : HalfRec 0
  
HalfRecEven : (n : Nat) -> Lazy (HalfRec n) -> HalfRec (n + n)
  
HalfRecOdd : (n : Nat) -> Lazy (HalfRec n) -> HalfRec (S (n + n))
half : (n : Nat) -> Half n
  Covering function for the `Half` view

  Totality: total
  Visibility: public export
halfRec : (n : Nat) -> HalfRec n
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Nat.Views(source)
Definitions
data Half : Nat -> Type
  View for dividing a Nat in half

  Totality: total
  Visibility: public export
  Constructors:
  
HalfOdd : (n : Nat) -> Half (S (n + n))
  
HalfEven : (n : Nat) -> Half (n + n)
data HalfRec : Nat -> Type
  View for dividing a Nat in half, recursively

  Totality: total
  Visibility: public export
  Constructors:
  
HalfRecZ : HalfRec 0
  
HalfRecEven : (n : Nat) -> Lazy (HalfRec n) -> HalfRec (n + n)
  
HalfRecOdd : (n : Nat) -> Lazy (HalfRec n) -> HalfRec (S (n + n))
half : (n : Nat) -> Half n
  Covering function for the `Half` view

  Totality: total
  Visibility: public export
halfRec : (n : Nat) -> HalfRec n
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Nat.html b/base/docs/Data.Nat.html
index c2461299b4..4214ddd5d6 100644
--- a/base/docs/Data.Nat.html
+++ b/base/docs/Data.Nat.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Nat(source)
Reexports
import public Control.Relation
import public Control.Ord
import public Control.Order
import public Control.Function
Definitions
isZero : Nat -> Bool
  Totality: total
  Visibility: public export
isSucc : Nat -> Bool
  Totality: total
  Visibility: public export
data IsSucc : Nat -> Type
  Totality: total
  Visibility: public export
  Constructor: 
ItIsSucc : IsSucc (S n)

  Hint: 
Uninhabited (IsSucc 0)
isItSucc : (n : Nat) -> Dec (IsSucc n)
  Totality: total
  Visibility: public export
power : Nat -> Nat -> Nat
  Totality: total
  Visibility: public export
hyper : Nat -> Nat -> Nat -> Nat
  Totality: total
  Visibility: public export
pred : Nat -> Nat
  Totality: total
  Visibility: public export
compareNatDiag : (k : Nat) -> compareNat k k = EQ
  Totality: total
  Visibility: export
compareNatFlip : (m : Nat) -> (n : Nat) -> flip compareNat m n = contra (compareNat m n)
  Totality: total
  Visibility: export
data NotBothZero : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
LeftIsNotZero : NotBothZero (S n) m
  
RightIsNotZero : NotBothZero n (S m)

  Hint: 
Uninhabited (NotBothZero 0 0)
data LTE : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
LTEZero : LTE 0 right
  
LTESucc : LTE left right -> LTE (S left) (S right)

  Hints:
  
Antisymmetric Nat LTE
  
Connex Nat LTE
  
LinearOrder Nat LTE
  
PartialOrder Nat LTE
  
Preorder Nat LTE
  
Reflexive Nat LTE
  
Transitive Nat LTE
  
Uninhabited (LTE (S n) 0)
  
Uninhabited (LTE m n) => Uninhabited (LTE (S m) (S n))
GTE : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
LT : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
data View : LT m n -> Type
  LT is defined in terms of LTE which makes it annoying to use.
  This convenient view of allows us to avoid having to constantly
  perform nested matches to obtain another LT subproof instead of
  an LTE one.

  Totality: total
  Visibility: public export
  Constructors:
  
LTZero : View (LTESucc LTEZero)
  
LTSucc : (lt : LT m n) -> View (LTESucc lt)
view : (lt : LT m n) -> View lt
  Deconstruct an LT proof into either a base case or a further *LT*

  Totality: total
  Visibility: export
ltZero : LT 0 (S m)
  A convenient alias for trivial LT proofs

  Totality: total
  Visibility: export
GT : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
succNotLTEzero : Not (LTE (S m) 0)
  Totality: total
  Visibility: export
fromLteSucc : LTE (S m) (S n) -> LTE m n
  Totality: total
  Visibility: export
succNotLTEpred : Not (LTE (S x) x)
  Totality: total
  Visibility: export
isLTE : (m : Nat) -> (n : Nat) -> Dec (LTE m n)
  Totality: total
  Visibility: public export
isGTE : (m : Nat) -> (n : Nat) -> Dec (GTE m n)
  Totality: total
  Visibility: public export
isLT : (m : Nat) -> (n : Nat) -> Dec (LT m n)
  Totality: total
  Visibility: public export
isGT : (m : Nat) -> (n : Nat) -> Dec (GT m n)
  Totality: total
  Visibility: public export
lteSuccRight : LTE n m -> LTE n (S m)
  Totality: total
  Visibility: export
lteSuccLeft : LTE (S n) m -> LTE n m
  Totality: total
  Visibility: export
lteAddRight : (n : Nat) -> LTE n (n + m)
  Totality: total
  Visibility: export
notLTEImpliesGT : Not (LTE a b) -> GT a b
  Totality: total
  Visibility: export
LTEImpliesNotGT : LTE a b -> Not (GT a b)
  Totality: total
  Visibility: export
notLTImpliesGTE : Not (LT a b) -> GTE a b
  Totality: total
  Visibility: export
LTImpliesNotGTE : LT a b -> Not (GTE a b)
  Totality: total
  Visibility: export
lte : Nat -> Nat -> Bool
  Totality: total
  Visibility: public export
gte : Nat -> Nat -> Bool
  Totality: total
  Visibility: public export
lt : Nat -> Nat -> Bool
  Totality: total
  Visibility: public export
gt : Nat -> Nat -> Bool
  Totality: total
  Visibility: public export
lteReflectsLTE : (k : Nat) -> (n : Nat) -> lte k n = True -> LTE k n
  Totality: total
  Visibility: export
gteReflectsGTE : (k : Nat) -> (n : Nat) -> gte k n = True -> GTE k n
  Totality: total
  Visibility: export
ltReflectsLT : (k : Nat) -> (n : Nat) -> lt k n = True -> LT k n
  Totality: total
  Visibility: export
ltOpReflectsLT : (m : Nat) -> (n : Nat) -> So (m < n) -> LT m n
  Totality: total
  Visibility: public export
gtReflectsGT : (k : Nat) -> (n : Nat) -> gt k n = True -> GT k n
  Totality: total
  Visibility: export
minimum : Nat -> Nat -> Nat
  Totality: total
  Visibility: public export
maximum : Nat -> Nat -> Nat
  Totality: total
  Visibility: public export
eqSucc : (0 left : Nat) -> (0 right : Nat) -> left = right -> S left = S right
  Totality: total
  Visibility: export
data NonZero : Nat -> Type
  A definition of non-zero with a better behaviour than `Not (x = Z)`
  This is amenable to proof search and `NonZero Z` is more readily
  detected as impossible by Idris

  Totality: total
  Visibility: public export
  Constructor: 
SIsNonZero : NonZero (S x)

  Hint: 
Uninhabited (NonZero 0)
SIsNotZ : Not (S x = 0)
  Totality: total
  Visibility: export
mod' : Nat -> Nat -> Nat -> Nat
  Auxiliary function:
  mod' fuel a b = a `mod` (S b)
  assuming we have enough fuel

  Totality: total
  Visibility: public export
modNatNZ : Nat -> (y : Nat) -> (0 _ : NonZero y) -> Nat
  Totality: total
  Visibility: public export
modNat : Nat -> Nat -> Nat
  Visibility: export
div' : Nat -> Nat -> Nat -> Nat
  Auxiliary function:
  div' fuel a b = a `div` (S b)
  assuming we have enough fuel

  Totality: total
  Visibility: public export
divNatNZ : Nat -> (y : Nat) -> (0 _ : NonZero y) -> Nat
  Totality: total
  Visibility: public export
divNat : Nat -> Nat -> Nat
  Visibility: export
divCeilNZ : Nat -> (y : Nat) -> (0 _ : NonZero y) -> Nat
  Visibility: export
divCeil : Nat -> Nat -> Nat
  Visibility: export
divmod' : Nat -> Nat -> Nat -> (Nat, Nat)
  Totality: total
  Visibility: public export
divmodNatNZ : Nat -> (y : Nat) -> (0 _ : NonZero y) -> (Nat, Nat)
  Totality: total
  Visibility: public export
gcd : (a : Nat) -> (b : Nat) -> {auto 0 _ : NotBothZero a b} -> Nat
  Visibility: export
lcm : Nat -> Nat -> Nat
  Visibility: export
data CmpNat : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
CmpLT : (y : Nat) -> CmpNat x (x + S y)
  
CmpEQ : CmpNat x x
  
CmpGT : (x : Nat) -> CmpNat (y + S x) y
cmp : (x : Nat) -> (y : Nat) -> CmpNat x y
  Totality: total
  Visibility: export
plusZeroLeftNeutral : (right : Nat) -> 0 + right = right
  Totality: total
  Visibility: export
plusZeroRightNeutral : (left : Nat) -> left + 0 = left
  Totality: total
  Visibility: export
plusSuccRightSucc : (left : Nat) -> (right : Nat) -> S (left + right) = left + S right
  Totality: total
  Visibility: export
plusCommutative : (left : Nat) -> (right : Nat) -> left + right = right + left
  Totality: total
  Visibility: export
plusAssociative : (left : Nat) -> (centre : Nat) -> (right : Nat) -> left + (centre + right) = (left + centre) + right
  Totality: total
  Visibility: export
plusConstantRight : (left : Nat) -> (right : Nat) -> (c : Nat) -> left = right -> left + c = right + c
  Totality: total
  Visibility: export
plusConstantLeft : (left : Nat) -> (right : Nat) -> (c : Nat) -> left = right -> c + left = c + right
  Totality: total
  Visibility: export
plusOneSucc : (right : Nat) -> 1 + right = S right
  Totality: total
  Visibility: export
plusLeftCancel : (left : Nat) -> (right : Nat) -> (right' : Nat) -> left + right = left + right' -> right = right'
  Totality: total
  Visibility: export
plusRightCancel : (left : Nat) -> (left' : Nat) -> (right : Nat) -> left + right = left' + right -> left = left'
  Totality: total
  Visibility: export
plusLeftLeftRightZero : (left : Nat) -> (right : Nat) -> left + right = left -> right = 0
  Totality: total
  Visibility: export
plusLteMonotoneRight : (p : Nat) -> (q : Nat) -> (r : Nat) -> LTE q r -> LTE (q + p) (r + p)
  Totality: total
  Visibility: export
plusLteMonotoneLeft : (p : Nat) -> (q : Nat) -> (r : Nat) -> LTE q r -> LTE (p + q) (p + r)
  Totality: total
  Visibility: export
plusLteMonotone : LTE m n -> LTE p q -> LTE (m + p) (n + q)
  Totality: total
  Visibility: export
multZeroLeftZero : (right : Nat) -> 0 * right = 0
  Totality: total
  Visibility: export
multZeroRightZero : (left : Nat) -> left * 0 = 0
  Totality: total
  Visibility: export
multRightSuccPlus : (left : Nat) -> (right : Nat) -> left * S right = left + (left * right)
  Totality: total
  Visibility: export
multLeftSuccPlus : (left : Nat) -> (right : Nat) -> S left * right = right + (left * right)
  Totality: total
  Visibility: export
multCommutative : (left : Nat) -> (right : Nat) -> left * right = right * left
  Totality: total
  Visibility: export
multDistributesOverPlusLeft : (left : Nat) -> (centre : Nat) -> (right : Nat) -> (left + centre) * right = (left * right) + (centre * right)
  Totality: total
  Visibility: export
multDistributesOverPlusRight : (left : Nat) -> (centre : Nat) -> (right : Nat) -> left * (centre + right) = (left * centre) + (left * right)
  Totality: total
  Visibility: export
multAssociative : (left : Nat) -> (centre : Nat) -> (right : Nat) -> left * (centre * right) = (left * centre) * right
  Totality: total
  Visibility: export
multOneLeftNeutral : (right : Nat) -> 1 * right = right
  Totality: total
  Visibility: export
multOneRightNeutral : (left : Nat) -> left * 1 = left
  Totality: total
  Visibility: export
minusSuccSucc : (left : Nat) -> (right : Nat) -> minus (S left) (S right) = minus left right
  Totality: total
  Visibility: export
minusZeroLeft : (right : Nat) -> minus 0 right = 0
  Totality: total
  Visibility: export
minusZeroRight : (left : Nat) -> minus left 0 = left
  Totality: total
  Visibility: export
minusZeroN : (n : Nat) -> 0 = minus n n
  Totality: total
  Visibility: export
minusOneSuccN : (n : Nat) -> 1 = minus (S n) n
  Totality: total
  Visibility: export
minusSuccOne : (n : Nat) -> minus (S n) 1 = n
  Totality: total
  Visibility: export
minusPlusZero : (n : Nat) -> (m : Nat) -> minus n (n + m) = 0
  Totality: total
  Visibility: export
minusPos : LT m n -> LT 0 (minus n m)
  Totality: total
  Visibility: export
minusLteMonotone : LTE m n -> LTE (minus m p) (minus n p)
  Totality: total
  Visibility: export
minusLtMonotone : LT m n -> LT p n -> LT (minus m p) (minus n p)
  Totality: total
  Visibility: export
minusPlus : (m : Nat) -> minus (plus m n) m = n
  Totality: total
  Visibility: public export
plusMinusLte : (n : Nat) -> (m : Nat) -> LTE n m -> minus m n + n = m
  Totality: total
  Visibility: export
minusMinusMinusPlus : (left : Nat) -> (centre : Nat) -> (right : Nat) -> minus (minus left centre) right = minus left (centre + right)
  Totality: total
  Visibility: export
plusMinusLeftCancel : (left : Nat) -> (right : Nat) -> (right' : Nat) -> minus (left + right) (left + right') = minus right right'
  Totality: total
  Visibility: export
multDistributesOverMinusLeft : (left : Nat) -> (centre : Nat) -> (right : Nat) -> minus left centre * right = minus (left * right) (centre * right)
  Totality: total
  Visibility: export
multDistributesOverMinusRight : (left : Nat) -> (centre : Nat) -> (right : Nat) -> left * minus centre right = minus (left * centre) (left * right)
  Totality: total
  Visibility: export
zeroMultEitherZero : (a : Nat) -> (b : Nat) -> a * b = 0 -> Either (a = 0) (b = 0)
  Totality: total
  Visibility: export
maximumAssociative : (l : Nat) -> (c : Nat) -> (r : Nat) -> maximum l (maximum c r) = maximum (maximum l c) r
  Totality: total
  Visibility: export
maximumCommutative : (l : Nat) -> (r : Nat) -> maximum l r = maximum r l
  Totality: total
  Visibility: export
maximumIdempotent : (n : Nat) -> maximum n n = n
  Totality: total
  Visibility: export
maximumLeftUpperBound : (m : Nat) -> (n : Nat) -> LTE m (maximum m n)
  Totality: total
  Visibility: export
maximumRightUpperBound : (m : Nat) -> (n : Nat) -> LTE n (maximum m n)
  Totality: total
  Visibility: export
minimumAssociative : (l : Nat) -> (c : Nat) -> (r : Nat) -> minimum l (minimum c r) = minimum (minimum l c) r
  Totality: total
  Visibility: export
minimumCommutative : (l : Nat) -> (r : Nat) -> minimum l r = minimum r l
  Totality: total
  Visibility: export
minimumIdempotent : (n : Nat) -> minimum n n = n
  Totality: total
  Visibility: export
minimumZeroZeroLeft : (left : Nat) -> minimum left 0 = 0
  Totality: total
  Visibility: export
minimumSuccSucc : (left : Nat) -> (right : Nat) -> minimum (S left) (S right) = S (minimum left right)
  Totality: total
  Visibility: export
maximumZeroNLeft : (left : Nat) -> maximum left 0 = left
  Totality: total
  Visibility: export
maximumSuccSucc : (left : Nat) -> (right : Nat) -> S (maximum left right) = maximum (S left) (S right)
  Totality: total
  Visibility: export
sucMaxL : (l : Nat) -> maximum (S l) l = S l
  Totality: total
  Visibility: export
sucMaxR : (l : Nat) -> maximum l (S l) = S l
  Totality: total
  Visibility: export
sucMinL : (l : Nat) -> minimum (S l) l = l
  Totality: total
  Visibility: export
sucMinR : (l : Nat) -> minimum l (S l) = l
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Nat(source)
Reexports
import public Control.Relation
import public Control.Ord
import public Control.Order
import public Control.Function
Definitions
isZero : Nat -> Bool
  Totality: total
  Visibility: public export
isSucc : Nat -> Bool
  Totality: total
  Visibility: public export
data IsSucc : Nat -> Type
  Totality: total
  Visibility: public export
  Constructor: 
ItIsSucc : IsSucc (S n)

  Hint: 
Uninhabited (IsSucc 0)
isItSucc : (n : Nat) -> Dec (IsSucc n)
  Totality: total
  Visibility: public export
power : Nat -> Nat -> Nat
  Totality: total
  Visibility: public export
hyper : Nat -> Nat -> Nat -> Nat
  Totality: total
  Visibility: public export
pred : Nat -> Nat
  Totality: total
  Visibility: public export
compareNatDiag : (k : Nat) -> compareNat k k = EQ
  Totality: total
  Visibility: export
compareNatFlip : (m : Nat) -> (n : Nat) -> flip compareNat m n = contra (compareNat m n)
  Totality: total
  Visibility: export
data NotBothZero : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
LeftIsNotZero : NotBothZero (S n) m
  
RightIsNotZero : NotBothZero n (S m)

  Hint: 
Uninhabited (NotBothZero 0 0)
data LTE : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
LTEZero : LTE 0 right
  
LTESucc : LTE left right -> LTE (S left) (S right)

  Hints:
  
Antisymmetric Nat LTE
  
Connex Nat LTE
  
LinearOrder Nat LTE
  
PartialOrder Nat LTE
  
Preorder Nat LTE
  
Reflexive Nat LTE
  
Transitive Nat LTE
  
Uninhabited (LTE (S n) 0)
  
Uninhabited (LTE m n) => Uninhabited (LTE (S m) (S n))
GTE : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
LT : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
data View : LT m n -> Type
  LT is defined in terms of LTE which makes it annoying to use.
  This convenient view of allows us to avoid having to constantly
  perform nested matches to obtain another LT subproof instead of
  an LTE one.

  Totality: total
  Visibility: public export
  Constructors:
  
LTZero : View (LTESucc LTEZero)
  
LTSucc : (lt : LT m n) -> View (LTESucc lt)
view : (lt : LT m n) -> View lt
  Deconstruct an LT proof into either a base case or a further *LT*

  Totality: total
  Visibility: export
ltZero : LT 0 (S m)
  A convenient alias for trivial LT proofs

  Totality: total
  Visibility: export
GT : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
succNotLTEzero : Not (LTE (S m) 0)
  Totality: total
  Visibility: export
fromLteSucc : LTE (S m) (S n) -> LTE m n
  Totality: total
  Visibility: export
succNotLTEpred : Not (LTE (S x) x)
  Totality: total
  Visibility: export
isLTE : (m : Nat) -> (n : Nat) -> Dec (LTE m n)
  Totality: total
  Visibility: public export
isGTE : (m : Nat) -> (n : Nat) -> Dec (GTE m n)
  Totality: total
  Visibility: public export
isLT : (m : Nat) -> (n : Nat) -> Dec (LT m n)
  Totality: total
  Visibility: public export
isGT : (m : Nat) -> (n : Nat) -> Dec (GT m n)
  Totality: total
  Visibility: public export
lteSuccRight : LTE n m -> LTE n (S m)
  Totality: total
  Visibility: export
lteSuccLeft : LTE (S n) m -> LTE n m
  Totality: total
  Visibility: export
lteAddRight : (n : Nat) -> LTE n (n + m)
  Totality: total
  Visibility: export
notLTEImpliesGT : Not (LTE a b) -> GT a b
  Totality: total
  Visibility: export
LTEImpliesNotGT : LTE a b -> Not (GT a b)
  Totality: total
  Visibility: export
notLTImpliesGTE : Not (LT a b) -> GTE a b
  Totality: total
  Visibility: export
LTImpliesNotGTE : LT a b -> Not (GTE a b)
  Totality: total
  Visibility: export
lte : Nat -> Nat -> Bool
  Totality: total
  Visibility: public export
gte : Nat -> Nat -> Bool
  Totality: total
  Visibility: public export
lt : Nat -> Nat -> Bool
  Totality: total
  Visibility: public export
gt : Nat -> Nat -> Bool
  Totality: total
  Visibility: public export
lteReflectsLTE : (k : Nat) -> (n : Nat) -> lte k n = True -> LTE k n
  Totality: total
  Visibility: export
gteReflectsGTE : (k : Nat) -> (n : Nat) -> gte k n = True -> GTE k n
  Totality: total
  Visibility: export
ltReflectsLT : (k : Nat) -> (n : Nat) -> lt k n = True -> LT k n
  Totality: total
  Visibility: export
ltOpReflectsLT : (m : Nat) -> (n : Nat) -> So (m < n) -> LT m n
  Totality: total
  Visibility: public export
gtReflectsGT : (k : Nat) -> (n : Nat) -> gt k n = True -> GT k n
  Totality: total
  Visibility: export
minimum : Nat -> Nat -> Nat
  Totality: total
  Visibility: public export
maximum : Nat -> Nat -> Nat
  Totality: total
  Visibility: public export
eqSucc : (0 left : Nat) -> (0 right : Nat) -> left = right -> S left = S right
  Totality: total
  Visibility: export
data NonZero : Nat -> Type
  A definition of non-zero with a better behaviour than `Not (x = Z)`
  This is amenable to proof search and `NonZero Z` is more readily
  detected as impossible by Idris

  Totality: total
  Visibility: public export
  Constructor: 
SIsNonZero : NonZero (S x)

  Hint: 
Uninhabited (NonZero 0)
SIsNotZ : Not (S x = 0)
  Totality: total
  Visibility: export
mod' : Nat -> Nat -> Nat -> Nat
  Auxiliary function:
  mod' fuel a b = a `mod` (S b)
  assuming we have enough fuel

  Totality: total
  Visibility: public export
modNatNZ : Nat -> (y : Nat) -> (0 _ : NonZero y) -> Nat
  Totality: total
  Visibility: public export
modNat : Nat -> Nat -> Nat
  Visibility: export
div' : Nat -> Nat -> Nat -> Nat
  Auxiliary function:
  div' fuel a b = a `div` (S b)
  assuming we have enough fuel

  Totality: total
  Visibility: public export
divNatNZ : Nat -> (y : Nat) -> (0 _ : NonZero y) -> Nat
  Totality: total
  Visibility: public export
divNat : Nat -> Nat -> Nat
  Visibility: export
divCeilNZ : Nat -> (y : Nat) -> (0 _ : NonZero y) -> Nat
  Visibility: export
divCeil : Nat -> Nat -> Nat
  Visibility: export
divmod' : Nat -> Nat -> Nat -> (Nat, Nat)
  Totality: total
  Visibility: public export
divmodNatNZ : Nat -> (y : Nat) -> (0 _ : NonZero y) -> (Nat, Nat)
  Totality: total
  Visibility: public export
gcd : (a : Nat) -> (b : Nat) -> {auto 0 _ : NotBothZero a b} -> Nat
  Visibility: export
lcm : Nat -> Nat -> Nat
  Visibility: export
data CmpNat : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
CmpLT : (y : Nat) -> CmpNat x (x + S y)
  
CmpEQ : CmpNat x x
  
CmpGT : (x : Nat) -> CmpNat (y + S x) y
cmp : (x : Nat) -> (y : Nat) -> CmpNat x y
  Totality: total
  Visibility: export
plusZeroLeftNeutral : (right : Nat) -> 0 + right = right
  Totality: total
  Visibility: export
plusZeroRightNeutral : (left : Nat) -> left + 0 = left
  Totality: total
  Visibility: export
plusSuccRightSucc : (left : Nat) -> (right : Nat) -> S (left + right) = left + S right
  Totality: total
  Visibility: export
plusCommutative : (left : Nat) -> (right : Nat) -> left + right = right + left
  Totality: total
  Visibility: export
plusAssociative : (left : Nat) -> (centre : Nat) -> (right : Nat) -> left + (centre + right) = (left + centre) + right
  Totality: total
  Visibility: export
plusConstantRight : (left : Nat) -> (right : Nat) -> (c : Nat) -> left = right -> left + c = right + c
  Totality: total
  Visibility: export
plusConstantLeft : (left : Nat) -> (right : Nat) -> (c : Nat) -> left = right -> c + left = c + right
  Totality: total
  Visibility: export
plusOneSucc : (right : Nat) -> 1 + right = S right
  Totality: total
  Visibility: export
plusLeftCancel : (left : Nat) -> (right : Nat) -> (right' : Nat) -> left + right = left + right' -> right = right'
  Totality: total
  Visibility: export
plusRightCancel : (left : Nat) -> (left' : Nat) -> (right : Nat) -> left + right = left' + right -> left = left'
  Totality: total
  Visibility: export
plusLeftLeftRightZero : (left : Nat) -> (right : Nat) -> left + right = left -> right = 0
  Totality: total
  Visibility: export
plusLteMonotoneRight : (p : Nat) -> (q : Nat) -> (r : Nat) -> LTE q r -> LTE (q + p) (r + p)
  Totality: total
  Visibility: export
plusLteMonotoneLeft : (p : Nat) -> (q : Nat) -> (r : Nat) -> LTE q r -> LTE (p + q) (p + r)
  Totality: total
  Visibility: export
plusLteMonotone : LTE m n -> LTE p q -> LTE (m + p) (n + q)
  Totality: total
  Visibility: export
multZeroLeftZero : (right : Nat) -> 0 * right = 0
  Totality: total
  Visibility: export
multZeroRightZero : (left : Nat) -> left * 0 = 0
  Totality: total
  Visibility: export
multRightSuccPlus : (left : Nat) -> (right : Nat) -> left * S right = left + (left * right)
  Totality: total
  Visibility: export
multLeftSuccPlus : (left : Nat) -> (right : Nat) -> S left * right = right + (left * right)
  Totality: total
  Visibility: export
multCommutative : (left : Nat) -> (right : Nat) -> left * right = right * left
  Totality: total
  Visibility: export
multDistributesOverPlusLeft : (left : Nat) -> (centre : Nat) -> (right : Nat) -> (left + centre) * right = (left * right) + (centre * right)
  Totality: total
  Visibility: export
multDistributesOverPlusRight : (left : Nat) -> (centre : Nat) -> (right : Nat) -> left * (centre + right) = (left * centre) + (left * right)
  Totality: total
  Visibility: export
multAssociative : (left : Nat) -> (centre : Nat) -> (right : Nat) -> left * (centre * right) = (left * centre) * right
  Totality: total
  Visibility: export
multOneLeftNeutral : (right : Nat) -> 1 * right = right
  Totality: total
  Visibility: export
multOneRightNeutral : (left : Nat) -> left * 1 = left
  Totality: total
  Visibility: export
minusSuccSucc : (left : Nat) -> (right : Nat) -> minus (S left) (S right) = minus left right
  Totality: total
  Visibility: export
minusZeroLeft : (right : Nat) -> minus 0 right = 0
  Totality: total
  Visibility: export
minusZeroRight : (left : Nat) -> minus left 0 = left
  Totality: total
  Visibility: export
minusZeroN : (n : Nat) -> 0 = minus n n
  Totality: total
  Visibility: export
minusOneSuccN : (n : Nat) -> 1 = minus (S n) n
  Totality: total
  Visibility: export
minusSuccOne : (n : Nat) -> minus (S n) 1 = n
  Totality: total
  Visibility: export
minusPlusZero : (n : Nat) -> (m : Nat) -> minus n (n + m) = 0
  Totality: total
  Visibility: export
minusPos : LT m n -> LT 0 (minus n m)
  Totality: total
  Visibility: export
minusLteMonotone : LTE m n -> LTE (minus m p) (minus n p)
  Totality: total
  Visibility: export
minusLtMonotone : LT m n -> LT p n -> LT (minus m p) (minus n p)
  Totality: total
  Visibility: export
minusPlus : (m : Nat) -> minus (plus m n) m = n
  Totality: total
  Visibility: public export
plusMinusLte : (n : Nat) -> (m : Nat) -> LTE n m -> minus m n + n = m
  Totality: total
  Visibility: export
minusMinusMinusPlus : (left : Nat) -> (centre : Nat) -> (right : Nat) -> minus (minus left centre) right = minus left (centre + right)
  Totality: total
  Visibility: export
plusMinusLeftCancel : (left : Nat) -> (right : Nat) -> (right' : Nat) -> minus (left + right) (left + right') = minus right right'
  Totality: total
  Visibility: export
multDistributesOverMinusLeft : (left : Nat) -> (centre : Nat) -> (right : Nat) -> minus left centre * right = minus (left * right) (centre * right)
  Totality: total
  Visibility: export
multDistributesOverMinusRight : (left : Nat) -> (centre : Nat) -> (right : Nat) -> left * minus centre right = minus (left * centre) (left * right)
  Totality: total
  Visibility: export
zeroMultEitherZero : (a : Nat) -> (b : Nat) -> a * b = 0 -> Either (a = 0) (b = 0)
  Totality: total
  Visibility: export
maximumAssociative : (l : Nat) -> (c : Nat) -> (r : Nat) -> maximum l (maximum c r) = maximum (maximum l c) r
  Totality: total
  Visibility: export
maximumCommutative : (l : Nat) -> (r : Nat) -> maximum l r = maximum r l
  Totality: total
  Visibility: export
maximumIdempotent : (n : Nat) -> maximum n n = n
  Totality: total
  Visibility: export
maximumLeftUpperBound : (m : Nat) -> (n : Nat) -> LTE m (maximum m n)
  Totality: total
  Visibility: export
maximumRightUpperBound : (m : Nat) -> (n : Nat) -> LTE n (maximum m n)
  Totality: total
  Visibility: export
minimumAssociative : (l : Nat) -> (c : Nat) -> (r : Nat) -> minimum l (minimum c r) = minimum (minimum l c) r
  Totality: total
  Visibility: export
minimumCommutative : (l : Nat) -> (r : Nat) -> minimum l r = minimum r l
  Totality: total
  Visibility: export
minimumIdempotent : (n : Nat) -> minimum n n = n
  Totality: total
  Visibility: export
minimumZeroZeroLeft : (left : Nat) -> minimum left 0 = 0
  Totality: total
  Visibility: export
minimumSuccSucc : (left : Nat) -> (right : Nat) -> minimum (S left) (S right) = S (minimum left right)
  Totality: total
  Visibility: export
maximumZeroNLeft : (left : Nat) -> maximum left 0 = left
  Totality: total
  Visibility: export
maximumSuccSucc : (left : Nat) -> (right : Nat) -> S (maximum left right) = maximum (S left) (S right)
  Totality: total
  Visibility: export
sucMaxL : (l : Nat) -> maximum (S l) l = S l
  Totality: total
  Visibility: export
sucMaxR : (l : Nat) -> maximum l (S l) = S l
  Totality: total
  Visibility: export
sucMinL : (l : Nat) -> minimum (S l) l = l
  Totality: total
  Visibility: export
sucMinR : (l : Nat) -> minimum l (S l) = l
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.Primitives.Interpolation.html b/base/docs/Data.Primitives.Interpolation.html
index 3e96dc8777..97740b25bd 100644
--- a/base/docs/Data.Primitives.Interpolation.html
+++ b/base/docs/Data.Primitives.Interpolation.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Primitives.Interpolation(source)
Definitions

\ No newline at end of file
+
Data.Primitives.Interpolation(source)
Definitions

\ No newline at end of file
diff --git a/base/docs/Data.Primitives.Views.html b/base/docs/Data.Primitives.Views.html
index b0b515878b..c5ca413b27 100644
--- a/base/docs/Data.Primitives.Views.html
+++ b/base/docs/Data.Primitives.Views.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Primitives.Views(source)
Definitions
data Divides : Integer -> Integer -> Type
  View for expressing a number as a multiplication + a remainder

  Totality: total
  Visibility: public export
  Constructors:
  
DivByZero : Divides x 0
  
DivBy : (div : Integer) -> (rem : Integer) -> (rem >= 0) && Delay (rem < d) = True -> Divides ((d * div) + rem) d
divides : (val : Integer) -> (d : Integer) -> Divides val d
  Covering function for the `Divides` view

  Totality: total
  Visibility: public export
data IntegerRec : Integer -> Type
  View for recursion over Integers

  Totality: total
  Visibility: public export
  Constructors:
  
IntegerZ : IntegerRec 0
  
IntegerSucc : IntegerRec (-1 + n) -> IntegerRec n
  
IntegerPred : IntegerRec (1 + negate n) -> IntegerRec (negate n)
integerRec : (x : Integer) -> IntegerRec x
  Covering function for `IntegerRec`

  Totality: total
  Visibility: public export
data Divides : Int -> Int -> Type
  View for expressing a number as a multiplication + a remainder

  Totality: total
  Visibility: public export
  Constructors:
  
DivByZero : Divides x 0
  
DivBy : (div : Int) -> (rem : Int) -> (rem >= 0) && Delay (rem < d) = True -> Divides ((d * div) + rem) d
divides : (val : Int) -> (d : Int) -> Divides val d
  Covering function for the `Divides` view

  Totality: total
  Visibility: public export
data IntRec : Int -> Type
  View for recursion over Ints

  Totality: total
  Visibility: public export
  Constructors:
  
IntZ : IntRec 0
  
IntSucc : IntRec (-1 + n) -> IntRec n
  
IntPred : IntRec (1 + negate n) -> IntRec (negate n)
intRec : (x : Int) -> IntRec x
  Covering function for `IntRec`

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Primitives.Views(source)
Definitions
data Divides : Integer -> Integer -> Type
  View for expressing a number as a multiplication + a remainder

  Totality: total
  Visibility: public export
  Constructors:
  
DivByZero : Divides x 0
  
DivBy : (div : Integer) -> (rem : Integer) -> (rem >= 0) && Delay (rem < d) = True -> Divides ((d * div) + rem) d
divides : (val : Integer) -> (d : Integer) -> Divides val d
  Covering function for the `Divides` view

  Totality: total
  Visibility: public export
data IntegerRec : Integer -> Type
  View for recursion over Integers

  Totality: total
  Visibility: public export
  Constructors:
  
IntegerZ : IntegerRec 0
  
IntegerSucc : IntegerRec (-1 + n) -> IntegerRec n
  
IntegerPred : IntegerRec (1 + negate n) -> IntegerRec (negate n)
integerRec : (x : Integer) -> IntegerRec x
  Covering function for `IntegerRec`

  Totality: total
  Visibility: public export
data Divides : Int -> Int -> Type
  View for expressing a number as a multiplication + a remainder

  Totality: total
  Visibility: public export
  Constructors:
  
DivByZero : Divides x 0
  
DivBy : (div : Int) -> (rem : Int) -> (rem >= 0) && Delay (rem < d) = True -> Divides ((d * div) + rem) d
divides : (val : Int) -> (d : Int) -> Divides val d
  Covering function for the `Divides` view

  Totality: total
  Visibility: public export
data IntRec : Int -> Type
  View for recursion over Ints

  Totality: total
  Visibility: public export
  Constructors:
  
IntZ : IntRec 0
  
IntSucc : IntRec (-1 + n) -> IntRec n
  
IntPred : IntRec (1 + negate n) -> IntRec (negate n)
intRec : (x : Int) -> IntRec x
  Covering function for `IntRec`

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Ref.html b/base/docs/Data.Ref.html
index 05d3816c8b..4adbc84def 100644
--- a/base/docs/Data.Ref.html
+++ b/base/docs/Data.Ref.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Ref(source)
Reexports
import public Data.IORef
import public Control.Monad.ST
Definitions
interface Ref : (Type -> Type) -> (Type -> Type) -> Type
  Parameters: m, r
Constraints: Monad m
Methods:
  
newRef : a -> m (r a)
  
readRef : r a -> m a
  
writeRef : r a -> a -> m ()
  
modifyRef : (a -> a) -> r a -> m a
  Updates a value and returns the previous value

Implementations:
  
HasIO io => Ref io IORef
  
Ref (ST s) (STRef s)
newRef : Ref m r => a -> m (r a)
  Totality: total
  Visibility: public export
readRef : Ref m r => r a -> m a
  Totality: total
  Visibility: public export
writeRef : Ref m r => r a -> a -> m ()
  Totality: total
  Visibility: public export
modifyRef : Ref m r => (a -> a) -> r a -> m a
  Updates a value and returns the previous value

  Totality: total
  Visibility: public export
modifyRef_ : Ref m r => (a -> a) -> r a -> m ()
  Totality: total
  Visibility: public export
ForRef : Ref m r => Monad m => r a -> MonadState a m
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Ref(source)
Reexports
import public Data.IORef
import public Control.Monad.ST
Definitions
interface Ref : (Type -> Type) -> (Type -> Type) -> Type
  Parameters: m, r
Constraints: Monad m
Methods:
  
newRef : a -> m (r a)
  
readRef : r a -> m a
  
writeRef : r a -> a -> m ()
  
modifyRef : (a -> a) -> r a -> m a
  Updates a value and returns the previous value

Implementations:
  
HasIO io => Ref io IORef
  
Ref (ST s) (STRef s)
newRef : Ref m r => a -> m (r a)
  Totality: total
  Visibility: public export
readRef : Ref m r => r a -> m a
  Totality: total
  Visibility: public export
writeRef : Ref m r => r a -> a -> m ()
  Totality: total
  Visibility: public export
modifyRef : Ref m r => (a -> a) -> r a -> m a
  Updates a value and returns the previous value

  Totality: total
  Visibility: public export
modifyRef_ : Ref m r => (a -> a) -> r a -> m ()
  Totality: total
  Visibility: public export
ForRef : Ref m r => Monad m => r a -> MonadState a m
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.Rel.html b/base/docs/Data.Rel.html
index 653a7c1041..d068846f38 100644
--- a/base/docs/Data.Rel.html
+++ b/base/docs/Data.Rel.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Rel(source)
Definitions
Rel : Vect n Type -> Type
  Build an n-ary relation type from a Vect of Types

  Totality: total
  Visibility: public export
All : (ts : Vect n Type) -> Rel ts -> Type
  Universal quantification of a n-ary Relation over its
  arguments to build a (function) type from a `Rel` type
  
  ```
  λ> All [Nat,Nat] LTE
  (x : Nat) -> (x : Nat) -> LTE x x
  ```

  Totality: total
  Visibility: public export
Ex : (ts : Vect n Type) -> Rel ts -> Type
  Existential quantification of a n-ary relation over its
  arguments to build a dependent pair (eg. Sigma type).
  
  Given a (type of) relation `p : [t_1, t_2 ... t_n] x r` where `t_i` and `r` are
  types, `Ex` builds the type `Σ (x_1 : t_1). Σ (x_2 : t_2) ... . r`
  For example:
  ```
  λ> Ex [Nat,Nat] LTE
  (x : Nat ** (x : Nat ** LTE x x))
  ```
  Which is the type of a pair of natural numbers along with a proof that the first
  is smaller or equal than the second.

  Totality: total
  Visibility: public export
liftRel : (ts : Vect n Type) -> Rel ts -> (Type -> Type) -> Type
  Map a type-level function over the co-domain of a n-ary Relation

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Rel(source)
Definitions
Rel : Vect n Type -> Type
  Build an n-ary relation type from a Vect of Types

  Totality: total
  Visibility: public export
All : (ts : Vect n Type) -> Rel ts -> Type
  Universal quantification of a n-ary Relation over its
  arguments to build a (function) type from a `Rel` type
  
  ```
  λ> All [Nat,Nat] LTE
  (x : Nat) -> (x : Nat) -> LTE x x
  ```

  Totality: total
  Visibility: public export
Ex : (ts : Vect n Type) -> Rel ts -> Type
  Existential quantification of a n-ary relation over its
  arguments to build a dependent pair (eg. Sigma type).
  
  Given a (type of) relation `p : [t_1, t_2 ... t_n] x r` where `t_i` and `r` are
  types, `Ex` builds the type `Σ (x_1 : t_1). Σ (x_2 : t_2) ... . r`
  For example:
  ```
  λ> Ex [Nat,Nat] LTE
  (x : Nat ** (x : Nat ** LTE x x))
  ```
  Which is the type of a pair of natural numbers along with a proof that the first
  is smaller or equal than the second.

  Totality: total
  Visibility: public export
liftRel : (ts : Vect n Type) -> Rel ts -> (Type -> Type) -> Type
  Map a type-level function over the co-domain of a n-ary Relation

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Singleton.html b/base/docs/Data.Singleton.html
index 09ee014fa8..f768ca7d34 100644
--- a/base/docs/Data.Singleton.html
+++ b/base/docs/Data.Singleton.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Singleton(source)
Definitions
data Singleton : a -> Type
  The type containing only a particular value.
  This is useful for calculating type-level information at runtime.

  Totality: total
  Visibility: public export
  Constructor: 
Val : (x : a) -> Singleton x
unVal : Singleton x -> a
  Visibility: public export
.unVal : Singleton x -> a
  Visibility: public export
pure : (x : a) -> Singleton x
  Visibility: public export
(<*>) : Singleton f -> Singleton x -> Singleton (f x)
  Visibility: public export
  Fixity Declaration: infixl operator, level 3

\ No newline at end of file
+
Data.Singleton(source)
Definitions
data Singleton : a -> Type
  The type containing only a particular value.
  This is useful for calculating type-level information at runtime.

  Totality: total
  Visibility: public export
  Constructor: 
Val : (x : a) -> Singleton x
unVal : Singleton x -> a
  Visibility: public export
.unVal : Singleton x -> a
  Visibility: public export
pure : (x : a) -> Singleton x
  Visibility: public export
(<*>) : Singleton f -> Singleton x -> Singleton (f x)
  Visibility: public export
  Fixity Declaration: infixl operator, level 3

\ No newline at end of file
diff --git a/base/docs/Data.SnocList.Elem.html b/base/docs/Data.SnocList.Elem.html
index 31e6fb529e..583452c33a 100644
--- a/base/docs/Data.SnocList.Elem.html
+++ b/base/docs/Data.SnocList.Elem.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.SnocList.Elem(source)
Definitions
data Elem : a -> SnocList a -> Type
  A proof that some element is found in a list.

  Totality: total
  Visibility: public export
  Constructors:
  
Here : Elem x (sx :< x)
  A proof that the element is at the head of the list
  
There : Elem x sx -> Elem x (sx :< y)
  A proof that the element is in the tail of the list

  Hints:
  
DecEq (Elem x sx)
  
Injective There
  
Uninhabited (Here = There e)
  
Uninhabited (There e = Here)
  
Uninhabited (Elem x [<])
neitherHereNorThere : Not (x = y) -> Not (Elem x sx) -> Not (Elem x (sx :< y))
  An item not in the head and not in the tail is not in the list at all.

  Visibility: public export
isElem : DecEq a => (x : a) -> (sx : SnocList a) -> Dec (Elem x sx)
  Check whether the given element is a member of the given list.

  Visibility: public export
get : (sx : SnocList a) -> Elem x sx -> a
  Get the element at the given position.

  Visibility: public export
lookup : (sx : SnocList a) -> Elem x sx -> Singleton x
  Get the element at the given position, with proof that it is the desired element.

  Visibility: public export
dropElem : (sx : SnocList a) -> Elem x sx -> SnocList a
  Remove the element at the given position.

  Visibility: public export
elemToNat : Elem x sx -> Nat
  Erase the indices, returning the numeric position of the element

  Visibility: public export
indexElem : Nat -> (sx : SnocList a) -> Maybe (x : a ** Elem x sx)
  Find the element with a proof at a given position (in reverse), if it is valid

  Visibility: public export
elemMap : (0 f : (a -> b)) -> Elem x sx -> Elem (f x) (map f sx)
  Lift the membership proof to a mapped list

  Visibility: export

\ No newline at end of file
+
Data.SnocList.Elem(source)
Definitions
data Elem : a -> SnocList a -> Type
  A proof that some element is found in a list.

  Totality: total
  Visibility: public export
  Constructors:
  
Here : Elem x (sx :< x)
  A proof that the element is at the head of the list
  
There : Elem x sx -> Elem x (sx :< y)
  A proof that the element is in the tail of the list

  Hints:
  
DecEq (Elem x sx)
  
Injective There
  
Uninhabited (Here = There e)
  
Uninhabited (There e = Here)
  
Uninhabited (Elem x [<])
neitherHereNorThere : Not (x = y) -> Not (Elem x sx) -> Not (Elem x (sx :< y))
  An item not in the head and not in the tail is not in the list at all.

  Visibility: public export
isElem : DecEq a => (x : a) -> (sx : SnocList a) -> Dec (Elem x sx)
  Check whether the given element is a member of the given list.

  Visibility: public export
get : (sx : SnocList a) -> Elem x sx -> a
  Get the element at the given position.

  Visibility: public export
lookup : (sx : SnocList a) -> Elem x sx -> Singleton x
  Get the element at the given position, with proof that it is the desired element.

  Visibility: public export
dropElem : (sx : SnocList a) -> Elem x sx -> SnocList a
  Remove the element at the given position.

  Visibility: public export
elemToNat : Elem x sx -> Nat
  Erase the indices, returning the numeric position of the element

  Visibility: public export
indexElem : Nat -> (sx : SnocList a) -> Maybe (x : a ** Elem x sx)
  Find the element with a proof at a given position (in reverse), if it is valid

  Visibility: public export
elemMap : (0 f : (a -> b)) -> Elem x sx -> Elem (f x) (map f sx)
  Lift the membership proof to a mapped list

  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.SnocList.Operations.html b/base/docs/Data.SnocList.Operations.html
index 005e242b7f..6be74c704e 100644
--- a/base/docs/Data.SnocList.Operations.html
+++ b/base/docs/Data.SnocList.Operations.html
@@ -64,4 +64,4 @@
 
Data.SnocList.Operations(source)
Operations on `SnocList`s, analogous to the `List` ones.
 Depending on your style of programming, these might cause
 ambiguities, so import with care
-
Definitions
takeTail : Nat -> SnocList a -> SnocList a
  Take `n` last elements from `sx`, returning the whole list if
  `n` >= length `sx`.
  
  @ n  the number of elements to take
  @ sx the snoc-list to take the elements from

  Totality: total
  Visibility: public export
dropTail : Nat -> SnocList a -> SnocList a
  Remove `n` last elements from `xs`, returning the empty list if
  `n >= length xs`
  
  @ n  the number of elements to remove
  @ xs the list to drop the elements from

  Totality: total
  Visibility: public export
concatDropTailTakeTail : (n : Nat) -> (sx : SnocList a) -> dropTail n sx ++ takeTail n sx = sx
  Totality: total
  Visibility: public export
splitOntoLeft : Nat -> SnocList a -> List a -> (SnocList a, List a)
  Shift `n` elements from the beginning of `xs` to the end of `sx`,
  returning the same lists if `n` >= length `xs`.
  
  @ n  the number of elements to take
  @ sx the snoc-list to append onto
  @ xs the list to take the elements from

  Totality: total
  Visibility: public export
splitOntoRight : Nat -> SnocList a -> List a -> (SnocList a, List a)
  Shift `n` elements from the end of `sx` to the beginning of `xs`,
  returning the same lists if `n` >= length `sx`.
  
  @ n  the number of elements to take
  @ sx the snoc-list to take the elements from
  @ xs the list to append onto

  Totality: total
  Visibility: public export
splitOntoRightInvariant : (n : Nat) -> (sx : SnocList a) -> (xs : List a) -> fst (splitOntoRight n sx xs) <>< snd (splitOntoRight n sx xs) = sx <>< xs
  Totality: total
  Visibility: export
splitOntoRightSpec : (n : Nat) -> (sx : SnocList a) -> (xs : List a) -> (fst (splitOntoRight n sx xs) = dropTail n sx, snd (splitOntoRight n sx xs) = takeTail n sx <>> xs)
  Totality: total
  Visibility: export
splitOntoLeftSpec : (n : Nat) -> (sx : SnocList a) -> (xs : List a) -> (fst (splitOntoLeft n sx xs) = sx <>< take n xs, snd (splitOntoLeft n sx xs) = drop n xs)
  Totality: total
  Visibility: export
lengthHomomorphism : (sx : SnocList a) -> (sy : SnocList a) -> length (sx ++ sy) = length sx + length sy
  Totality: total
  Visibility: export
take : Nat -> SnocList a -> SnocList a
  Take `n` first elements from `sx`, returning the whole list if
  `n` >= length `sx`.
  
  @ n  the number of elements to take
  @ sx the snoc-list to take the elements from
  
  Note: traverses the whole the input list, so linear in `n` and
  `length sx`

  Totality: total
  Visibility: public export
drop : Nat -> SnocList a -> SnocList a
  Drop `n` first elements from `sx`, returning an empty list if
  `n` >= length `sx`.
  
  @ n  the number of elements to drop
  @ sx the snoc-list to drop the elements from
  
  Note: traverses the whole the input list, so linear in `n` and
  `length sx`

  Totality: total
  Visibility: public export
data NonEmpty : SnocList a -> Type
  Totality: total
  Visibility: public export
  Constructor: 
IsSnoc : NonEmpty (sx :< x)
last : (sx : SnocList a) -> {auto 0 _ : NonEmpty sx} -> a
  Totality: total
  Visibility: public export
intersectBy : (a -> a -> Bool) -> SnocList a -> SnocList a -> SnocList a
  Totality: total
  Visibility: public export
intersect : Eq a => SnocList a -> SnocList a -> SnocList a
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
takeTail : Nat -> SnocList a -> SnocList a
  Take `n` last elements from `sx`, returning the whole list if
  `n` >= length `sx`.
  
  @ n  the number of elements to take
  @ sx the snoc-list to take the elements from

  Totality: total
  Visibility: public export
dropTail : Nat -> SnocList a -> SnocList a
  Remove `n` last elements from `xs`, returning the empty list if
  `n >= length xs`
  
  @ n  the number of elements to remove
  @ xs the list to drop the elements from

  Totality: total
  Visibility: public export
concatDropTailTakeTail : (n : Nat) -> (sx : SnocList a) -> dropTail n sx ++ takeTail n sx = sx
  Totality: total
  Visibility: public export
splitOntoLeft : Nat -> SnocList a -> List a -> (SnocList a, List a)
  Shift `n` elements from the beginning of `xs` to the end of `sx`,
  returning the same lists if `n` >= length `xs`.
  
  @ n  the number of elements to take
  @ sx the snoc-list to append onto
  @ xs the list to take the elements from

  Totality: total
  Visibility: public export
splitOntoRight : Nat -> SnocList a -> List a -> (SnocList a, List a)
  Shift `n` elements from the end of `sx` to the beginning of `xs`,
  returning the same lists if `n` >= length `sx`.
  
  @ n  the number of elements to take
  @ sx the snoc-list to take the elements from
  @ xs the list to append onto

  Totality: total
  Visibility: public export
splitOntoRightInvariant : (n : Nat) -> (sx : SnocList a) -> (xs : List a) -> fst (splitOntoRight n sx xs) <>< snd (splitOntoRight n sx xs) = sx <>< xs
  Totality: total
  Visibility: export
splitOntoRightSpec : (n : Nat) -> (sx : SnocList a) -> (xs : List a) -> (fst (splitOntoRight n sx xs) = dropTail n sx, snd (splitOntoRight n sx xs) = takeTail n sx <>> xs)
  Totality: total
  Visibility: export
splitOntoLeftSpec : (n : Nat) -> (sx : SnocList a) -> (xs : List a) -> (fst (splitOntoLeft n sx xs) = sx <>< take n xs, snd (splitOntoLeft n sx xs) = drop n xs)
  Totality: total
  Visibility: export
lengthHomomorphism : (sx : SnocList a) -> (sy : SnocList a) -> length (sx ++ sy) = length sx + length sy
  Totality: total
  Visibility: export
take : Nat -> SnocList a -> SnocList a
  Take `n` first elements from `sx`, returning the whole list if
  `n` >= length `sx`.
  
  @ n  the number of elements to take
  @ sx the snoc-list to take the elements from
  
  Note: traverses the whole the input list, so linear in `n` and
  `length sx`

  Totality: total
  Visibility: public export
drop : Nat -> SnocList a -> SnocList a
  Drop `n` first elements from `sx`, returning an empty list if
  `n` >= length `sx`.
  
  @ n  the number of elements to drop
  @ sx the snoc-list to drop the elements from
  
  Note: traverses the whole the input list, so linear in `n` and
  `length sx`

  Totality: total
  Visibility: public export
data NonEmpty : SnocList a -> Type
  Totality: total
  Visibility: public export
  Constructor: 
IsSnoc : NonEmpty (sx :< x)
last : (sx : SnocList a) -> {auto 0 _ : NonEmpty sx} -> a
  Totality: total
  Visibility: public export
intersectBy : (a -> a -> Bool) -> SnocList a -> SnocList a -> SnocList a
  Totality: total
  Visibility: public export
intersect : Eq a => SnocList a -> SnocList a -> SnocList a
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.SnocList.Quantifiers.html b/base/docs/Data.SnocList.Quantifiers.html
index 5a8a2ac3e1..fd9fbcc0d1 100644
--- a/base/docs/Data.SnocList.Quantifiers.html
+++ b/base/docs/Data.SnocList.Quantifiers.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.SnocList.Quantifiers(source)
Definitions
data Any : (0 _ : (a -> Type)) -> SnocList a -> Type
  A proof that some element of a snoclist satisfies some property
  
  @ p the property to be satisfied

  Totality: total
  Visibility: public export
  Constructors:
  
Here : p x -> Any p (xs :< x)
  A proof that the rightmost element in the `SnocList` satisfies p
  
There : Any p xs -> Any p (xs :< x)
  A proof that there is an element the tail of the `SnocList` satisfying p

  Hints:
  
Uninhabited (Any p [<])
  
Uninhabited (p x) => Uninhabited (Any p xs) => Uninhabited (Any p (xs :< x))
mapProperty : (p x -> q x) -> Any p l -> Any q l
  Modify the property given a pointwise function

  Totality: total
  Visibility: public export
any : ((x : a) -> Dec (p x)) -> (xs : SnocList a) -> Dec (Any p xs)
  Given a decision procedure for a property, determine if an element of a
  list satisfies it.
  
  @ p the property to be satisfied
  @ dec the decision procedure
  @ xs the list to examine

  Totality: total
  Visibility: public export
toExists : Any p xs -> Exists p
  Forget the membership proof

  Totality: total
  Visibility: export
data All : (0 _ : (a -> Type)) -> SnocList a -> Type
  A proof that all elements of a list satisfy a property. It is a list of
  proofs, corresponding element-wise to the `List`.

  Totality: total
  Visibility: public export
  Constructors:
  
Lin : All p [<]
  
(:<) : All p xs -> p x -> All p (xs :< x)

  Hints:
  
All Show (map p xs) => Show (All p xs)
  
Either (Uninhabited (p x)) (Uninhabited (All p xs)) => Uninhabited (All p (xs :< x))
length : All p xs -> Nat
  Totality: total
  Visibility: public export
(++) : All p xs -> All p ys -> All p (xs ++ ys)
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
lengthUnfold : (pxs : All p xs) -> length pxs = length xs
  Totality: total
  Visibility: export
mapProperty : (p x -> q x) -> All p l -> All q l
  Modify the property given a pointwise function

  Totality: total
  Visibility: public export
imapProperty : (0 i : (Type -> Type)) -> (i a => p a -> q a) -> All i types => All p types -> All q types
  Modify the property given a pointwise interface function

  Totality: total
  Visibility: public export
forget : All (const type) types -> SnocList type
  Forget property source for a homogeneous collection of properties

  Totality: total
  Visibility: public export
all : ((x : a) -> Dec (p x)) -> (xs : SnocList a) -> Dec (All p xs)
  Given a decision procedure for a property, decide whether all elements of
  a list satisfy it.
  
  @ p the property
  @ dec the decision procedure
  @ xs the list to examine

  Totality: total
  Visibility: public export
zipPropertyWith : (p x -> q x -> r x) -> All p xs -> All q xs -> All r xs
  Totality: total
  Visibility: export
negAnyAll : Not (Any p xs) -> All (Not . p) xs
  If there does not exist an element that satifies the property, then it is
  the case that all elements do not satisfy it.

  Totality: total
  Visibility: export
anyNegAll : Any (Not . p) xs -> Not (All p xs)
  If there exists an element that doesn't satify the property, then it is
  not the case that all elements satisfy it.

  Totality: total
  Visibility: export
allNegAny : All (Not . p) xs -> Not (Any p xs)
  If none of the elements satisfy the property, then not any single one can.

  Totality: total
  Visibility: export
indexAll : Elem x xs -> All p xs -> p x
  Given a proof of membership for some element, extract the property proof for it

  Totality: total
  Visibility: public export
decide : ((x : a) -> Either (p x) (q x)) -> (xs : SnocList a) -> Either (All p xs) (Any q xs)
  If any `a` either satisfies p or q then given a Snoclist of as,
  either all values satisfy p
  or at least one of them sastifies q

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.SnocList.Quantifiers(source)
Definitions
data Any : (0 _ : (a -> Type)) -> SnocList a -> Type
  A proof that some element of a snoclist satisfies some property
  
  @ p the property to be satisfied

  Totality: total
  Visibility: public export
  Constructors:
  
Here : p x -> Any p (xs :< x)
  A proof that the rightmost element in the `SnocList` satisfies p
  
There : Any p xs -> Any p (xs :< x)
  A proof that there is an element the tail of the `SnocList` satisfying p

  Hints:
  
Uninhabited (Any p [<])
  
Uninhabited (p x) => Uninhabited (Any p xs) => Uninhabited (Any p (xs :< x))
mapProperty : (p x -> q x) -> Any p l -> Any q l
  Modify the property given a pointwise function

  Totality: total
  Visibility: public export
any : ((x : a) -> Dec (p x)) -> (xs : SnocList a) -> Dec (Any p xs)
  Given a decision procedure for a property, determine if an element of a
  list satisfies it.
  
  @ p the property to be satisfied
  @ dec the decision procedure
  @ xs the list to examine

  Totality: total
  Visibility: public export
toExists : Any p xs -> Exists p
  Forget the membership proof

  Totality: total
  Visibility: export
data All : (0 _ : (a -> Type)) -> SnocList a -> Type
  A proof that all elements of a list satisfy a property. It is a list of
  proofs, corresponding element-wise to the `List`.

  Totality: total
  Visibility: public export
  Constructors:
  
Lin : All p [<]
  
(:<) : All p xs -> p x -> All p (xs :< x)

  Hints:
  
All Show (map p xs) => Show (All p xs)
  
Either (Uninhabited (p x)) (Uninhabited (All p xs)) => Uninhabited (All p (xs :< x))
length : All p xs -> Nat
  Totality: total
  Visibility: public export
(++) : All p xs -> All p ys -> All p (xs ++ ys)
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
lengthUnfold : (pxs : All p xs) -> length pxs = length xs
  Totality: total
  Visibility: export
mapProperty : (p x -> q x) -> All p l -> All q l
  Modify the property given a pointwise function

  Totality: total
  Visibility: public export
imapProperty : (0 i : (Type -> Type)) -> (i a => p a -> q a) -> All i types => All p types -> All q types
  Modify the property given a pointwise interface function

  Totality: total
  Visibility: public export
forget : All (const type) types -> SnocList type
  Forget property source for a homogeneous collection of properties

  Totality: total
  Visibility: public export
all : ((x : a) -> Dec (p x)) -> (xs : SnocList a) -> Dec (All p xs)
  Given a decision procedure for a property, decide whether all elements of
  a list satisfy it.
  
  @ p the property
  @ dec the decision procedure
  @ xs the list to examine

  Totality: total
  Visibility: public export
zipPropertyWith : (p x -> q x -> r x) -> All p xs -> All q xs -> All r xs
  Totality: total
  Visibility: export
negAnyAll : Not (Any p xs) -> All (Not . p) xs
  If there does not exist an element that satifies the property, then it is
  the case that all elements do not satisfy it.

  Totality: total
  Visibility: export
anyNegAll : Any (Not . p) xs -> Not (All p xs)
  If there exists an element that doesn't satify the property, then it is
  not the case that all elements satisfy it.

  Totality: total
  Visibility: export
allNegAny : All (Not . p) xs -> Not (Any p xs)
  If none of the elements satisfy the property, then not any single one can.

  Totality: total
  Visibility: export
indexAll : Elem x xs -> All p xs -> p x
  Given a proof of membership for some element, extract the property proof for it

  Totality: total
  Visibility: public export
decide : ((x : a) -> Either (p x) (q x)) -> (xs : SnocList a) -> Either (All p xs) (Any q xs)
  If any `a` either satisfies p or q then given a Snoclist of as,
  either all values satisfy p
  or at least one of them sastifies q

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.SnocList.html b/base/docs/Data.SnocList.html
index 96c3585446..89603728aa 100644
--- a/base/docs/Data.SnocList.html
+++ b/base/docs/Data.SnocList.html
@@ -62,4 +62,4 @@
 
 
 
Data.SnocList(source)
A Reversed List
-
Definitions
asList : SnocList type -> List type
  Transform to a list but keeping the contents in the spine order (term depth).

  Totality: total
  Visibility: public export
isLin : SnocList a -> Bool
  True iff input is Lin

  Totality: total
  Visibility: public export
isSnoc : SnocList a -> Bool
  True iff input is (:<)

  Totality: total
  Visibility: public export
spanBy : (a -> Maybe b) -> SnocList a -> (SnocList a, SnocList b)
  Given a predicate and a snoclist, returns a tuple consisting of the longest
  prefix of the snoclist whose elements satisfy the predicate, and the rest of the
  snoclist.

  Totality: total
  Visibility: public export
mapImpl : (a -> b) -> SnocList a -> SnocList b
  Totality: total
  Visibility: public export
SnocBiinjective : Biinjective (:<)
  Totality: total
  Visibility: export
find : (a -> Bool) -> SnocList a -> Maybe a
  Find the rightmost element of the snoc-list that satisfies the predicate.

  Totality: total
  Visibility: public export
data InBounds : Nat -> SnocList a -> Type
  Satisfiable if `k` is a valid index into `xs`.
  
  @ k  the potential index
  @ xs the snoc-list into which k may be an index

  Totality: total
  Visibility: public export
  Constructors:
  
InFirst : InBounds 0 (xs :< x)
  Z is a valid index into any cons cell
  
InLater : InBounds k xs -> InBounds (S k) (xs :< x)
  Valid indices can be extended
findIndex : (a -> Bool) -> (xs : SnocList a) -> Maybe (Fin (length xs))
  Find the index (counting from right) of the rightmost element (if exists) of a
  snoc-list that satisfies the given test, else `Nothing`.

  Totality: total
  Visibility: public export
appendAssociative : (l : SnocList a) -> (c : SnocList a) -> (r : SnocList a) -> l ++ (c ++ r) = (l ++ c) ++ r
  Totality: total
  Visibility: export
appendLinLeftNeutral : (sx : SnocList a) -> [<] ++ sx = sx
  Totality: total
  Visibility: export
fishAsSnocAppend : (xs : SnocList a) -> (ys : List a) -> xs <>< ys = xs ++ cast ys
  Totality: total
  Visibility: export
chipsAsListAppend : (xs : SnocList a) -> (ys : List a) -> xs <>> ys = cast xs ++ ys
  Totality: total
  Visibility: export
toListAppend : (sx : SnocList a) -> (sy : SnocList a) -> toList (sx ++ sy) = toList sx ++ toList sy
  Totality: total
  Visibility: export
castListAppend : (xs : List a) -> (ys : List a) -> cast (xs ++ ys) = cast xs ++ cast ys
  Totality: total
  Visibility: export
castToList : (sx : SnocList a) -> cast (toList sx) = sx
  Totality: total
  Visibility: export
toListCast : (xs : List a) -> toList (cast xs) = xs
  Totality: total
  Visibility: export
cons : a -> SnocList a -> SnocList a
  Append an element to the head of a snoc-list.
  Note: Traverses the snoc-list, linear time complexity

  Totality: total
  Visibility: public export
foldAppend : (f : (acc -> a -> acc)) -> (init : acc) -> (sx : SnocList a) -> (sy : SnocList a) -> foldl f init (sx ++ sy) = foldl f (foldl f init sx) sy
  Totality: total
  Visibility: export
snocFoldlAsListFoldl : (f : (acc -> a -> acc)) -> (init : acc) -> (xs : SnocList a) -> foldl f init xs = foldl f init (toList xs)
  Totality: total
  Visibility: export
filterAppend : (f : (a -> Bool)) -> (sx : SnocList a) -> (sy : SnocList a) -> filter f (sx ++ sy) = filter f sx ++ filter f sy
  Totality: total
  Visibility: export
toListFilter : (f : (a -> Bool)) -> (sx : SnocList a) -> toList (filter f sx) = filter f (toList sx)
  Totality: total
  Visibility: export
filterCast : (f : (a -> Bool)) -> (xs : List a) -> filter f (cast xs) = cast (filter f xs)
  Totality: total
  Visibility: export
mapFusion : (g : (b -> c)) -> (f : (a -> b)) -> (sx : SnocList a) -> map g (map f sx) = map (g . f) sx
  Totality: total
  Visibility: export
mapAppend : (f : (a -> b)) -> (sx : SnocList a) -> (sy : SnocList a) -> map f (sx ++ sy) = map f sx ++ map f sy
  Totality: total
  Visibility: export
toListMap : (f : (a -> b)) -> (sx : SnocList a) -> toList (map f sx) = map f (toList sx)
  Totality: total
  Visibility: export
mapCast : (f : (a -> b)) -> (xs : List a) -> map f (cast xs) = cast (map f xs)
  Totality: total
  Visibility: export
mapMaybeFusion : (g : (b -> Maybe c)) -> (f : (a -> Maybe b)) -> (sx : SnocList a) -> mapMaybe g (mapMaybe f sx) = mapMaybe (f >=> g) sx
  Totality: total
  Visibility: export
mapMaybeAppend : (f : (a -> Maybe b)) -> (sx : SnocList a) -> (sy : SnocList a) -> mapMaybe f (sx ++ sy) = mapMaybe f sx ++ mapMaybe f sy
  Totality: total
  Visibility: export
toListMapMaybe : (f : (a -> Maybe b)) -> (sx : SnocList a) -> toList (mapMaybe f sx) = mapMaybe f (toList sx)
  Totality: total
  Visibility: export
mapMaybeCast : (f : (a -> Maybe b)) -> (xs : List a) -> mapMaybe f (cast xs) = cast (mapMaybe f xs)
  Totality: total
  Visibility: export
reverseInvolutive : (sx : SnocList a) -> reverse (reverse sx) = sx
  SnocList `reverse` applied twice yields the identity function.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
asList : SnocList type -> List type
  Transform to a list but keeping the contents in the spine order (term depth).

  Totality: total
  Visibility: public export
isLin : SnocList a -> Bool
  True iff input is Lin

  Totality: total
  Visibility: public export
isSnoc : SnocList a -> Bool
  True iff input is (:<)

  Totality: total
  Visibility: public export
spanBy : (a -> Maybe b) -> SnocList a -> (SnocList a, SnocList b)
  Given a predicate and a snoclist, returns a tuple consisting of the longest
  prefix of the snoclist whose elements satisfy the predicate, and the rest of the
  snoclist.

  Totality: total
  Visibility: public export
mapImpl : (a -> b) -> SnocList a -> SnocList b
  Totality: total
  Visibility: public export
SnocBiinjective : Biinjective (:<)
  Totality: total
  Visibility: export
find : (a -> Bool) -> SnocList a -> Maybe a
  Find the rightmost element of the snoc-list that satisfies the predicate.

  Totality: total
  Visibility: public export
data InBounds : Nat -> SnocList a -> Type
  Satisfiable if `k` is a valid index into `xs`.
  
  @ k  the potential index
  @ xs the snoc-list into which k may be an index

  Totality: total
  Visibility: public export
  Constructors:
  
InFirst : InBounds 0 (xs :< x)
  Z is a valid index into any cons cell
  
InLater : InBounds k xs -> InBounds (S k) (xs :< x)
  Valid indices can be extended
findIndex : (a -> Bool) -> (xs : SnocList a) -> Maybe (Fin (length xs))
  Find the index (counting from right) of the rightmost element (if exists) of a
  snoc-list that satisfies the given test, else `Nothing`.

  Totality: total
  Visibility: public export
appendAssociative : (l : SnocList a) -> (c : SnocList a) -> (r : SnocList a) -> l ++ (c ++ r) = (l ++ c) ++ r
  Totality: total
  Visibility: export
appendLinLeftNeutral : (sx : SnocList a) -> [<] ++ sx = sx
  Totality: total
  Visibility: export
fishAsSnocAppend : (xs : SnocList a) -> (ys : List a) -> xs <>< ys = xs ++ cast ys
  Totality: total
  Visibility: export
chipsAsListAppend : (xs : SnocList a) -> (ys : List a) -> xs <>> ys = cast xs ++ ys
  Totality: total
  Visibility: export
toListAppend : (sx : SnocList a) -> (sy : SnocList a) -> toList (sx ++ sy) = toList sx ++ toList sy
  Totality: total
  Visibility: export
castListAppend : (xs : List a) -> (ys : List a) -> cast (xs ++ ys) = cast xs ++ cast ys
  Totality: total
  Visibility: export
castToList : (sx : SnocList a) -> cast (toList sx) = sx
  Totality: total
  Visibility: export
toListCast : (xs : List a) -> toList (cast xs) = xs
  Totality: total
  Visibility: export
cons : a -> SnocList a -> SnocList a
  Append an element to the head of a snoc-list.
  Note: Traverses the snoc-list, linear time complexity

  Totality: total
  Visibility: public export
foldAppend : (f : (acc -> a -> acc)) -> (init : acc) -> (sx : SnocList a) -> (sy : SnocList a) -> foldl f init (sx ++ sy) = foldl f (foldl f init sx) sy
  Totality: total
  Visibility: export
snocFoldlAsListFoldl : (f : (acc -> a -> acc)) -> (init : acc) -> (xs : SnocList a) -> foldl f init xs = foldl f init (toList xs)
  Totality: total
  Visibility: export
filterAppend : (f : (a -> Bool)) -> (sx : SnocList a) -> (sy : SnocList a) -> filter f (sx ++ sy) = filter f sx ++ filter f sy
  Totality: total
  Visibility: export
toListFilter : (f : (a -> Bool)) -> (sx : SnocList a) -> toList (filter f sx) = filter f (toList sx)
  Totality: total
  Visibility: export
filterCast : (f : (a -> Bool)) -> (xs : List a) -> filter f (cast xs) = cast (filter f xs)
  Totality: total
  Visibility: export
mapFusion : (g : (b -> c)) -> (f : (a -> b)) -> (sx : SnocList a) -> map g (map f sx) = map (g . f) sx
  Totality: total
  Visibility: export
mapAppend : (f : (a -> b)) -> (sx : SnocList a) -> (sy : SnocList a) -> map f (sx ++ sy) = map f sx ++ map f sy
  Totality: total
  Visibility: export
toListMap : (f : (a -> b)) -> (sx : SnocList a) -> toList (map f sx) = map f (toList sx)
  Totality: total
  Visibility: export
mapCast : (f : (a -> b)) -> (xs : List a) -> map f (cast xs) = cast (map f xs)
  Totality: total
  Visibility: export
mapMaybeFusion : (g : (b -> Maybe c)) -> (f : (a -> Maybe b)) -> (sx : SnocList a) -> mapMaybe g (mapMaybe f sx) = mapMaybe (f >=> g) sx
  Totality: total
  Visibility: export
mapMaybeAppend : (f : (a -> Maybe b)) -> (sx : SnocList a) -> (sy : SnocList a) -> mapMaybe f (sx ++ sy) = mapMaybe f sx ++ mapMaybe f sy
  Totality: total
  Visibility: export
toListMapMaybe : (f : (a -> Maybe b)) -> (sx : SnocList a) -> toList (mapMaybe f sx) = mapMaybe f (toList sx)
  Totality: total
  Visibility: export
mapMaybeCast : (f : (a -> Maybe b)) -> (xs : List a) -> mapMaybe f (cast xs) = cast (mapMaybe f xs)
  Totality: total
  Visibility: export
reverseInvolutive : (sx : SnocList a) -> reverse (reverse sx) = sx
  SnocList `reverse` applied twice yields the identity function.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.So.html b/base/docs/Data.So.html
index 17050a3702..105ef221b5 100644
--- a/base/docs/Data.So.html
+++ b/base/docs/Data.So.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.So(source)
Definitions
data So : Bool -> Type
  Ensure that some run-time Boolean test has been performed.
  
  This lifts a Boolean predicate to the type level. See the function `choose`
  if you need to perform a Boolean test and convince the type checker of this
  fact.
  
  If you find yourself using `So` for something other than primitive types,
  it may be appropriate to define a type of evidence for the property that you
  care about instead.

  Totality: total
  Visibility: public export
  Constructor: 
Oh : So True

  Hint: 
Uninhabited (So False)
choose : (b : Bool) -> Either (So b) (So (not b))
  Perform a case analysis on a Boolean, providing clients with a `So` proof

  Totality: total
  Visibility: export
decSo : (b : Bool) -> Dec (So b)
  Totality: total
  Visibility: export
eqToSo : b = True -> So b
  Totality: total
  Visibility: export
soToEq : So b -> b = True
  Totality: total
  Visibility: export
soToNotSoNot : So b -> Not (So (not b))
  If `b` is True, `not b` can't be True

  Totality: total
  Visibility: export
soNotToNotSo : So (not b) -> Not (So b)
  If `not b` is True, `b` can't be True

  Totality: total
  Visibility: export
soAnd : So (a && b) -> (So a, So (Force b))
  Totality: total
  Visibility: export
andSo : (So a, So b) -> So (a && Delay b)
  Totality: total
  Visibility: export
soOr : So (a || b) -> Either (So a) (So (Force b))
  Totality: total
  Visibility: export
orSo : Either (So a) (So b) -> So (a || Delay b)
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.So(source)
Definitions
data So : Bool -> Type
  Ensure that some run-time Boolean test has been performed.
  
  This lifts a Boolean predicate to the type level. See the function `choose`
  if you need to perform a Boolean test and convince the type checker of this
  fact.
  
  If you find yourself using `So` for something other than primitive types,
  it may be appropriate to define a type of evidence for the property that you
  care about instead.

  Totality: total
  Visibility: public export
  Constructor: 
Oh : So True

  Hint: 
Uninhabited (So False)
choose : (b : Bool) -> Either (So b) (So (not b))
  Perform a case analysis on a Boolean, providing clients with a `So` proof

  Totality: total
  Visibility: export
decSo : (b : Bool) -> Dec (So b)
  Totality: total
  Visibility: export
eqToSo : b = True -> So b
  Totality: total
  Visibility: export
soToEq : So b -> b = True
  Totality: total
  Visibility: export
soToNotSoNot : So b -> Not (So (not b))
  If `b` is True, `not b` can't be True

  Totality: total
  Visibility: export
soNotToNotSo : So (not b) -> Not (So b)
  If `not b` is True, `b` can't be True

  Totality: total
  Visibility: export
soAnd : So (a && b) -> (So a, So (Force b))
  Totality: total
  Visibility: export
andSo : (So a, So b) -> So (a && Delay b)
  Totality: total
  Visibility: export
soOr : So (a || b) -> Either (So a) (So (Force b))
  Totality: total
  Visibility: export
orSo : Either (So a) (So b) -> So (a || Delay b)
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.SortedMap.Dependent.html b/base/docs/Data.SortedMap.Dependent.html
index 336c5a6617..2afd4edef3 100644
--- a/base/docs/Data.SortedMap.Dependent.html
+++ b/base/docs/Data.SortedMap.Dependent.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.SortedMap.Dependent(source)
Definitions
data SortedDMap : (k : Type) -> (k -> Type) -> Type
  Totality: total
  Visibility: export
  Constructors:
  
Empty : Ord k => SortedDMap k v
  
M : {auto o : Ord k} -> (n : Nat) -> Tree n k v o -> SortedDMap k v

  Hints:
  
Cast (SortedDMap k (const v)) (SortedMap k v)
  
Cast (SortedMap k v) (SortedDMap k (const v))
  
(DecEq k, Eq (v x)) => Eq (SortedDMap k v)
  
DecEq k => Ord k => Semigroup (v x) => Monoid (SortedDMap k v)
  
DecEq k => Semigroup (v x) => Semigroup (SortedDMap k v)
  
(Show k, Show (v x)) => Show (SortedDMap k v)
empty : Ord k => SortedDMap k v
  Visibility: export
lookup : k -> SortedDMap k v -> Maybe (y : k ** v y)
  Visibility: export
lookupPrecise : DecEq k => (x : k) -> SortedDMap k v -> Maybe (v x)
  Visibility: export
insert : (x : k) -> v x -> SortedDMap k v -> SortedDMap k v
  Visibility: export
singleton : Ord k => (x : k) -> v x -> SortedDMap k v
  Visibility: export
insertFrom : Foldable f => f (x : k ** v x) -> SortedDMap k v -> SortedDMap k v
  Visibility: export
delete : k -> SortedDMap k v -> SortedDMap k v
  Visibility: export
update : DecEq k => (x : k) -> (Maybe (v x) -> Maybe (v x)) -> SortedDMap k v -> SortedDMap k v
  Updates or deletes a value based on the decision function
  
  The decision function takes information about the presence of the value,
  and the value itself, if it is present.
  It returns a new value or the fact that there should be no value as the result.
  
  The current implementation performs up to two traversals of the original map

  Visibility: export
updateExisting : DecEq k => (x : k) -> (v x -> v x) -> SortedDMap k v -> SortedDMap k v
  Updates existing value, if it is present, and does nothing otherwise
  
  The current implementation performs up to two traversals of the original map

  Visibility: export
fromList : Ord k => List (x : k ** v x) -> SortedDMap k v
  Visibility: export
toList : SortedDMap k v -> List (x : k ** v x)
  Visibility: export
keys : SortedDMap k v -> List k
  Gets the keys of the map.

  Visibility: export
values : SortedDMap k v -> List (x : k ** v x)
  Visibility: export
map : (v x -> w x) -> SortedDMap k v -> SortedDMap k w
  Visibility: export
foldl : (acc -> (x : k ** v x) -> acc) -> acc -> SortedDMap k v -> acc
  Visibility: export
foldr : ((x : k ** v x) -> acc -> acc) -> acc -> SortedDMap k v -> acc
  Visibility: export
foldlM : Monad m => (acc -> (x : k ** v x) -> m acc) -> acc -> SortedDMap k v -> m acc
  Visibility: export
foldMap : Monoid m => ((x : k) -> v x -> m) -> SortedDMap k v -> m
  Visibility: export
null : SortedDMap k v -> Bool
  Visibility: export
traverse : Applicative f => (v x -> f (w x)) -> SortedDMap k v -> f (SortedDMap k w)
  Visibility: export
mergeWith : DecEq k => (v x -> v x -> v x) -> SortedDMap k v -> SortedDMap k v -> SortedDMap k v
  Merge two maps. When encountering duplicate keys, using a function to combine the values.
  Uses the ordering of the first map given.

  Visibility: export
merge : DecEq k => Semigroup (v x) => SortedDMap k v -> SortedDMap k v -> SortedDMap k v
  Merge two maps using the Semigroup (and by extension, Monoid) operation.
  Uses mergeWith internally, so the ordering of the left map is kept.

  Visibility: export
mergeLeft : DecEq k => SortedDMap k v -> SortedDMap k v -> SortedDMap k v
  Left-biased merge, also keeps the ordering specified  by the left map.

  Visibility: export
lookupBetween : k -> SortedDMap k v -> (Maybe (x : k ** v x), Maybe (x : k ** v x))
  looks up a key in map, returning the left and right closest values, so that
   k1 <= k < k2. If at the end of the beginning and/or end of the sorted map, returns
  nothing appropriately

  Visibility: export
leftMost : SortedDMap k v -> Maybe (x : k ** v x)
  Returns the leftmost (least) key and value

  Visibility: export
rightMost : SortedDMap k v -> Maybe (x : k ** v x)
  Returns the rightmost (greatest) key and value

  Visibility: export
strictSubmap : DecEq k => Eq (v x) => SortedDMap k v -> SortedDMap k v -> Bool
  Visibility: export

\ No newline at end of file
+
Data.SortedMap.Dependent(source)
Definitions
data SortedDMap : (k : Type) -> (k -> Type) -> Type
  Totality: total
  Visibility: export
  Constructors:
  
Empty : Ord k => SortedDMap k v
  
M : {auto o : Ord k} -> (n : Nat) -> Tree n k v o -> SortedDMap k v

  Hints:
  
Cast (SortedDMap k (const v)) (SortedMap k v)
  
Cast (SortedMap k v) (SortedDMap k (const v))
  
(DecEq k, Eq (v x)) => Eq (SortedDMap k v)
  
DecEq k => Ord k => Semigroup (v x) => Monoid (SortedDMap k v)
  
DecEq k => Semigroup (v x) => Semigroup (SortedDMap k v)
  
(Show k, Show (v x)) => Show (SortedDMap k v)
empty : Ord k => SortedDMap k v
  Visibility: export
lookup : k -> SortedDMap k v -> Maybe (y : k ** v y)
  Visibility: export
lookupPrecise : DecEq k => (x : k) -> SortedDMap k v -> Maybe (v x)
  Visibility: export
insert : (x : k) -> v x -> SortedDMap k v -> SortedDMap k v
  Visibility: export
singleton : Ord k => (x : k) -> v x -> SortedDMap k v
  Visibility: export
insertFrom : Foldable f => f (x : k ** v x) -> SortedDMap k v -> SortedDMap k v
  Visibility: export
delete : k -> SortedDMap k v -> SortedDMap k v
  Visibility: export
update : DecEq k => (x : k) -> (Maybe (v x) -> Maybe (v x)) -> SortedDMap k v -> SortedDMap k v
  Updates or deletes a value based on the decision function
  
  The decision function takes information about the presence of the value,
  and the value itself, if it is present.
  It returns a new value or the fact that there should be no value as the result.
  
  The current implementation performs up to two traversals of the original map

  Visibility: export
updateExisting : DecEq k => (x : k) -> (v x -> v x) -> SortedDMap k v -> SortedDMap k v
  Updates existing value, if it is present, and does nothing otherwise
  
  The current implementation performs up to two traversals of the original map

  Visibility: export
fromList : Ord k => List (x : k ** v x) -> SortedDMap k v
  Visibility: export
toList : SortedDMap k v -> List (x : k ** v x)
  Visibility: export
keys : SortedDMap k v -> List k
  Gets the keys of the map.

  Visibility: export
values : SortedDMap k v -> List (x : k ** v x)
  Visibility: export
map : (v x -> w x) -> SortedDMap k v -> SortedDMap k w
  Visibility: export
foldl : (acc -> (x : k ** v x) -> acc) -> acc -> SortedDMap k v -> acc
  Visibility: export
foldr : ((x : k ** v x) -> acc -> acc) -> acc -> SortedDMap k v -> acc
  Visibility: export
foldlM : Monad m => (acc -> (x : k ** v x) -> m acc) -> acc -> SortedDMap k v -> m acc
  Visibility: export
foldMap : Monoid m => ((x : k) -> v x -> m) -> SortedDMap k v -> m
  Visibility: export
null : SortedDMap k v -> Bool
  Visibility: export
traverse : Applicative f => (v x -> f (w x)) -> SortedDMap k v -> f (SortedDMap k w)
  Visibility: export
mergeWith : DecEq k => (v x -> v x -> v x) -> SortedDMap k v -> SortedDMap k v -> SortedDMap k v
  Merge two maps. When encountering duplicate keys, using a function to combine the values.
  Uses the ordering of the first map given.

  Visibility: export
merge : DecEq k => Semigroup (v x) => SortedDMap k v -> SortedDMap k v -> SortedDMap k v
  Merge two maps using the Semigroup (and by extension, Monoid) operation.
  Uses mergeWith internally, so the ordering of the left map is kept.

  Visibility: export
mergeLeft : DecEq k => SortedDMap k v -> SortedDMap k v -> SortedDMap k v
  Left-biased merge, also keeps the ordering specified  by the left map.

  Visibility: export
lookupBetween : k -> SortedDMap k v -> (Maybe (x : k ** v x), Maybe (x : k ** v x))
  looks up a key in map, returning the left and right closest values, so that
   k1 <= k < k2. If at the end of the beginning and/or end of the sorted map, returns
  nothing appropriately

  Visibility: export
leftMost : SortedDMap k v -> Maybe (x : k ** v x)
  Returns the leftmost (least) key and value

  Visibility: export
rightMost : SortedDMap k v -> Maybe (x : k ** v x)
  Returns the rightmost (greatest) key and value

  Visibility: export
strictSubmap : DecEq k => Eq (v x) => SortedDMap k v -> SortedDMap k v -> Bool
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.SortedMap.html b/base/docs/Data.SortedMap.html
index c0a87afc52..1ed039fe53 100644
--- a/base/docs/Data.SortedMap.html
+++ b/base/docs/Data.SortedMap.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.SortedMap(source)
Definitions
record SortedMap : Type -> Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
M : SortedDMap k (const v) -> SortedMap k v

  Projection: 
.unM : SortedMap k v -> SortedDMap k (const v)

  Hints:
  
Cast (SortedDMap k (const v)) (SortedMap k v)
  
Cast (SortedMap k v) (SortedDMap k (const v))
  
(Eq k, Eq v) => Eq (SortedMap k v)
  
Foldable (SortedMap k)
  
Functor (SortedMap k)
  
(Ord k, Semigroup v) => Monoid (SortedMap k v)
  
Semigroup v => Semigroup (SortedMap k v)
  
(Show k, Show v) => Show (SortedMap k v)
  
Traversable (SortedMap k)
  
Ord k => Zippable (SortedMap k)
empty : Ord k => SortedMap k v
  Visibility: export
lookup : k -> SortedMap k v -> Maybe v
  Visibility: export
insert : k -> v -> SortedMap k v -> SortedMap k v
  Visibility: export
singleton : Ord k => k -> v -> SortedMap k v
  Visibility: export
insertFrom : Foldable f => f (k, v) -> SortedMap k v -> SortedMap k v
  Visibility: export
delete : k -> SortedMap k v -> SortedMap k v
  Visibility: export
update : (Maybe v -> Maybe v) -> k -> SortedMap k v -> SortedMap k v
  Updates or deletes a value based on the decision function
  
  The decision function takes information about the presence of the value,
  and the value itself, if it is present.
  It returns a new value or the fact that there should be no value as the result.
  
  The current implementation performs up to two traversals of the original map

  Visibility: export
updateExisting : (v -> v) -> k -> SortedMap k v -> SortedMap k v
  Updates existing value, if it is present, and does nothing otherwise
  
  The current implementation performs up to two traversals of the original map

  Visibility: export
fromList : Ord k => List (k, v) -> SortedMap k v
  Visibility: export
toList : SortedMap k v -> List (k, v)
  Visibility: export
keys : SortedMap k v -> List k
  Gets the keys of the map.

  Visibility: export
values : SortedMap k v -> List v
  Gets the values of the map. Could contain duplicates.

  Visibility: export
mergeWith : (v -> v -> v) -> SortedMap k v -> SortedMap k v -> SortedMap k v
  Merge two maps. When encountering duplicate keys, using a function to combine the values.
  Uses the ordering of the first map given.

  Visibility: export
merge : Semigroup v => SortedMap k v -> SortedMap k v -> SortedMap k v
  Merge two maps using the Semigroup (and by extension, Monoid) operation.
  Uses mergeWith internally, so the ordering of the left map is kept.

  Visibility: export
mergeLeft : SortedMap k v -> SortedMap k v -> SortedMap k v
  Left-biased merge, also keeps the ordering specified  by the left map.

  Visibility: export
lookupBetween : key -> SortedMap key val -> (Maybe (key, val), Maybe (key, val))
  looks up a key in map, returning the left and right closest values, so that
   k1 <= k < k2. If at the end of the beginning and/or end of the sorted map, returns
  nothing appropriately

  Visibility: export
leftMost : SortedMap key val -> Maybe (key, val)
  Returns the leftmost (least) key and value

  Visibility: export
rightMost : SortedMap key val -> Maybe (key, val)
  Returns the rightmost (greatest) key and value

  Visibility: export

\ No newline at end of file
+
Data.SortedMap(source)
Definitions
record SortedMap : Type -> Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
M : SortedDMap k (const v) -> SortedMap k v

  Projection: 
.unM : SortedMap k v -> SortedDMap k (const v)

  Hints:
  
Cast (SortedDMap k (const v)) (SortedMap k v)
  
Cast (SortedMap k v) (SortedDMap k (const v))
  
(Eq k, Eq v) => Eq (SortedMap k v)
  
Foldable (SortedMap k)
  
Functor (SortedMap k)
  
(Ord k, Semigroup v) => Monoid (SortedMap k v)
  
Semigroup v => Semigroup (SortedMap k v)
  
(Show k, Show v) => Show (SortedMap k v)
  
Traversable (SortedMap k)
  
Ord k => Zippable (SortedMap k)
empty : Ord k => SortedMap k v
  Visibility: export
lookup : k -> SortedMap k v -> Maybe v
  Visibility: export
insert : k -> v -> SortedMap k v -> SortedMap k v
  Visibility: export
singleton : Ord k => k -> v -> SortedMap k v
  Visibility: export
insertFrom : Foldable f => f (k, v) -> SortedMap k v -> SortedMap k v
  Visibility: export
delete : k -> SortedMap k v -> SortedMap k v
  Visibility: export
update : (Maybe v -> Maybe v) -> k -> SortedMap k v -> SortedMap k v
  Updates or deletes a value based on the decision function
  
  The decision function takes information about the presence of the value,
  and the value itself, if it is present.
  It returns a new value or the fact that there should be no value as the result.
  
  The current implementation performs up to two traversals of the original map

  Visibility: export
updateExisting : (v -> v) -> k -> SortedMap k v -> SortedMap k v
  Updates existing value, if it is present, and does nothing otherwise
  
  The current implementation performs up to two traversals of the original map

  Visibility: export
fromList : Ord k => List (k, v) -> SortedMap k v
  Visibility: export
toList : SortedMap k v -> List (k, v)
  Visibility: export
keys : SortedMap k v -> List k
  Gets the keys of the map.

  Visibility: export
values : SortedMap k v -> List v
  Gets the values of the map. Could contain duplicates.

  Visibility: export
mergeWith : (v -> v -> v) -> SortedMap k v -> SortedMap k v -> SortedMap k v
  Merge two maps. When encountering duplicate keys, using a function to combine the values.
  Uses the ordering of the first map given.

  Visibility: export
merge : Semigroup v => SortedMap k v -> SortedMap k v -> SortedMap k v
  Merge two maps using the Semigroup (and by extension, Monoid) operation.
  Uses mergeWith internally, so the ordering of the left map is kept.

  Visibility: export
mergeLeft : SortedMap k v -> SortedMap k v -> SortedMap k v
  Left-biased merge, also keeps the ordering specified  by the left map.

  Visibility: export
lookupBetween : key -> SortedMap key val -> (Maybe (key, val), Maybe (key, val))
  looks up a key in map, returning the left and right closest values, so that
   k1 <= k < k2. If at the end of the beginning and/or end of the sorted map, returns
  nothing appropriately

  Visibility: export
leftMost : SortedMap key val -> Maybe (key, val)
  Returns the leftmost (least) key and value

  Visibility: export
rightMost : SortedMap key val -> Maybe (key, val)
  Returns the rightmost (greatest) key and value

  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.SortedSet.html b/base/docs/Data.SortedSet.html
index 982eff04c5..6f584c1a8c 100644
--- a/base/docs/Data.SortedSet.html
+++ b/base/docs/Data.SortedSet.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.SortedSet(source)
Definitions
data SortedSet : Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
SetWrapper : SortedMap k () -> SortedSet k

  Hints:
  
Eq k => Eq (SortedSet k)
  
Foldable SortedSet
  
Ord k => Monoid (SortedSet k)
  
Ord k => Semigroup (SortedSet k)
  
Show k => Show (SortedSet k)
empty : Ord k => SortedSet k
  Visibility: export
insert : k -> SortedSet k -> SortedSet k
  Visibility: export
delete : k -> SortedSet k -> SortedSet k
  Visibility: export
contains : k -> SortedSet k -> Bool
  Visibility: export
fromList : Ord k => List k -> SortedSet k
  Visibility: export
toList : SortedSet k -> List k
  Visibility: export
union : SortedSet k -> SortedSet k -> SortedSet k
  Set union. Inserts all elements of x into y

  Visibility: export
difference : SortedSet k -> SortedSet k -> SortedSet k
  Set difference. Delete all elments in y from x

  Visibility: export
symDifference : SortedSet k -> SortedSet k -> SortedSet k
  Set symmetric difference. Uses the union of the differences.

  Visibility: export
intersection : SortedSet k -> SortedSet k -> SortedSet k
  Set intersection. Implemented as the difference of the union and the symetric difference.

  Visibility: export
keySet : SortedMap k v -> SortedSet k
  Visibility: export
keySet : SortedDMap k v -> SortedSet k
  Visibility: export
singleton : Ord k => k -> SortedSet k
  Visibility: export

\ No newline at end of file
+
Data.SortedSet(source)
Definitions
data SortedSet : Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
SetWrapper : SortedMap k () -> SortedSet k

  Hints:
  
Eq k => Eq (SortedSet k)
  
Foldable SortedSet
  
Ord k => Monoid (SortedSet k)
  
Ord k => Semigroup (SortedSet k)
  
Show k => Show (SortedSet k)
empty : Ord k => SortedSet k
  Visibility: export
insert : k -> SortedSet k -> SortedSet k
  Visibility: export
delete : k -> SortedSet k -> SortedSet k
  Visibility: export
contains : k -> SortedSet k -> Bool
  Visibility: export
fromList : Ord k => List k -> SortedSet k
  Visibility: export
toList : SortedSet k -> List k
  Visibility: export
union : SortedSet k -> SortedSet k -> SortedSet k
  Set union. Inserts all elements of x into y

  Visibility: export
difference : SortedSet k -> SortedSet k -> SortedSet k
  Set difference. Delete all elments in y from x

  Visibility: export
symDifference : SortedSet k -> SortedSet k -> SortedSet k
  Set symmetric difference. Uses the union of the differences.

  Visibility: export
intersection : SortedSet k -> SortedSet k -> SortedSet k
  Set intersection. Implemented as the difference of the union and the symetric difference.

  Visibility: export
keySet : SortedMap k v -> SortedSet k
  Visibility: export
keySet : SortedDMap k v -> SortedSet k
  Visibility: export
singleton : Ord k => k -> SortedSet k
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.Stream.html b/base/docs/Data.Stream.html
index abd470d808..f361dddb59 100644
--- a/base/docs/Data.Stream.html
+++ b/base/docs/Data.Stream.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Stream(source)
Reexports
import public Data.Zippable
Definitions
drop : Nat -> Stream a -> Stream a
  Drop the first n elements from the stream
  @ n how many elements to drop

  Totality: total
  Visibility: public export
repeat : a -> Stream a
  An infinite stream of repetitions of the same thing

  Totality: total
  Visibility: public export
iterate : (a -> a) -> a -> Stream a
  Generate an infinite stream by repeatedly applying a function
  @ f the function to iterate
  @ x the initial value that will be the head of the stream

  Totality: total
  Visibility: public export
unfoldr : (b -> (a, b)) -> b -> Stream a
  Totality: total
  Visibility: public export
nats : Stream Nat
  All of the natural numbers, in order

  Totality: total
  Visibility: public export
index : Nat -> Stream a -> a
  Get the nth element of a stream

  Totality: total
  Visibility: public export
zipWithIndexLinear : (0 f : (a -> a -> {a:5799})) -> (xs : Stream a) -> (ys : Stream a) -> (i : Nat) -> index i (zipWith f xs ys) = f (index i xs) (index i ys)
  Totality: total
  Visibility: export
zipWith3IndexLinear : (0 f : (a -> a -> a -> {a:5885})) -> (xs : Stream a) -> (ys : Stream a) -> (zs : Stream a) -> (i : Nat) -> index i (zipWith3 f xs ys zs) = f (index i xs) (index i ys) (index i zs)
  Totality: total
  Visibility: export
diag : Stream (Stream a) -> Stream a
  Return the diagonal elements of a stream of streams

  Totality: total
  Visibility: export
scanl : (a -> b -> a) -> a -> Stream b -> Stream a
  Produce a Stream of left folds of prefixes of the given Stream
  @ f the combining function
  @ acc the initial value
  @ xs the Stream to process

  Totality: total
  Visibility: export
cycle : (xs : List a) -> {auto 0 _ : NonEmpty xs} -> Stream a
  Produce a Stream repeating a sequence
  @ xs the sequence to repeat
  @ ok proof that the list is non-empty

  Totality: total
  Visibility: export
zig : List1 (Stream a) -> Stream (Stream a) -> Stream a
  Totality: total
  Visibility: public export
zag : List1 a -> List1 (Stream a) -> Stream (Stream a) -> Stream a
  Totality: total
  Visibility: public export
cantor : Stream (Stream a) -> Stream a
  Totality: total
  Visibility: public export
planeWith : {0 p : a -> Type} -> ((x : a) -> p x -> c) -> Stream a -> ((x : a) -> Stream (p x)) -> Stream c
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export
plane : {0 p : a -> Type} -> Stream a -> ((x : a) -> Stream (p x)) -> Stream (x : a ** p x)
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export
planeWith : (a -> b -> c) -> Stream a -> (a -> Stream b) -> Stream c
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export
plane : Stream a -> (a -> Stream b) -> Stream (a, b)
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Stream(source)
Reexports
import public Data.Zippable
Definitions
drop : Nat -> Stream a -> Stream a
  Drop the first n elements from the stream
  @ n how many elements to drop

  Totality: total
  Visibility: public export
repeat : a -> Stream a
  An infinite stream of repetitions of the same thing

  Totality: total
  Visibility: public export
iterate : (a -> a) -> a -> Stream a
  Generate an infinite stream by repeatedly applying a function
  @ f the function to iterate
  @ x the initial value that will be the head of the stream

  Totality: total
  Visibility: public export
unfoldr : (b -> (a, b)) -> b -> Stream a
  Totality: total
  Visibility: public export
nats : Stream Nat
  All of the natural numbers, in order

  Totality: total
  Visibility: public export
index : Nat -> Stream a -> a
  Get the nth element of a stream

  Totality: total
  Visibility: public export
zipWithIndexLinear : (0 f : (a -> a -> {a:5799})) -> (xs : Stream a) -> (ys : Stream a) -> (i : Nat) -> index i (zipWith f xs ys) = f (index i xs) (index i ys)
  Totality: total
  Visibility: export
zipWith3IndexLinear : (0 f : (a -> a -> a -> {a:5885})) -> (xs : Stream a) -> (ys : Stream a) -> (zs : Stream a) -> (i : Nat) -> index i (zipWith3 f xs ys zs) = f (index i xs) (index i ys) (index i zs)
  Totality: total
  Visibility: export
diag : Stream (Stream a) -> Stream a
  Return the diagonal elements of a stream of streams

  Totality: total
  Visibility: export
scanl : (a -> b -> a) -> a -> Stream b -> Stream a
  Produce a Stream of left folds of prefixes of the given Stream
  @ f the combining function
  @ acc the initial value
  @ xs the Stream to process

  Totality: total
  Visibility: export
cycle : (xs : List a) -> {auto 0 _ : NonEmpty xs} -> Stream a
  Produce a Stream repeating a sequence
  @ xs the sequence to repeat
  @ ok proof that the list is non-empty

  Totality: total
  Visibility: export
zig : List1 (Stream a) -> Stream (Stream a) -> Stream a
  Totality: total
  Visibility: public export
zag : List1 a -> List1 (Stream a) -> Stream (Stream a) -> Stream a
  Totality: total
  Visibility: public export
cantor : Stream (Stream a) -> Stream a
  Totality: total
  Visibility: public export
planeWith : {0 p : a -> Type} -> ((x : a) -> p x -> c) -> Stream a -> ((x : a) -> Stream (p x)) -> Stream c
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export
plane : {0 p : a -> Type} -> Stream a -> ((x : a) -> Stream (p x)) -> Stream (x : a ** p x)
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export
planeWith : (a -> b -> c) -> Stream a -> (a -> Stream b) -> Stream c
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export
plane : Stream a -> (a -> Stream b) -> Stream (a, b)
  Explore the plane corresponding to all possible pairings
  using Cantor's zig zag traversal

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.String.html b/base/docs/Data.String.html
index 6413e1811b..12b06c2534 100644
--- a/base/docs/Data.String.html
+++ b/base/docs/Data.String.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.String(source)
Reexports
import public Data.List
import public Data.SnocList
Definitions
singleton : Char -> String
  Totality: total
  Visibility: public export
replicate : Nat -> Char -> String
  Create a string by using n copies of a character

  Totality: total
  Visibility: public export
indent : Nat -> String -> String
  Indent a given string by `n` spaces.

  Totality: total
  Visibility: public export
padLeft : Nat -> Char -> String -> String
  Pad a string on the left

  Totality: total
  Visibility: public export
padRight : Nat -> Char -> String -> String
  Pad a string on the right

  Totality: total
  Visibility: public export
fastUnlines : List String -> String
  Totality: total
  Visibility: export
words : String -> List String
  Splits a string into a list of whitespace separated strings.
  
  ```idris example
  words " A B C  D E   "
  ```

  Totality: total
  Visibility: public export
joinBy : String -> List String -> String
  Joins the strings using the provided separator
  ```idris example
  joinBy ", " ["A", "BC", "D"] === "A, BC, D"
  ```

  Totality: total
  Visibility: public export
unwords : List String -> String
  Joins the strings by spaces into a single string.
  
  ```idris example
  unwords ["A", "BC", "D", "E"] === "A BC D E"
  ```

  Totality: total
  Visibility: public export
lines' : List Char -> List (List Char)
  Splits a character list into a list of newline separated character lists.
  
  The empty string becomes an empty list. The last newline, if not followed by
  any additional characters, is eaten (there will never be an empty string last element
  in the result).
  
  ```idris example
  lines' (unpack "\rA BC\nD\r\nE\n")
  ```

  Totality: total
  Visibility: public export
lines : String -> List String
  Splits a string into a list of newline separated strings.
  
  The empty string becomes an empty list. The last newline, if not followed by
  any additional characters, is eaten (there will never be an empty string last element
  in the result).
  
  ```idris example
  lines  "\rA BC\nD\r\nE\n"
  ```

  Totality: total
  Visibility: public export
unlines : List String -> String
  Joins the strings into a single string by appending a newline to each string.
  
  ```idris example
  unlines ["line", "line2", "ln3", "D"]
  ```

  Totality: total
  Visibility: public export
data StrM : String -> Type
  A view checking whether a string is empty
  and, if not, returning its head and tail

  Totality: total
  Visibility: public export
  Constructors:
  
StrNil : StrM ""
  
StrCons : (x : Char) -> (xs : String) -> StrM (strCons x xs)
strM : (x : String) -> StrM x
  To each string we can associate its StrM view

  Totality: total
  Visibility: public export
data AsList : String -> Type
  A view of a string as a lazy linked list of characters

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : AsList ""
  
(::) : (c : Char) -> Lazy (AsList str) -> AsList (strCons c str)
asList : (str : String) -> AsList str
  To each string we can associate the lazy linked list of characters
  it corresponds to once unpacked.

  Totality: total
  Visibility: public export
ltrim : String -> String
  Trim whitespace on the left of the string

  Totality: total
  Visibility: public export
trim : String -> String
  Trim whitespace on both sides of the string

  Totality: total
  Visibility: public export
span : (Char -> Bool) -> String -> (String, String)
  Splits the string into a part before the predicate
  returns False and the rest of the string.
  
  ```idris example
  span (/= 'C') "ABCD"
  ```
  ```idris example
  span (/= 'C') "EFGH"
  ```

  Totality: total
  Visibility: public export
break : (Char -> Bool) -> String -> (String, String)
  Splits the string into a part before the predicate
  returns True and the rest of the string.
  
  ```idris example
  break (== 'C') "ABCD"
  ```
  ```idris example
  break (== 'C') "EFGH"
  ```

  Totality: total
  Visibility: public export
split : (Char -> Bool) -> String -> List1 String
  Splits the string into parts with the predicate
  indicating separator characters.
  
  ```idris example
  split (== '.') ".AB.C..D"
  ```

  Totality: total
  Visibility: public export
stringToNatOrZ : String -> Nat
  Totality: total
  Visibility: public export
toUpper : String -> String
  Totality: total
  Visibility: public export
toLower : String -> String
  Totality: total
  Visibility: public export
strIndex : String -> Int -> Char
  Visibility: public export
strLength : String -> Int
  Visibility: public export
strSubstr : Int -> Int -> String -> String
  Visibility: public export
strTail : String -> String
  Visibility: public export
isPrefixOf : String -> String -> Bool
  Totality: total
  Visibility: public export
isSuffixOf : String -> String -> Bool
  Totality: total
  Visibility: public export
isInfixOf : String -> String -> Bool
  Totality: total
  Visibility: public export
parseNumWithoutSign : List Char -> Integer -> Maybe Integer
  Totality: total
  Visibility: public export
parsePositive : Num a => String -> Maybe a
  Convert a positive number string to a Num.
  
  ```idris example
  parsePositive "123"
  ```
  ```idris example
  parsePositive {a=Int} " +123"
  ```

  Totality: total
  Visibility: public export
parseInteger : Num a => Neg a => String -> Maybe a
  Convert a number string to a Num.
  
  ```idris example
  parseInteger " 123"
  ```
  ```idris example
  parseInteger {a=Int} " -123"
  ```

  Totality: total
  Visibility: public export
parseDouble : String -> Maybe Double
  Convert a number string to a Double.
  
  ```idris example
  parseDouble "+123.123e-2"
  ```
  ```idris example
  parseDouble " -123.123E+2"
  ```
  ```idris example
  parseDouble " +123.123"
  ```

  Visibility: export
null : String -> Bool
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.String(source)
Reexports
import public Data.List
import public Data.SnocList
Definitions
singleton : Char -> String
  Totality: total
  Visibility: public export
replicate : Nat -> Char -> String
  Create a string by using n copies of a character

  Totality: total
  Visibility: public export
indent : Nat -> String -> String
  Indent a given string by `n` spaces.

  Totality: total
  Visibility: public export
padLeft : Nat -> Char -> String -> String
  Pad a string on the left

  Totality: total
  Visibility: public export
padRight : Nat -> Char -> String -> String
  Pad a string on the right

  Totality: total
  Visibility: public export
fastUnlines : List String -> String
  Totality: total
  Visibility: export
words : String -> List String
  Splits a string into a list of whitespace separated strings.
  
  ```idris example
  words " A B C  D E   "
  ```

  Totality: total
  Visibility: public export
joinBy : String -> List String -> String
  Joins the strings using the provided separator
  ```idris example
  joinBy ", " ["A", "BC", "D"] === "A, BC, D"
  ```

  Totality: total
  Visibility: public export
unwords : List String -> String
  Joins the strings by spaces into a single string.
  
  ```idris example
  unwords ["A", "BC", "D", "E"] === "A BC D E"
  ```

  Totality: total
  Visibility: public export
lines' : List Char -> List (List Char)
  Splits a character list into a list of newline separated character lists.
  
  The empty string becomes an empty list. The last newline, if not followed by
  any additional characters, is eaten (there will never be an empty string last element
  in the result).
  
  ```idris example
  lines' (unpack "\rA BC\nD\r\nE\n")
  ```

  Totality: total
  Visibility: public export
lines : String -> List String
  Splits a string into a list of newline separated strings.
  
  The empty string becomes an empty list. The last newline, if not followed by
  any additional characters, is eaten (there will never be an empty string last element
  in the result).
  
  ```idris example
  lines  "\rA BC\nD\r\nE\n"
  ```

  Totality: total
  Visibility: public export
unlines : List String -> String
  Joins the strings into a single string by appending a newline to each string.
  
  ```idris example
  unlines ["line", "line2", "ln3", "D"]
  ```

  Totality: total
  Visibility: public export
data StrM : String -> Type
  A view checking whether a string is empty
  and, if not, returning its head and tail

  Totality: total
  Visibility: public export
  Constructors:
  
StrNil : StrM ""
  
StrCons : (x : Char) -> (xs : String) -> StrM (strCons x xs)
strM : (x : String) -> StrM x
  To each string we can associate its StrM view

  Totality: total
  Visibility: public export
data AsList : String -> Type
  A view of a string as a lazy linked list of characters

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : AsList ""
  
(::) : (c : Char) -> Lazy (AsList str) -> AsList (strCons c str)
asList : (str : String) -> AsList str
  To each string we can associate the lazy linked list of characters
  it corresponds to once unpacked.

  Totality: total
  Visibility: public export
ltrim : String -> String
  Trim whitespace on the left of the string

  Totality: total
  Visibility: public export
trim : String -> String
  Trim whitespace on both sides of the string

  Totality: total
  Visibility: public export
span : (Char -> Bool) -> String -> (String, String)
  Splits the string into a part before the predicate
  returns False and the rest of the string.
  
  ```idris example
  span (/= 'C') "ABCD"
  ```
  ```idris example
  span (/= 'C') "EFGH"
  ```

  Totality: total
  Visibility: public export
break : (Char -> Bool) -> String -> (String, String)
  Splits the string into a part before the predicate
  returns True and the rest of the string.
  
  ```idris example
  break (== 'C') "ABCD"
  ```
  ```idris example
  break (== 'C') "EFGH"
  ```

  Totality: total
  Visibility: public export
split : (Char -> Bool) -> String -> List1 String
  Splits the string into parts with the predicate
  indicating separator characters.
  
  ```idris example
  split (== '.') ".AB.C..D"
  ```

  Totality: total
  Visibility: public export
stringToNatOrZ : String -> Nat
  Totality: total
  Visibility: public export
toUpper : String -> String
  Totality: total
  Visibility: public export
toLower : String -> String
  Totality: total
  Visibility: public export
strIndex : String -> Int -> Char
  Visibility: public export
strLength : String -> Int
  Visibility: public export
strSubstr : Int -> Int -> String -> String
  Visibility: public export
strTail : String -> String
  Visibility: public export
isPrefixOf : String -> String -> Bool
  Totality: total
  Visibility: public export
isSuffixOf : String -> String -> Bool
  Totality: total
  Visibility: public export
isInfixOf : String -> String -> Bool
  Totality: total
  Visibility: public export
parseNumWithoutSign : List Char -> Integer -> Maybe Integer
  Totality: total
  Visibility: public export
parsePositive : Num a => String -> Maybe a
  Convert a positive number string to a Num.
  
  ```idris example
  parsePositive "123"
  ```
  ```idris example
  parsePositive {a=Int} " +123"
  ```

  Totality: total
  Visibility: public export
parseInteger : Num a => Neg a => String -> Maybe a
  Convert a number string to a Num.
  
  ```idris example
  parseInteger " 123"
  ```
  ```idris example
  parseInteger {a=Int} " -123"
  ```

  Totality: total
  Visibility: public export
parseDouble : String -> Maybe Double
  Convert a number string to a Double.
  
  ```idris example
  parseDouble "+123.123e-2"
  ```
  ```idris example
  parseDouble " -123.123E+2"
  ```
  ```idris example
  parseDouble " +123.123"
  ```

  Visibility: export
null : String -> Bool
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.These.html b/base/docs/Data.These.html
index 76e41275ef..5327d79773 100644
--- a/base/docs/Data.These.html
+++ b/base/docs/Data.These.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.These(source)
Definitions
data These : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
This : a -> These a b
  
That : b -> These a b
  
Both : a -> b -> These a b

  Hints:
  
Semigroup a => Applicative (These a)
  
Bifoldable These
  
Bifunctor These
  
Biinjective Both
  
Bitraversable These
  
DecEq t => DecEq s => DecEq (These t s)
  
Eq a => Eq b => Eq (These a b)
  
Foldable (These a)
  
Functor (These a)
  
Injective This
  
Injective That
  
Injective (Both x)
  
Injective (\{arg:0} => Both {arg:0} y)
  
Semigroup a => Semigroup b => Semigroup (These a b)
  
(Show a, Show b) => Show (These a b)
  
Traversable (These a)
  
Semigroup a => Zippable (These a)
fromEither : Either a b -> These a b
  Totality: total
  Visibility: public export
fromThis : These a b -> Maybe a
  Totality: total
  Visibility: public export
fromThat : These a b -> Maybe b
  Totality: total
  Visibility: public export
fromBoth : Lazy a -> Lazy b -> These a b -> (a, b)
  Totality: total
  Visibility: public export
these : (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c
  Totality: total
  Visibility: public export
these' : Lazy a -> Lazy b -> (a -> b -> c) -> These a b -> c
  Totality: total
  Visibility: public export
swap : These a b -> These b a
  Totality: total
  Visibility: public export
bifold : Semigroup m => These m m -> m
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.These(source)
Definitions
data These : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
This : a -> These a b
  
That : b -> These a b
  
Both : a -> b -> These a b

  Hints:
  
Semigroup a => Applicative (These a)
  
Bifoldable These
  
Bifunctor These
  
Biinjective Both
  
Bitraversable These
  
DecEq t => DecEq s => DecEq (These t s)
  
Eq a => Eq b => Eq (These a b)
  
Foldable (These a)
  
Functor (These a)
  
Injective This
  
Injective That
  
Injective (Both x)
  
Injective (\{arg:0} => Both {arg:0} y)
  
Semigroup a => Semigroup b => Semigroup (These a b)
  
(Show a, Show b) => Show (These a b)
  
Traversable (These a)
  
Semigroup a => Zippable (These a)
fromEither : Either a b -> These a b
  Totality: total
  Visibility: public export
fromThis : These a b -> Maybe a
  Totality: total
  Visibility: public export
fromThat : These a b -> Maybe b
  Totality: total
  Visibility: public export
fromBoth : Lazy a -> Lazy b -> These a b -> (a, b)
  Totality: total
  Visibility: public export
these : (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c
  Totality: total
  Visibility: public export
these' : Lazy a -> Lazy b -> (a -> b -> c) -> These a b -> c
  Totality: total
  Visibility: public export
swap : These a b -> These b a
  Totality: total
  Visibility: public export
bifold : Semigroup m => These m m -> m
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Vect.AtIndex.html b/base/docs/Data.Vect.AtIndex.html
index f079282dc8..bd3d4133c8 100644
--- a/base/docs/Data.Vect.AtIndex.html
+++ b/base/docs/Data.Vect.AtIndex.html
@@ -74,4 +74,4 @@
    presented vector.
 
 2. Find the element at the given index in the presented vector.
-
Definitions
data AtIndex : Fin n -> Vect n type -> type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Here : AtIndex FZ (x :: xs) x
  
There : AtIndex rest xs x -> AtIndex (FS rest) (y :: xs) x
elemDiffers : (y = x -> Void) -> AtIndex FZ (y :: xs) x -> Void
  Totality: total
  Visibility: public export
elemNotInRest : (AtIndex z xs x -> Void) -> AtIndex (FS z) (y :: xs) x -> Void
  Totality: total
  Visibility: public export
index : DecEq type => (idx : Fin n) -> (x : type) -> (xs : Vect n type) -> Dec (AtIndex idx xs x)
  Is the element at the given index?
  

  Totality: total
  Visibility: public export
elemNotInRest : (DPair type (AtIndex x xs) -> Void) -> DPair type (AtIndex (FS x) (y :: xs)) -> Void
  Totality: total
  Visibility: public export
index : DecEq type => (idx : Fin n) -> (xs : Vect n type) -> Dec (DPair type (AtIndex idx xs))
  What is the element at the given index?
  

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
data AtIndex : Fin n -> Vect n type -> type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Here : AtIndex FZ (x :: xs) x
  
There : AtIndex rest xs x -> AtIndex (FS rest) (y :: xs) x
elemDiffers : (y = x -> Void) -> AtIndex FZ (y :: xs) x -> Void
  Totality: total
  Visibility: public export
elemNotInRest : (AtIndex z xs x -> Void) -> AtIndex (FS z) (y :: xs) x -> Void
  Totality: total
  Visibility: public export
index : DecEq type => (idx : Fin n) -> (x : type) -> (xs : Vect n type) -> Dec (AtIndex idx xs x)
  Is the element at the given index?
  

  Totality: total
  Visibility: public export
elemNotInRest : (DPair type (AtIndex x xs) -> Void) -> DPair type (AtIndex (FS x) (y :: xs)) -> Void
  Totality: total
  Visibility: public export
index : DecEq type => (idx : Fin n) -> (xs : Vect n type) -> Dec (DPair type (AtIndex idx xs))
  What is the element at the given index?
  

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Vect.Elem.html b/base/docs/Data.Vect.Elem.html
index 15854ed3d4..fb7959d17d 100644
--- a/base/docs/Data.Vect.Elem.html
+++ b/base/docs/Data.Vect.Elem.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Vect.Elem(source)
Definitions
data Elem : a -> Vect k a -> Type
  A proof that some element is found in a vector

  Totality: total
  Visibility: public export
  Constructors:
  
Here : Elem x (x :: xs)
  
There : Elem x xs -> Elem x (y :: xs)

  Hints:
  
DecEq (Elem x xs)
  
Injective There
  
Uninhabited (Here = There e)
  
Uninhabited (There e = Here)
  
Uninhabited (Elem x [])
  
Uninhabited (x = z) => Uninhabited (Elem z xs) => Uninhabited (Elem z (x :: xs))
neitherHereNorThere : Not (x = y) -> Not (Elem x xs) -> Not (Elem x (y :: xs))
  An item not in the head and not in the tail is not in the Vect at all

  Totality: total
  Visibility: export
isElem : DecEq a => (x : a) -> (xs : Vect n a) -> Dec (Elem x xs)
  A decision procedure for Elem

  Totality: total
  Visibility: public export
get : (xs : Vect n a) -> Elem x xs -> a
  Get the element at the given position.

  Totality: total
  Visibility: public export
lookup : (xs : Vect n a) -> Elem x xs -> Singleton x
  Get the element at the given position, with proof that it is the desired element.

  Totality: total
  Visibility: public export
replaceElem : (xs : Vect k t) -> Elem x xs -> (y : t) -> (ys : Vect k t ** Elem y ys)
  Totality: total
  Visibility: public export
replaceByElem : (xs : Vect k t) -> Elem x xs -> t -> Vect k t
  Totality: total
  Visibility: public export
mapElem : (1 _ : Elem x xs) -> Elem (f x) (map f xs)
  Totality: total
  Visibility: public export
dropElem : (xs : Vect (S k) t) -> Elem x xs -> Vect k t
  Remove the element at the given position.
  
  @xs The vector to be removed from
  @p A proof that the element to be removed is in the vector

  Totality: total
  Visibility: public export
elemToFin : Elem x xs -> Fin n
  Erase the indices, returning the bounded numeric position of the element

  Totality: total
  Visibility: public export
indexElem : (1 _ : Fin n) -> (xs : Vect n a) -> (x : a ** Elem x xs)
  Find the element with a proof at a given bounded position

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Vect.Elem(source)
Definitions
data Elem : a -> Vect k a -> Type
  A proof that some element is found in a vector

  Totality: total
  Visibility: public export
  Constructors:
  
Here : Elem x (x :: xs)
  
There : Elem x xs -> Elem x (y :: xs)

  Hints:
  
DecEq (Elem x xs)
  
Injective There
  
Uninhabited (Here = There e)
  
Uninhabited (There e = Here)
  
Uninhabited (Elem x [])
  
Uninhabited (x = z) => Uninhabited (Elem z xs) => Uninhabited (Elem z (x :: xs))
neitherHereNorThere : Not (x = y) -> Not (Elem x xs) -> Not (Elem x (y :: xs))
  An item not in the head and not in the tail is not in the Vect at all

  Totality: total
  Visibility: export
isElem : DecEq a => (x : a) -> (xs : Vect n a) -> Dec (Elem x xs)
  A decision procedure for Elem

  Totality: total
  Visibility: public export
get : (xs : Vect n a) -> Elem x xs -> a
  Get the element at the given position.

  Totality: total
  Visibility: public export
lookup : (xs : Vect n a) -> Elem x xs -> Singleton x
  Get the element at the given position, with proof that it is the desired element.

  Totality: total
  Visibility: public export
replaceElem : (xs : Vect k t) -> Elem x xs -> (y : t) -> (ys : Vect k t ** Elem y ys)
  Totality: total
  Visibility: public export
replaceByElem : (xs : Vect k t) -> Elem x xs -> t -> Vect k t
  Totality: total
  Visibility: public export
mapElem : (1 _ : Elem x xs) -> Elem (f x) (map f xs)
  Totality: total
  Visibility: public export
dropElem : (xs : Vect (S k) t) -> Elem x xs -> Vect k t
  Remove the element at the given position.
  
  @xs The vector to be removed from
  @p A proof that the element to be removed is in the vector

  Totality: total
  Visibility: public export
elemToFin : Elem x xs -> Fin n
  Erase the indices, returning the bounded numeric position of the element

  Totality: total
  Visibility: public export
indexElem : (1 _ : Fin n) -> (xs : Vect n a) -> (x : a ** Elem x xs)
  Find the element with a proof at a given bounded position

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Data.Vect.Quantifiers.html b/base/docs/Data.Vect.Quantifiers.html
index b5b18a32bc..ac5ec110fa 100644
--- a/base/docs/Data.Vect.Quantifiers.html
+++ b/base/docs/Data.Vect.Quantifiers.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Vect.Quantifiers(source)
Definitions
data Any : (0 _ : (a -> Type)) -> Vect n a -> Type
  A proof that some element of a vector satisfies some property
  
  @ p the property to be satsified

  Totality: total
  Visibility: public export
  Constructors:
  
Here : p x -> Any p (x :: xs)
  A proof that the satisfying element is the first one in the `Vect`
  
There : Any p xs -> Any p (x :: xs)
  A proof that the satsifying element is in the tail of the `Vect`

  Hints:
  
Uninhabited (Any p [])
  
Uninhabited (p x) => Uninhabited (Any p xs) => Uninhabited (Any p (x :: xs))
anyElim : (Any p xs -> b) -> (p x -> b) -> Any p (x :: xs) -> b
  Eliminator for `Any`

  Totality: total
  Visibility: public export
any : ((x : a) -> Dec (p x)) -> (xs : Vect n a) -> Dec (Any p xs)
  Given a decision procedure for a property, determine if an element of a
  vector satisfies it.
  
  @ p the property to be satisfied
  @ dec the decision procedure
  @ xs the vector to examine

  Totality: total
  Visibility: public export
mapProperty : (p x -> q x) -> Any p l -> Any q l
  Totality: total
  Visibility: export
toExists : Any p xs -> Exists p
  Totality: total
  Visibility: export
anyToFin : Any p xs -> Fin n
  Get the bounded numeric position of the element satisfying the predicate

  Totality: total
  Visibility: public export
anyToFinCorrect : (witness : Any p xs) -> p (index (anyToFin witness) xs)
  `anyToFin`'s return type satisfies the predicate

  Totality: total
  Visibility: export
data All : (0 _ : (a -> Type)) -> Vect n a -> Type
  A proof that all elements of a vector satisfy a property. It is a list of
  proofs, corresponding element-wise to the `Vect`.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : All p []
  
(::) : p x -> All p xs -> All p (x :: xs)

  Hints:
  
All (Ord . p) xs => All (Eq . p) xs
  
All (Monoid . p) xs => All (Semigroup . p) xs
  
All (Eq . p) xs => Eq (All p xs)
  
All (Monoid . p) xs => Monoid (All p xs)
  
All (Ord . p) xs => Ord (All p xs)
  
All (Semigroup . p) xs => Semigroup (All p xs)
  
All (Show . p) xs => Show (All p xs)
  
Either (Uninhabited (p x)) (Uninhabited (All p xs)) => Uninhabited (All p (x :: xs))
negAnyAll : Not (Any p xs) -> All (Not . p) xs
  If there does not exist an element that satifies the property, then it is
  the case that all elements do not satisfy.

  Totality: total
  Visibility: export
notAllHere : Not (p x) -> Not (All p (x :: xs))
  Totality: total
  Visibility: export
notAllThere : Not (All p xs) -> Not (All p (x :: xs))
  Totality: total
  Visibility: export
all : ((x : a) -> Dec (p x)) -> (xs : Vect n a) -> Dec (All p xs)
  Given a decision procedure for a property, decide whether all elements of
  a vector satisfy it.
  
  @ p the property
  @ dec the decision procedure
  @ xs the vector to examine

  Totality: total
  Visibility: public export
mapProperty : (p x -> q x) -> All p l -> All q l
  Totality: total
  Visibility: export
mapPropertyRelevant : ((x : a) -> p x -> q x) -> All p xs -> All q xs
  A variant of `mapProperty` that also allows accessing
  the values of `xs` that the corresponding `ps` prove `p` about.

  Totality: total
  Visibility: export
imapProperty : (0 i : (a -> Type)) -> (i x => p x -> q x) -> All i as => All p as -> All q as
  Totality: total
  Visibility: public export
forget : All (const p) xs -> Vect n p
  If `All` witnesses a property that does not depend on the vector `xs`
  it's indexed by, then it is really a `Vect`.

  Totality: total
  Visibility: public export
remember : (xs : Vect n ty) -> All (const ty) xs
  Any `Vect` can be lifted to become an `All`
  witnessing the presence of elements of the `Vect`'s type.

  Totality: total
  Visibility: public export
forgetRememberId : (xs : Vect n ty) -> forget (remember xs) = xs
  Totality: total
  Visibility: export
castAllConst : All (const ty) xs -> All (const ty) ys
  Totality: total
  Visibility: public export
rememberForgetId : (vs : All (const ty) xs) -> castAllConst (remember (forget vs)) = vs
  Totality: total
  Visibility: export
zipPropertyWith : (p x -> q x -> r x) -> All p xs -> All q xs -> All r xs
  Totality: total
  Visibility: export
traverseProperty : Applicative f => (p x -> f (q x)) -> All p xs -> f (All q xs)
  A `Traversable`'s `traverse` for `All`,
  for traversals that don't care about the values of the associated `Vect`.

  Totality: total
  Visibility: export
traversePropertyRelevant : Applicative f => ((x : a) -> p x -> f (q x)) -> All p xs -> f (All q xs)
  A `Traversable`'s `traverse` for `All`,
  in case the elements of the `Vect` that the `All` is proving `p` about are also needed.

  Totality: total
  Visibility: export
tabulate : ((ix : Fin n) -> p (index ix xs)) -> All p xs
  Totality: total
  Visibility: public export
(++) : All p xs -> All p ys -> All p (xs ++ ys)
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
HVect : Vect n Type -> Type
  A heterogeneous vector of arbitrary types

  Totality: total
  Visibility: public export
head : All p (x :: xs) -> p x
  Take the first element.

  Totality: total
  Visibility: export
tail : All p (x :: xs) -> All p xs
  Take all but the first element.

  Totality: total
  Visibility: export
drop : (n : Nat) -> All p xs -> All p (the (Vect m a) (drop n xs))
  Drop the first n elements given knowledge that
  there are at least n elements available.

  Totality: total
  Visibility: export
drop' : (l : Nat) -> All p xs -> All p (drop' l xs)
  Drop up to the first l elements, stopping early
  if all elements have been dropped.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Vect.Quantifiers(source)
Definitions
data Any : (0 _ : (a -> Type)) -> Vect n a -> Type
  A proof that some element of a vector satisfies some property
  
  @ p the property to be satsified

  Totality: total
  Visibility: public export
  Constructors:
  
Here : p x -> Any p (x :: xs)
  A proof that the satisfying element is the first one in the `Vect`
  
There : Any p xs -> Any p (x :: xs)
  A proof that the satsifying element is in the tail of the `Vect`

  Hints:
  
Uninhabited (Any p [])
  
Uninhabited (p x) => Uninhabited (Any p xs) => Uninhabited (Any p (x :: xs))
anyElim : (Any p xs -> b) -> (p x -> b) -> Any p (x :: xs) -> b
  Eliminator for `Any`

  Totality: total
  Visibility: public export
any : ((x : a) -> Dec (p x)) -> (xs : Vect n a) -> Dec (Any p xs)
  Given a decision procedure for a property, determine if an element of a
  vector satisfies it.
  
  @ p the property to be satisfied
  @ dec the decision procedure
  @ xs the vector to examine

  Totality: total
  Visibility: public export
mapProperty : (p x -> q x) -> Any p l -> Any q l
  Totality: total
  Visibility: export
toExists : Any p xs -> Exists p
  Totality: total
  Visibility: export
anyToFin : Any p xs -> Fin n
  Get the bounded numeric position of the element satisfying the predicate

  Totality: total
  Visibility: public export
anyToFinCorrect : (witness : Any p xs) -> p (index (anyToFin witness) xs)
  `anyToFin`'s return type satisfies the predicate

  Totality: total
  Visibility: export
data All : (0 _ : (a -> Type)) -> Vect n a -> Type
  A proof that all elements of a vector satisfy a property. It is a list of
  proofs, corresponding element-wise to the `Vect`.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : All p []
  
(::) : p x -> All p xs -> All p (x :: xs)

  Hints:
  
All (Ord . p) xs => All (Eq . p) xs
  
All (Monoid . p) xs => All (Semigroup . p) xs
  
All (Eq . p) xs => Eq (All p xs)
  
All (Monoid . p) xs => Monoid (All p xs)
  
All (Ord . p) xs => Ord (All p xs)
  
All (Semigroup . p) xs => Semigroup (All p xs)
  
All (Show . p) xs => Show (All p xs)
  
Either (Uninhabited (p x)) (Uninhabited (All p xs)) => Uninhabited (All p (x :: xs))
negAnyAll : Not (Any p xs) -> All (Not . p) xs
  If there does not exist an element that satifies the property, then it is
  the case that all elements do not satisfy.

  Totality: total
  Visibility: export
notAllHere : Not (p x) -> Not (All p (x :: xs))
  Totality: total
  Visibility: export
notAllThere : Not (All p xs) -> Not (All p (x :: xs))
  Totality: total
  Visibility: export
all : ((x : a) -> Dec (p x)) -> (xs : Vect n a) -> Dec (All p xs)
  Given a decision procedure for a property, decide whether all elements of
  a vector satisfy it.
  
  @ p the property
  @ dec the decision procedure
  @ xs the vector to examine

  Totality: total
  Visibility: public export
mapProperty : (p x -> q x) -> All p l -> All q l
  Totality: total
  Visibility: export
mapPropertyRelevant : ((x : a) -> p x -> q x) -> All p xs -> All q xs
  A variant of `mapProperty` that also allows accessing
  the values of `xs` that the corresponding `ps` prove `p` about.

  Totality: total
  Visibility: export
imapProperty : (0 i : (a -> Type)) -> (i x => p x -> q x) -> All i as => All p as -> All q as
  Totality: total
  Visibility: public export
forget : All (const p) xs -> Vect n p
  If `All` witnesses a property that does not depend on the vector `xs`
  it's indexed by, then it is really a `Vect`.

  Totality: total
  Visibility: public export
remember : (xs : Vect n ty) -> All (const ty) xs
  Any `Vect` can be lifted to become an `All`
  witnessing the presence of elements of the `Vect`'s type.

  Totality: total
  Visibility: public export
forgetRememberId : (xs : Vect n ty) -> forget (remember xs) = xs
  Totality: total
  Visibility: export
castAllConst : All (const ty) xs -> All (const ty) ys
  Totality: total
  Visibility: public export
rememberForgetId : (vs : All (const ty) xs) -> castAllConst (remember (forget vs)) = vs
  Totality: total
  Visibility: export
zipPropertyWith : (p x -> q x -> r x) -> All p xs -> All q xs -> All r xs
  Totality: total
  Visibility: export
traverseProperty : Applicative f => (p x -> f (q x)) -> All p xs -> f (All q xs)
  A `Traversable`'s `traverse` for `All`,
  for traversals that don't care about the values of the associated `Vect`.

  Totality: total
  Visibility: export
traversePropertyRelevant : Applicative f => ((x : a) -> p x -> f (q x)) -> All p xs -> f (All q xs)
  A `Traversable`'s `traverse` for `All`,
  in case the elements of the `Vect` that the `All` is proving `p` about are also needed.

  Totality: total
  Visibility: export
tabulate : ((ix : Fin n) -> p (index ix xs)) -> All p xs
  Totality: total
  Visibility: public export
(++) : All p xs -> All p ys -> All p (xs ++ ys)
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
HVect : Vect n Type -> Type
  A heterogeneous vector of arbitrary types

  Totality: total
  Visibility: public export
head : All p (x :: xs) -> p x
  Take the first element.

  Totality: total
  Visibility: export
tail : All p (x :: xs) -> All p xs
  Take all but the first element.

  Totality: total
  Visibility: export
drop : (n : Nat) -> All p xs -> All p (the (Vect m a) (drop n xs))
  Drop the first n elements given knowledge that
  there are at least n elements available.

  Totality: total
  Visibility: export
drop' : (l : Nat) -> All p xs -> All p (drop' l xs)
  Drop up to the first l elements, stopping early
  if all elements have been dropped.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.Vect.html b/base/docs/Data.Vect.html
index ff95eed359..c16d39fd4b 100644
--- a/base/docs/Data.Vect.html
+++ b/base/docs/Data.Vect.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Vect(source)
Reexports
import public Data.Fin
import public Data.Zippable
Definitions
data Vect : Nat -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Vect 0 elem
  Empty vector
  
(::) : elem -> Vect len elem -> Vect (S len) elem
  A non-empty vector of length `S len`, consisting of a head element and
  the rest of the list, of length `len`.

  Hints:
  
Applicative (Vect k)
  
Biinjective (::)
  
DecEq a => DecEq (Vect n a)
  
Eq a => Eq (Vect n a)
  
Foldable (Vect n)
  
Functor (Vect n)
  
Injective ((x ::))
  
Injective (\x => x :: xs)
  
Monad (Vect k)
  
Monoid a => Monoid (Vect k a)
  
Ord elem => Ord (Vect len elem)
  
Semigroup a => Semigroup (Vect k a)
  
Show elem => Show (Vect len elem)
  
Traversable (Vect k)
  
Zippable (Vect k)
length : Vect len elem -> Nat
  Totality: total
  Visibility: public export
lengthCorrect : (xs : Vect len elem) -> length xs = len
  Show that the length function on vectors in fact calculates the length

  Totality: total
  Visibility: export
invertVectZ : (xs : Vect 0 a) -> xs = []
  Totality: total
  Visibility: export
tail : Vect (S len) elem -> Vect len elem
  All but the first element of the vector
  
  ```idris example
  tail [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
head : Vect (S len) elem -> elem
  Only the first element of the vector
  
  ```idris example
  head [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
invertVectS : (xs : Vect (S n) a) -> xs = head xs :: tail xs
  Totality: total
  Visibility: export
last : Vect (S len) elem -> elem
  The last element of the vector
  
  ```idris example
  last [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
init : Vect (S len) elem -> Vect len elem
  All but the last element of the vector
  
  ```idris example
  init [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
take : (n : Nat) -> Vect (n + m) type -> Vect n type
  Extract the first `n` elements of a Vect.

  Totality: total
  Visibility: public export
take : (n : Nat) -> Stream a -> Vect n a
  Take precisely n elements from the stream.
  @ n how many elements to take
  @ xs the stream

  Totality: total
  Visibility: public export
drop : (n : Nat) -> Vect (n + m) elem -> Vect m elem
  Drop the first `n` elements of a Vect.

  Totality: total
  Visibility: public export
drop' : (n : Nat) -> Vect l elem -> Vect (minus l n) elem
  Drop up to the first `n` elements of a Vect.

  Totality: total
  Visibility: public export
allFins : (n : Nat) -> Vect n (Fin n)
  Generate all of the Fin elements as a Vect whose length is the number of
  elements.
  
  Useful, for example, when one wants all the indices for specific Vect.

  Totality: total
  Visibility: public export
index : Fin len -> Vect len elem -> elem
  Extract a particular element from a vector
  
  ```idris example
  index 1 [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
insertAt : Fin (S len) -> elem -> Vect len elem -> Vect (S len) elem
  Insert an element at a particular index
  
  ```idris example
  insertAt 1 8 [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
deleteAt : Fin (S len) -> Vect (S len) elem -> Vect len elem
  Construct a new vector consisting of all but the indicated element
  
  ```idris example
  deleteAt 1 [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
replaceAt : Fin len -> elem -> Vect len elem -> Vect len elem
  Replace an element at a particlar index with another
  
  ```idris example
  replaceAt 1 8 [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
updateAt : Fin len -> (elem -> elem) -> Vect len elem -> Vect len elem
  Replace the element at a particular index with the result of applying a function to it
  @ i the index to replace at
  @ f the update function
  @ xs the vector to replace in
  
  ```idris example
  updateAt 1 (+10) [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
(++) : Vect m elem -> Vect n elem -> Vect (m + n) elem
  Append two vectors
  
  ```idris example
  [1,2,3,4] ++ [5,6]
  ```

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
snoc : Vect n a -> a -> Vect (S n) a
  Add an element at the end of the vector.
  The main use case for it is to get the expected type signature
  `Vect n a -> a -> Vect (S n) a` instead of
  `Vect n a -> a -> Vect (n + 1) a` which you get by using `++ [x]`
  
  Snoc gets its name by reversing `cons`, indicating we are
  tacking on the element at the end rather than the begining.
  `append` would also be a suitable name.
  
  @ xs The vector to be appended
  @ v The value to append

  Totality: total
  Visibility: public export
unsnoc : Vect (S n) a -> (Vect n a, a)
  Pop the last element from a vector. This is the opposite of `snoc`, in that
  `(uncurry snoc) unsnoc xs` is `xs`. It is equivalent to `(init xs, last xs)`,
  but traverses the vector once.
  
  @ xs The vector to pop the element from.

  Totality: total
  Visibility: public export
replicate : (len : Nat) -> elem -> Vect len elem
  Repeat some value some number of times.
  
  @ len the number of times to repeat it
  @ x the value to repeat
  
  ```idris example
  replicate 4 1
  ```

  Totality: total
  Visibility: public export
mergeBy : (elem -> elem -> Ordering) -> Vect n elem -> Vect m elem -> Vect (n + m) elem
  Merge two ordered vectors
  
  ```idris example
  mergeBy compare (fromList [1,3,5]) (fromList [2,3,4,5,6])
  ```

  Totality: total
  Visibility: export
merge : Ord elem => Vect n elem -> Vect m elem -> Vect (n + m) elem
  Totality: total
  Visibility: export
replaceAtSameIndex : (xs : Vect n a) -> (i : Fin n) -> (0 y : a) -> index i (replaceAt i y xs) = y
  Totality: total
  Visibility: export
replaceAtDiffIndexPreserves : (xs : Vect n a) -> (i : Fin n) -> (j : Fin n) -> Not (i = j) -> (0 y : a) -> index i (replaceAt j y xs) = index i xs
  Totality: total
  Visibility: export
reverseOnto : Vect n elem -> Vect m elem -> Vect (n + m) elem
  Reverse the second vector, prepending the result to the first.
  
  ```idris example
  reverseOnto [0, 1] [10, 11, 12]
  ```

  Totality: total
  Visibility: public export
reverse : Vect len elem -> Vect len elem
  Reverse the order of the elements of a vector
  
  ```idris example
  reverse [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
intersperse : elem -> Vect len elem -> Vect (len + pred len) elem
  Alternate an element between the other elements of a vector
  @ sep the element to intersperse
  @ xs the vector to separate with `sep`
  
  ```idris example
  intersperse 0 [1,2,3,4]
  ```

  Totality: total
  Visibility: export
toVect : (n : Nat) -> List a -> Maybe (Vect n a)
  Totality: total
  Visibility: public export
fromList' : Vect len elem -> (l : List elem) -> Vect (length l + len) elem
  Totality: total
  Visibility: public export
fromList : (xs : List elem) -> Vect (length xs) elem
  Convert a list to a vector.
  
  The length of the list should be statically known.
  
  ```idris example
  fromList [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
mapMaybe : (a -> Maybe b) -> Vect len a -> (m : Nat ** Vect m b)
  Map a partial function across a vector, returning those elements for which
  the function had a value.
  
  The first projection of the resulting pair (ie the length) will always be
  at most the length of the input vector. This is not, however, guaranteed
  by the type.
  
  @ f the partial function (expressed by returning `Maybe`)
  @ xs the vector to check for results
  
  ```idris example
  mapMaybe ((find (=='a')) . unpack) (fromList ["abc","ade","bgh","xyz"])
  ```

  Totality: total
  Visibility: export
foldrImpl : (t -> acc -> acc) -> acc -> (acc -> acc) -> Vect n t -> acc
  Totality: total
  Visibility: public export
foldrImplGoLemma : (x : a) -> (xs : Vect n a) -> (f : (a -> b -> b)) -> (e : b) -> (go : (b -> b)) -> go (foldrImpl f e (f x) xs) = foldrImpl f e (go . f x) xs
  Totality: total
  Visibility: export
concat : Vect m (Vect n elem) -> Vect (m * n) elem
  Flatten a vector of equal-length vectors
  
  ```idris example
  concat [[1,2,3], [4,5,6]]
  ```

  Totality: total
  Visibility: public export
foldr1 : (t -> t -> t) -> Vect (S n) t -> t
  Foldr without seeding the accumulator
  
  ```idris example
  foldr1 (-) (fromList [1,2,3])
  ```

  Totality: total
  Visibility: public export
foldl1 : (t -> t -> t) -> Vect (S n) t -> t
  Foldl without seeding the accumulator
  
  ```idris example
  foldl1 (-) (fromList [1,2,3])
  ```

  Totality: total
  Visibility: public export
scanr : (elem -> res -> res) -> res -> Vect len elem -> Vect (S len) res
  The scanr function is similar to foldr, but returns all the intermediate
  accumulator states in the form of a vector. Note the intermediate accumulator
  states appear in the result in reverse order - the first state appears last
  in the result.
  
  ```idris example
  scanr (-) 0 (fromList [1,2,3])
  ```

  Totality: total
  Visibility: public export
scanr1 : (elem -> elem -> elem) -> Vect len elem -> Vect len elem
  The scanr1 function is a variant of scanr that doesn't require an explicit
  starting value.
  It assumes the last element of the vector to be the starting value and then
  starts the fold with the element preceding it.
  
  ```idris example
  scanr1 (-) (fromList [1,2,3])
  ```

  Totality: total
  Visibility: public export
scanl : (res -> elem -> res) -> res -> Vect len elem -> Vect (S len) res
  The scanl function is similar to foldl, but returns all the intermediate
  accumulator states in the form of a vector.
  
  ```idris example
  scanl (-) 0 (fromList [1,2,3])
  ```

  Totality: total
  Visibility: public export
scanl1 : (elem -> elem -> elem) -> Vect len elem -> Vect len elem
  The scanl1 function is a variant of scanl that doesn't require an explicit
  starting value.
  It assumes the first element of the vector to be the starting value and then
  starts the fold with the element following it.
  
  ```idris example
  scanl1 (-) (fromList [1,2,3])
  ```

  Totality: total
  Visibility: public export
lookupBy : (key -> key -> Bool) -> key -> Vect n (key, val) -> Maybe val
  Find the association of some key with a user-provided comparison
  @ p the comparison operator for keys (True if they match)
  @ e the key to look for
  
  ```idris example
  lookupBy (==) 2 [(1, 'a'), (2, 'b'), (3, 'c')]
  ```

  Totality: total
  Visibility: public export
lookup : Eq key => key -> Vect n (key, val) -> Maybe val
  Find the assocation of some key using the default Boolean equality test
  
  ```idris example
  lookup 3 [(1, 'a'), (2, 'b'), (3, 'c')]
  ```

  Totality: total
  Visibility: public export
hasAnyBy : (elem -> elem -> Bool) -> Vect m elem -> Vect len elem -> Bool
  Check if any element of xs is found in elems by a user-provided comparison
  @ p the comparison operator
  @ elems the vector to search
  @ xs what to search for
  
  ```idris example
  hasAnyBy (==) [2,5] [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
hasAny : Eq elem => Vect m elem -> Vect len elem -> Bool
  Check if any element of xs is found in elems using the default Boolean equality test
  
  ```idris example
  hasAny [2,5] [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
find : (elem -> Bool) -> Vect len elem -> Maybe elem
  Find the first element of the vector that satisfies some test
  @ p the test to satisfy
  
  ```idris example
  find (== 3) [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
findIndex : (elem -> Bool) -> Vect len elem -> Maybe (Fin len)
  Find the index of the first element of the vector that satisfies some test
  
  ```idris example
  findIndex (== 3) [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
findIndices : (elem -> Bool) -> Vect m elem -> List (Fin m)
  Find the indices of all elements that satisfy some test
  
  ```idris example
  findIndices (< 3) [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
elemIndexBy : (elem -> elem -> Bool) -> elem -> Vect m elem -> Maybe (Fin m)
  Find the index of the first element of the vector that satisfies some test
  
  ```idris example
  elemIndexBy (==) 3 [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
elemIndex : Eq elem => elem -> Vect m elem -> Maybe (Fin m)
  Find the index of the first element of the vector equal to the given one.
  
  ```idris example
  elemIndex 3 [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
elemIndicesBy : (elem -> elem -> Bool) -> elem -> Vect m elem -> List (Fin m)
  Find the indices of all elements that satisfy some test
  
  ```idris example
  elemIndicesBy (<=) 3 [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
elemIndices : Eq elem => elem -> Vect m elem -> List (Fin m)
  Find the indices of all elements uquals to the given one
  
  ```idris example
  elemIndices 3 [1,2,3,4,3]
  ```

  Totality: total
  Visibility: public export
filter : (elem -> Bool) -> Vect len elem -> (p : Nat ** Vect p elem)
  Find all elements of a vector that satisfy some test
  
  ```idris example
  filter (< 3) (fromList [1,2,3,4])
  ```

  Totality: total
  Visibility: public export
nubBy : (elem -> elem -> Bool) -> Vect len elem -> (p : Nat ** Vect p elem)
  Make the elements of some vector unique by some test
  
  ```idris example
  nubBy (==) (fromList [1,2,2,3,4,4])
  ```

  Totality: total
  Visibility: public export
nub : Eq elem => Vect len elem -> (p : Nat ** Vect p elem)
  Make the elements of some vector unique by the default Boolean equality
  
  ```idris example
  nub (fromList [1,2,2,3,4,4])
  ```

  Totality: total
  Visibility: public export
deleteBy : (elem -> elem -> Bool) -> elem -> Vect len elem -> (p : Nat ** Vect p elem)
  Delete first element from list according to some test
  
  ```idris example
  deleteBy (<) 3 (fromList [1,2,2,3,4,4])
  ```

  Totality: total
  Visibility: public export
delete : Eq elem => elem -> Vect len elem -> (p : Nat ** Vect p elem)
  Delete first element from list equal to the given one
  
  ```idris example
  delete 2 (fromList [1,2,2,3,4,4])
  ```

  Totality: total
  Visibility: public export
splitAt : (n : Nat) -> Vect (n + m) elem -> (Vect n elem, Vect m elem)
  A tuple where the first element is a `Vect` of the `n` first elements and
  the second element is a `Vect` of the remaining elements of the original.
  It is equivalent to `(take n xs, drop n xs)` (`splitAtTakeDrop`),
  but is more efficient.
  
  @ n   the index to split at
  @ xs  the `Vect` to split in two
  
  ```idris example
  splitAt 2 (fromList [1,2,3,4])
  ```

  Totality: total
  Visibility: public export
partition : (elem -> Bool) -> Vect len elem -> ((p : Nat ** Vect p elem), (q : Nat ** Vect q elem))
  A tuple where the first element is a `Vect` of the `n` elements passing given test
  and the second element is a `Vect` of the remaining elements of the original.
  
  ```idris example
  partition (== 2) (fromList [1,2,3,2,4])
  ```

  Totality: total
  Visibility: public export
kSplits : (k : Nat) -> (n : Nat) -> Vect (k * n) a -> Vect k (Vect n a)
  Split a vector whose length is a multiple of two numbers, k times n, into k
  sections of length n.
  
  ```idris example
  > kSplits 2 4 [1, 2, 3, 4, 5, 6, 7, 8]
  [[1, 2, 3, 4], [5, 6, 7, 8]]
  ```

  Totality: total
  Visibility: public export
nSplits : (k : Nat) -> (n : Nat) -> Vect (k * n) a -> Vect n (Vect k a)
  Split a vector whose length is a multiple of two numbers, k times n, into n
  sections of length k.
  
  ```idris example
  > nSplits 2 4 [1, 2, 3, 4, 5, 6, 7, 8]
  [[1, 5], [2, 6], [3, 7], [4, 8]]
  ```

  Totality: total
  Visibility: public export
isPrefixOfBy : (elem -> elem -> Bool) -> Vect m elem -> Vect len elem -> Bool
  Verify vector prefix
  
  ```idris example
  isPrefixOfBy (==) (fromList [1,2]) (fromList [1,2,3,4])
  ```

  Totality: total
  Visibility: public export
isPrefixOf : Eq elem => Vect m elem -> Vect len elem -> Bool
  Verify vector prefix
  
  ```idris example
  isPrefixOf (fromList [1,2]) (fromList [1,2,3,4])
  ```

  Totality: total
  Visibility: public export
isSuffixOfBy : (elem -> elem -> Bool) -> Vect m elem -> Vect len elem -> Bool
  Verify vector suffix
  
  ```idris example
  isSuffixOfBy (==) (fromList [3,4]) (fromList [1,2,3,4])
  ```

  Totality: total
  Visibility: public export
isSuffixOf : Eq elem => Vect m elem -> Vect len elem -> Bool
  Verify vector suffix
  
  ```idris example
  isSuffixOf (fromList [3,4]) (fromList [1,2,3,4])
  ```

  Totality: total
  Visibility: public export
maybeToVect : Maybe elem -> (p : Nat ** Vect p elem)
  Convert Maybe type into Vect
  
  ```idris example
  maybeToVect (Just 2)
  ```

  Totality: total
  Visibility: public export
vectToMaybe : Vect len elem -> Maybe elem
  Convert first element of Vect (if exists) into Maybe.
  
  ```idris example
  vectToMaybe [2]
  ```

  Totality: total
  Visibility: public export
catMaybes : Vect n (Maybe elem) -> (p : Nat ** Vect p elem)
  Filter out Nothings from Vect and unwrap the Justs
  
  ```idris example
  catMaybes [Just 1, Just 2, Nothing, Nothing, Just 5]
  ```

  Totality: total
  Visibility: public export
diag : Vect len (Vect len elem) -> Vect len elem
  Get diagonal elements
  
  ```idris example
  diag [[1,2,3], [4,5,6], [7,8,9]]
  ```

  Totality: total
  Visibility: public export
tabulate : (Fin len -> a) -> Vect len a
  Totality: total
  Visibility: public export
range : Vect len (Fin len)
  Totality: total
  Visibility: public export
tabulate : (Subset Nat (\{arg:0} => LT {arg:0} len) -> a) -> Vect len a
  Totality: total
  Visibility: public export
range : Vect len (Subset Nat (\{arg:0} => LT {arg:0} len))
  Totality: total
  Visibility: public export
zipWithIndexLinear : (0 f : (a -> a -> {a:7178})) -> (xs : Vect n a) -> (ys : Vect n a) -> (i : Fin n) -> index i (zipWith f xs ys) = f (index i xs) (index i ys)
  Totality: total
  Visibility: export
zipWith3IndexLinear : (0 f : (a -> a -> a -> {a:7281})) -> (xs : Vect n a) -> (ys : Vect n a) -> (zs : Vect n a) -> (i : Fin n) -> index i (zipWith3 f xs ys zs) = f (index i xs) (index i ys) (index i zs)
  Totality: total
  Visibility: export
permute : Vect len a -> Vect len (Fin len) -> Vect len a
  Rearrange the elements of a vector according to some permutation of its
  indices.
  @ v the vector whose elements to rearrange
  @ p the permutation to apply
  
  ```idris example
  > permute ['a', 'b', 'c', 'd'] [0, 3, 2, 1]
  ['a', 'd' , 'c' ,'b']
  ```

  Totality: total
  Visibility: export
transpose : Vect m (Vect n elem) -> Vect n (Vect m elem)
  Transpose a `Vect` of `Vect`s, turning rows into columns and vice versa.
  
  This is like zipping all the inner `Vect`s together and is equivalent to `traverse id` (`transposeTraverse`).
  
  As the types ensure rectangularity, this is an involution, unlike `Prelude.List.transpose`.
  
  ```idris example
  transpose [[1,2], [3,4], [5,6], [7,8]]
  ```

  Totality: total
  Visibility: public export
exactLength : (len : Nat) -> Vect m a -> Maybe (Vect len a)
  Totality: total
  Visibility: export
overLength : (len : Nat) -> Vect m a -> Maybe (p : Nat ** Vect (plus p len) a)
  If the given Vect is at least the required length, return a Vect with
  at least that length in its type, otherwise return Nothing
  @len the required length
  @xs the vector with the desired length

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Vect(source)
Reexports
import public Data.Fin
import public Data.Zippable
Definitions
data Vect : Nat -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Vect 0 elem
  Empty vector
  
(::) : elem -> Vect len elem -> Vect (S len) elem
  A non-empty vector of length `S len`, consisting of a head element and
  the rest of the list, of length `len`.

  Hints:
  
Applicative (Vect k)
  
Biinjective (::)
  
DecEq a => DecEq (Vect n a)
  
Eq a => Eq (Vect n a)
  
Foldable (Vect n)
  
Functor (Vect n)
  
Injective ((x ::))
  
Injective (\x => x :: xs)
  
Monad (Vect k)
  
Monoid a => Monoid (Vect k a)
  
Ord elem => Ord (Vect len elem)
  
Semigroup a => Semigroup (Vect k a)
  
Show elem => Show (Vect len elem)
  
Traversable (Vect k)
  
Zippable (Vect k)
length : Vect len elem -> Nat
  Totality: total
  Visibility: public export
lengthCorrect : (xs : Vect len elem) -> length xs = len
  Show that the length function on vectors in fact calculates the length

  Totality: total
  Visibility: export
invertVectZ : (xs : Vect 0 a) -> xs = []
  Totality: total
  Visibility: export
tail : Vect (S len) elem -> Vect len elem
  All but the first element of the vector
  
  ```idris example
  tail [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
head : Vect (S len) elem -> elem
  Only the first element of the vector
  
  ```idris example
  head [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
invertVectS : (xs : Vect (S n) a) -> xs = head xs :: tail xs
  Totality: total
  Visibility: export
last : Vect (S len) elem -> elem
  The last element of the vector
  
  ```idris example
  last [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
init : Vect (S len) elem -> Vect len elem
  All but the last element of the vector
  
  ```idris example
  init [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
take : (n : Nat) -> Vect (n + m) type -> Vect n type
  Extract the first `n` elements of a Vect.

  Totality: total
  Visibility: public export
take : (n : Nat) -> Stream a -> Vect n a
  Take precisely n elements from the stream.
  @ n how many elements to take
  @ xs the stream

  Totality: total
  Visibility: public export
drop : (n : Nat) -> Vect (n + m) elem -> Vect m elem
  Drop the first `n` elements of a Vect.

  Totality: total
  Visibility: public export
drop' : (n : Nat) -> Vect l elem -> Vect (minus l n) elem
  Drop up to the first `n` elements of a Vect.

  Totality: total
  Visibility: public export
allFins : (n : Nat) -> Vect n (Fin n)
  Generate all of the Fin elements as a Vect whose length is the number of
  elements.
  
  Useful, for example, when one wants all the indices for specific Vect.

  Totality: total
  Visibility: public export
index : Fin len -> Vect len elem -> elem
  Extract a particular element from a vector
  
  ```idris example
  index 1 [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
insertAt : Fin (S len) -> elem -> Vect len elem -> Vect (S len) elem
  Insert an element at a particular index
  
  ```idris example
  insertAt 1 8 [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
deleteAt : Fin (S len) -> Vect (S len) elem -> Vect len elem
  Construct a new vector consisting of all but the indicated element
  
  ```idris example
  deleteAt 1 [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
replaceAt : Fin len -> elem -> Vect len elem -> Vect len elem
  Replace an element at a particlar index with another
  
  ```idris example
  replaceAt 1 8 [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
updateAt : Fin len -> (elem -> elem) -> Vect len elem -> Vect len elem
  Replace the element at a particular index with the result of applying a function to it
  @ i the index to replace at
  @ f the update function
  @ xs the vector to replace in
  
  ```idris example
  updateAt 1 (+10) [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
(++) : Vect m elem -> Vect n elem -> Vect (m + n) elem
  Append two vectors
  
  ```idris example
  [1,2,3,4] ++ [5,6]
  ```

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
snoc : Vect n a -> a -> Vect (S n) a
  Add an element at the end of the vector.
  The main use case for it is to get the expected type signature
  `Vect n a -> a -> Vect (S n) a` instead of
  `Vect n a -> a -> Vect (n + 1) a` which you get by using `++ [x]`
  
  Snoc gets its name by reversing `cons`, indicating we are
  tacking on the element at the end rather than the begining.
  `append` would also be a suitable name.
  
  @ xs The vector to be appended
  @ v The value to append

  Totality: total
  Visibility: public export
unsnoc : Vect (S n) a -> (Vect n a, a)
  Pop the last element from a vector. This is the opposite of `snoc`, in that
  `(uncurry snoc) unsnoc xs` is `xs`. It is equivalent to `(init xs, last xs)`,
  but traverses the vector once.
  
  @ xs The vector to pop the element from.

  Totality: total
  Visibility: public export
replicate : (len : Nat) -> elem -> Vect len elem
  Repeat some value some number of times.
  
  @ len the number of times to repeat it
  @ x the value to repeat
  
  ```idris example
  replicate 4 1
  ```

  Totality: total
  Visibility: public export
mergeBy : (elem -> elem -> Ordering) -> Vect n elem -> Vect m elem -> Vect (n + m) elem
  Merge two ordered vectors
  
  ```idris example
  mergeBy compare (fromList [1,3,5]) (fromList [2,3,4,5,6])
  ```

  Totality: total
  Visibility: export
merge : Ord elem => Vect n elem -> Vect m elem -> Vect (n + m) elem
  Totality: total
  Visibility: export
replaceAtSameIndex : (xs : Vect n a) -> (i : Fin n) -> (0 y : a) -> index i (replaceAt i y xs) = y
  Totality: total
  Visibility: export
replaceAtDiffIndexPreserves : (xs : Vect n a) -> (i : Fin n) -> (j : Fin n) -> Not (i = j) -> (0 y : a) -> index i (replaceAt j y xs) = index i xs
  Totality: total
  Visibility: export
reverseOnto : Vect n elem -> Vect m elem -> Vect (n + m) elem
  Reverse the second vector, prepending the result to the first.
  
  ```idris example
  reverseOnto [0, 1] [10, 11, 12]
  ```

  Totality: total
  Visibility: public export
reverse : Vect len elem -> Vect len elem
  Reverse the order of the elements of a vector
  
  ```idris example
  reverse [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
intersperse : elem -> Vect len elem -> Vect (len + pred len) elem
  Alternate an element between the other elements of a vector
  @ sep the element to intersperse
  @ xs the vector to separate with `sep`
  
  ```idris example
  intersperse 0 [1,2,3,4]
  ```

  Totality: total
  Visibility: export
toVect : (n : Nat) -> List a -> Maybe (Vect n a)
  Totality: total
  Visibility: public export
fromList' : Vect len elem -> (l : List elem) -> Vect (length l + len) elem
  Totality: total
  Visibility: public export
fromList : (xs : List elem) -> Vect (length xs) elem
  Convert a list to a vector.
  
  The length of the list should be statically known.
  
  ```idris example
  fromList [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
mapMaybe : (a -> Maybe b) -> Vect len a -> (m : Nat ** Vect m b)
  Map a partial function across a vector, returning those elements for which
  the function had a value.
  
  The first projection of the resulting pair (ie the length) will always be
  at most the length of the input vector. This is not, however, guaranteed
  by the type.
  
  @ f the partial function (expressed by returning `Maybe`)
  @ xs the vector to check for results
  
  ```idris example
  mapMaybe ((find (=='a')) . unpack) (fromList ["abc","ade","bgh","xyz"])
  ```

  Totality: total
  Visibility: export
foldrImpl : (t -> acc -> acc) -> acc -> (acc -> acc) -> Vect n t -> acc
  Totality: total
  Visibility: public export
foldrImplGoLemma : (x : a) -> (xs : Vect n a) -> (f : (a -> b -> b)) -> (e : b) -> (go : (b -> b)) -> go (foldrImpl f e (f x) xs) = foldrImpl f e (go . f x) xs
  Totality: total
  Visibility: export
concat : Vect m (Vect n elem) -> Vect (m * n) elem
  Flatten a vector of equal-length vectors
  
  ```idris example
  concat [[1,2,3], [4,5,6]]
  ```

  Totality: total
  Visibility: public export
foldr1 : (t -> t -> t) -> Vect (S n) t -> t
  Foldr without seeding the accumulator
  
  ```idris example
  foldr1 (-) (fromList [1,2,3])
  ```

  Totality: total
  Visibility: public export
foldl1 : (t -> t -> t) -> Vect (S n) t -> t
  Foldl without seeding the accumulator
  
  ```idris example
  foldl1 (-) (fromList [1,2,3])
  ```

  Totality: total
  Visibility: public export
scanr : (elem -> res -> res) -> res -> Vect len elem -> Vect (S len) res
  The scanr function is similar to foldr, but returns all the intermediate
  accumulator states in the form of a vector. Note the intermediate accumulator
  states appear in the result in reverse order - the first state appears last
  in the result.
  
  ```idris example
  scanr (-) 0 (fromList [1,2,3])
  ```

  Totality: total
  Visibility: public export
scanr1 : (elem -> elem -> elem) -> Vect len elem -> Vect len elem
  The scanr1 function is a variant of scanr that doesn't require an explicit
  starting value.
  It assumes the last element of the vector to be the starting value and then
  starts the fold with the element preceding it.
  
  ```idris example
  scanr1 (-) (fromList [1,2,3])
  ```

  Totality: total
  Visibility: public export
scanl : (res -> elem -> res) -> res -> Vect len elem -> Vect (S len) res
  The scanl function is similar to foldl, but returns all the intermediate
  accumulator states in the form of a vector.
  
  ```idris example
  scanl (-) 0 (fromList [1,2,3])
  ```

  Totality: total
  Visibility: public export
scanl1 : (elem -> elem -> elem) -> Vect len elem -> Vect len elem
  The scanl1 function is a variant of scanl that doesn't require an explicit
  starting value.
  It assumes the first element of the vector to be the starting value and then
  starts the fold with the element following it.
  
  ```idris example
  scanl1 (-) (fromList [1,2,3])
  ```

  Totality: total
  Visibility: public export
lookupBy : (key -> key -> Bool) -> key -> Vect n (key, val) -> Maybe val
  Find the association of some key with a user-provided comparison
  @ p the comparison operator for keys (True if they match)
  @ e the key to look for
  
  ```idris example
  lookupBy (==) 2 [(1, 'a'), (2, 'b'), (3, 'c')]
  ```

  Totality: total
  Visibility: public export
lookup : Eq key => key -> Vect n (key, val) -> Maybe val
  Find the assocation of some key using the default Boolean equality test
  
  ```idris example
  lookup 3 [(1, 'a'), (2, 'b'), (3, 'c')]
  ```

  Totality: total
  Visibility: public export
hasAnyBy : (elem -> elem -> Bool) -> Vect m elem -> Vect len elem -> Bool
  Check if any element of xs is found in elems by a user-provided comparison
  @ p the comparison operator
  @ elems the vector to search
  @ xs what to search for
  
  ```idris example
  hasAnyBy (==) [2,5] [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
hasAny : Eq elem => Vect m elem -> Vect len elem -> Bool
  Check if any element of xs is found in elems using the default Boolean equality test
  
  ```idris example
  hasAny [2,5] [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
find : (elem -> Bool) -> Vect len elem -> Maybe elem
  Find the first element of the vector that satisfies some test
  @ p the test to satisfy
  
  ```idris example
  find (== 3) [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
findIndex : (elem -> Bool) -> Vect len elem -> Maybe (Fin len)
  Find the index of the first element of the vector that satisfies some test
  
  ```idris example
  findIndex (== 3) [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
findIndices : (elem -> Bool) -> Vect m elem -> List (Fin m)
  Find the indices of all elements that satisfy some test
  
  ```idris example
  findIndices (< 3) [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
elemIndexBy : (elem -> elem -> Bool) -> elem -> Vect m elem -> Maybe (Fin m)
  Find the index of the first element of the vector that satisfies some test
  
  ```idris example
  elemIndexBy (==) 3 [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
elemIndex : Eq elem => elem -> Vect m elem -> Maybe (Fin m)
  Find the index of the first element of the vector equal to the given one.
  
  ```idris example
  elemIndex 3 [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
elemIndicesBy : (elem -> elem -> Bool) -> elem -> Vect m elem -> List (Fin m)
  Find the indices of all elements that satisfy some test
  
  ```idris example
  elemIndicesBy (<=) 3 [1,2,3,4]
  ```

  Totality: total
  Visibility: public export
elemIndices : Eq elem => elem -> Vect m elem -> List (Fin m)
  Find the indices of all elements uquals to the given one
  
  ```idris example
  elemIndices 3 [1,2,3,4,3]
  ```

  Totality: total
  Visibility: public export
filter : (elem -> Bool) -> Vect len elem -> (p : Nat ** Vect p elem)
  Find all elements of a vector that satisfy some test
  
  ```idris example
  filter (< 3) (fromList [1,2,3,4])
  ```

  Totality: total
  Visibility: public export
nubBy : (elem -> elem -> Bool) -> Vect len elem -> (p : Nat ** Vect p elem)
  Make the elements of some vector unique by some test
  
  ```idris example
  nubBy (==) (fromList [1,2,2,3,4,4])
  ```

  Totality: total
  Visibility: public export
nub : Eq elem => Vect len elem -> (p : Nat ** Vect p elem)
  Make the elements of some vector unique by the default Boolean equality
  
  ```idris example
  nub (fromList [1,2,2,3,4,4])
  ```

  Totality: total
  Visibility: public export
deleteBy : (elem -> elem -> Bool) -> elem -> Vect len elem -> (p : Nat ** Vect p elem)
  Delete first element from list according to some test
  
  ```idris example
  deleteBy (<) 3 (fromList [1,2,2,3,4,4])
  ```

  Totality: total
  Visibility: public export
delete : Eq elem => elem -> Vect len elem -> (p : Nat ** Vect p elem)
  Delete first element from list equal to the given one
  
  ```idris example
  delete 2 (fromList [1,2,2,3,4,4])
  ```

  Totality: total
  Visibility: public export
splitAt : (n : Nat) -> Vect (n + m) elem -> (Vect n elem, Vect m elem)
  A tuple where the first element is a `Vect` of the `n` first elements and
  the second element is a `Vect` of the remaining elements of the original.
  It is equivalent to `(take n xs, drop n xs)` (`splitAtTakeDrop`),
  but is more efficient.
  
  @ n   the index to split at
  @ xs  the `Vect` to split in two
  
  ```idris example
  splitAt 2 (fromList [1,2,3,4])
  ```

  Totality: total
  Visibility: public export
partition : (elem -> Bool) -> Vect len elem -> ((p : Nat ** Vect p elem), (q : Nat ** Vect q elem))
  A tuple where the first element is a `Vect` of the `n` elements passing given test
  and the second element is a `Vect` of the remaining elements of the original.
  
  ```idris example
  partition (== 2) (fromList [1,2,3,2,4])
  ```

  Totality: total
  Visibility: public export
kSplits : (k : Nat) -> (n : Nat) -> Vect (k * n) a -> Vect k (Vect n a)
  Split a vector whose length is a multiple of two numbers, k times n, into k
  sections of length n.
  
  ```idris example
  > kSplits 2 4 [1, 2, 3, 4, 5, 6, 7, 8]
  [[1, 2, 3, 4], [5, 6, 7, 8]]
  ```

  Totality: total
  Visibility: public export
nSplits : (k : Nat) -> (n : Nat) -> Vect (k * n) a -> Vect n (Vect k a)
  Split a vector whose length is a multiple of two numbers, k times n, into n
  sections of length k.
  
  ```idris example
  > nSplits 2 4 [1, 2, 3, 4, 5, 6, 7, 8]
  [[1, 5], [2, 6], [3, 7], [4, 8]]
  ```

  Totality: total
  Visibility: public export
isPrefixOfBy : (elem -> elem -> Bool) -> Vect m elem -> Vect len elem -> Bool
  Verify vector prefix
  
  ```idris example
  isPrefixOfBy (==) (fromList [1,2]) (fromList [1,2,3,4])
  ```

  Totality: total
  Visibility: public export
isPrefixOf : Eq elem => Vect m elem -> Vect len elem -> Bool
  Verify vector prefix
  
  ```idris example
  isPrefixOf (fromList [1,2]) (fromList [1,2,3,4])
  ```

  Totality: total
  Visibility: public export
isSuffixOfBy : (elem -> elem -> Bool) -> Vect m elem -> Vect len elem -> Bool
  Verify vector suffix
  
  ```idris example
  isSuffixOfBy (==) (fromList [3,4]) (fromList [1,2,3,4])
  ```

  Totality: total
  Visibility: public export
isSuffixOf : Eq elem => Vect m elem -> Vect len elem -> Bool
  Verify vector suffix
  
  ```idris example
  isSuffixOf (fromList [3,4]) (fromList [1,2,3,4])
  ```

  Totality: total
  Visibility: public export
maybeToVect : Maybe elem -> (p : Nat ** Vect p elem)
  Convert Maybe type into Vect
  
  ```idris example
  maybeToVect (Just 2)
  ```

  Totality: total
  Visibility: public export
vectToMaybe : Vect len elem -> Maybe elem
  Convert first element of Vect (if exists) into Maybe.
  
  ```idris example
  vectToMaybe [2]
  ```

  Totality: total
  Visibility: public export
catMaybes : Vect n (Maybe elem) -> (p : Nat ** Vect p elem)
  Filter out Nothings from Vect and unwrap the Justs
  
  ```idris example
  catMaybes [Just 1, Just 2, Nothing, Nothing, Just 5]
  ```

  Totality: total
  Visibility: public export
diag : Vect len (Vect len elem) -> Vect len elem
  Get diagonal elements
  
  ```idris example
  diag [[1,2,3], [4,5,6], [7,8,9]]
  ```

  Totality: total
  Visibility: public export
tabulate : (Fin len -> a) -> Vect len a
  Totality: total
  Visibility: public export
range : Vect len (Fin len)
  Totality: total
  Visibility: public export
tabulate : (Subset Nat (\{arg:0} => LT {arg:0} len) -> a) -> Vect len a
  Totality: total
  Visibility: public export
range : Vect len (Subset Nat (\{arg:0} => LT {arg:0} len))
  Totality: total
  Visibility: public export
zipWithIndexLinear : (0 f : (a -> a -> {a:7178})) -> (xs : Vect n a) -> (ys : Vect n a) -> (i : Fin n) -> index i (zipWith f xs ys) = f (index i xs) (index i ys)
  Totality: total
  Visibility: export
zipWith3IndexLinear : (0 f : (a -> a -> a -> {a:7281})) -> (xs : Vect n a) -> (ys : Vect n a) -> (zs : Vect n a) -> (i : Fin n) -> index i (zipWith3 f xs ys zs) = f (index i xs) (index i ys) (index i zs)
  Totality: total
  Visibility: export
permute : Vect len a -> Vect len (Fin len) -> Vect len a
  Rearrange the elements of a vector according to some permutation of its
  indices.
  @ v the vector whose elements to rearrange
  @ p the permutation to apply
  
  ```idris example
  > permute ['a', 'b', 'c', 'd'] [0, 3, 2, 1]
  ['a', 'd' , 'c' ,'b']
  ```

  Totality: total
  Visibility: export
transpose : Vect m (Vect n elem) -> Vect n (Vect m elem)
  Transpose a `Vect` of `Vect`s, turning rows into columns and vice versa.
  
  This is like zipping all the inner `Vect`s together and is equivalent to `traverse id` (`transposeTraverse`).
  
  As the types ensure rectangularity, this is an involution, unlike `Prelude.List.transpose`.
  
  ```idris example
  transpose [[1,2], [3,4], [5,6], [7,8]]
  ```

  Totality: total
  Visibility: public export
exactLength : (len : Nat) -> Vect m a -> Maybe (Vect len a)
  Totality: total
  Visibility: export
overLength : (len : Nat) -> Vect m a -> Maybe (p : Nat ** Vect (plus p len) a)
  If the given Vect is at least the required length, return a Vect with
  at least that length in its type, otherwise return Nothing
  @len the required length
  @xs the vector with the desired length

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Data.Zippable.html b/base/docs/Data.Zippable.html
index 75b0aa4145..149d451deb 100644
--- a/base/docs/Data.Zippable.html
+++ b/base/docs/Data.Zippable.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Zippable(source)
Definitions
interface Zippable : (Type -> Type) -> Type
  The `Zippable` interface describes how you can combine and split the
  elements in a parameterised type.
  @ z the parameterised type

  Parameters: z
Methods:
  
zipWith : (a -> b -> c) -> z a -> z b -> z c
  Combine two parameterised types by applying a function.
  @ z the parameterised type
  @ func the function to combine elements with
  
zip : z a -> z b -> z (a, b)
  Combine two parameterised types into a parameterised type of pairs.
  @ z the parameterised type

  Fixity Declaration: infixr operator, level 6
  
zipWith3 : (a -> b -> c -> d) -> z a -> z b -> z c -> z d
  Combine three parameterised types by applying a function.
  @ z the parameterised type
  @ func the function to combine elements with
  
zip3 : z a -> z b -> z c -> z (a, (b, c))
  Combine three parameterised types into a parameterised type of triplets.
  @ z the parameterised type
  
unzipWith : (a -> (b, c)) -> z a -> (z b, z c)
  Split a parameterised type by applying a function into a pair of
  parameterised types.
  @ z the parameterised type
  @ func the function to split elements with
  
unzip : z (a, b) -> (z a, z b)
  Split a parameterised type of pairs into a pair of parameterised types.
  @ z the parameterised type
  
unzipWith3 : (a -> (b, (c, d))) -> z a -> (z b, (z c, z d))
  Split a parameterised type by applying a function into a triplet of
  parameterised types.
  @ z the parameterised type
  @ func the function to split elements with
  
unzip3 : z (a, (b, c)) -> (z a, (z b, z c))
  Split a parameterised type of triplets into a triplet of parameterised
  types.
  @ z the parameterised type

Implementations:
  
Ord k => Zippable (SortedMap k)
  
Zippable LazyList
  
Zippable Stream
  
Zippable Colist1
  
Zippable Colist
  
Zippable (Either a)
  
Semigroup a => Zippable (These a)
  
Zippable (Vect k)
  
Zippable List
  
Zippable List1
  
Semigroup a => Zippable (Pair a)
  
Zippable Maybe
  
Zippable SnocList
zipWith : Zippable z => (a -> b -> c) -> z a -> z b -> z c
  Combine two parameterised types by applying a function.
  @ z the parameterised type
  @ func the function to combine elements with

  Totality: total
  Visibility: public export
zip : Zippable z => z a -> z b -> z (a, b)
  Combine two parameterised types into a parameterised type of pairs.
  @ z the parameterised type

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 6
zipWith3 : Zippable z => (a -> b -> c -> d) -> z a -> z b -> z c -> z d
  Combine three parameterised types by applying a function.
  @ z the parameterised type
  @ func the function to combine elements with

  Totality: total
  Visibility: public export
zip3 : Zippable z => z a -> z b -> z c -> z (a, (b, c))
  Combine three parameterised types into a parameterised type of triplets.
  @ z the parameterised type

  Totality: total
  Visibility: public export
unzipWith : Zippable z => (a -> (b, c)) -> z a -> (z b, z c)
  Split a parameterised type by applying a function into a pair of
  parameterised types.
  @ z the parameterised type
  @ func the function to split elements with

  Totality: total
  Visibility: public export
unzip : Zippable z => z (a, b) -> (z a, z b)
  Split a parameterised type of pairs into a pair of parameterised types.
  @ z the parameterised type

  Totality: total
  Visibility: public export
unzipWith3 : Zippable z => (a -> (b, (c, d))) -> z a -> (z b, (z c, z d))
  Split a parameterised type by applying a function into a triplet of
  parameterised types.
  @ z the parameterised type
  @ func the function to split elements with

  Totality: total
  Visibility: public export
unzip3 : Zippable z => z (a, (b, c)) -> (z a, (z b, z c))
  Split a parameterised type of triplets into a triplet of parameterised
  types.
  @ z the parameterised type

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Zippable(source)
Definitions
interface Zippable : (Type -> Type) -> Type
  The `Zippable` interface describes how you can combine and split the
  elements in a parameterised type.
  @ z the parameterised type

  Parameters: z
Methods:
  
zipWith : (a -> b -> c) -> z a -> z b -> z c
  Combine two parameterised types by applying a function.
  @ z the parameterised type
  @ func the function to combine elements with
  
zip : z a -> z b -> z (a, b)
  Combine two parameterised types into a parameterised type of pairs.
  @ z the parameterised type

  Fixity Declaration: infixr operator, level 6
  
zipWith3 : (a -> b -> c -> d) -> z a -> z b -> z c -> z d
  Combine three parameterised types by applying a function.
  @ z the parameterised type
  @ func the function to combine elements with
  
zip3 : z a -> z b -> z c -> z (a, (b, c))
  Combine three parameterised types into a parameterised type of triplets.
  @ z the parameterised type
  
unzipWith : (a -> (b, c)) -> z a -> (z b, z c)
  Split a parameterised type by applying a function into a pair of
  parameterised types.
  @ z the parameterised type
  @ func the function to split elements with
  
unzip : z (a, b) -> (z a, z b)
  Split a parameterised type of pairs into a pair of parameterised types.
  @ z the parameterised type
  
unzipWith3 : (a -> (b, (c, d))) -> z a -> (z b, (z c, z d))
  Split a parameterised type by applying a function into a triplet of
  parameterised types.
  @ z the parameterised type
  @ func the function to split elements with
  
unzip3 : z (a, (b, c)) -> (z a, (z b, z c))
  Split a parameterised type of triplets into a triplet of parameterised
  types.
  @ z the parameterised type

Implementations:
  
Ord k => Zippable (SortedMap k)
  
Zippable LazyList
  
Zippable Stream
  
Zippable Colist1
  
Zippable Colist
  
Zippable (Either a)
  
Semigroup a => Zippable (These a)
  
Zippable (Vect k)
  
Zippable List
  
Zippable List1
  
Semigroup a => Zippable (Pair a)
  
Zippable Maybe
  
Zippable SnocList
zipWith : Zippable z => (a -> b -> c) -> z a -> z b -> z c
  Combine two parameterised types by applying a function.
  @ z the parameterised type
  @ func the function to combine elements with

  Totality: total
  Visibility: public export
zip : Zippable z => z a -> z b -> z (a, b)
  Combine two parameterised types into a parameterised type of pairs.
  @ z the parameterised type

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 6
zipWith3 : Zippable z => (a -> b -> c -> d) -> z a -> z b -> z c -> z d
  Combine three parameterised types by applying a function.
  @ z the parameterised type
  @ func the function to combine elements with

  Totality: total
  Visibility: public export
zip3 : Zippable z => z a -> z b -> z c -> z (a, (b, c))
  Combine three parameterised types into a parameterised type of triplets.
  @ z the parameterised type

  Totality: total
  Visibility: public export
unzipWith : Zippable z => (a -> (b, c)) -> z a -> (z b, z c)
  Split a parameterised type by applying a function into a pair of
  parameterised types.
  @ z the parameterised type
  @ func the function to split elements with

  Totality: total
  Visibility: public export
unzip : Zippable z => z (a, b) -> (z a, z b)
  Split a parameterised type of pairs into a pair of parameterised types.
  @ z the parameterised type

  Totality: total
  Visibility: public export
unzipWith3 : Zippable z => (a -> (b, (c, d))) -> z a -> (z b, (z c, z d))
  Split a parameterised type by applying a function into a triplet of
  parameterised types.
  @ z the parameterised type
  @ func the function to split elements with

  Totality: total
  Visibility: public export
unzip3 : Zippable z => z (a, (b, c)) -> (z a, (z b, z c))
  Split a parameterised type of triplets into a triplet of parameterised
  types.
  @ z the parameterised type

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Debug.Trace.html b/base/docs/Debug.Trace.html
index c32bfb8b57..177cdafc57 100644
--- a/base/docs/Debug.Trace.html
+++ b/base/docs/Debug.Trace.html
@@ -61,4 +61,4 @@
 
 
 
-
Debug.Trace(source)
Definitions
trace : String -> a -> a
  Totality: total
  Visibility: export
traceValBy : (a -> String) -> a -> a
  Totality: total
  Visibility: export
traceVal : Show a => a -> a
  Totality: total
  Visibility: export

\ No newline at end of file
+
Debug.Trace(source)
Definitions
trace : String -> a -> a
  Totality: total
  Visibility: export
traceValBy : (a -> String) -> a -> a
  Totality: total
  Visibility: export
traceVal : Show a => a -> a
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Decidable.Decidable.html b/base/docs/Decidable.Decidable.html
index 514c36004a..d99480e432 100644
--- a/base/docs/Decidable.Decidable.html
+++ b/base/docs/Decidable.Decidable.html
@@ -61,4 +61,4 @@
 
 
 
-
Decidable.Decidable(source)
Definitions
isNo : Dec a -> Bool
  Totality: total
  Visibility: public export
isYes : Dec a -> Bool
  Totality: total
  Visibility: public export
data IsYes : Dec a -> Type
  Proof that some `Dec` is actually `Yes`

  Totality: total
  Visibility: public export
  Constructor: 
ItIsYes : IsYes (Yes prf)

  Hint: 
Uninhabited (IsYes (No contra))
isItYes : (v : Dec a) -> Dec (IsYes v)
  Decide whether a 'Dec' is 'Yes'

  Totality: total
  Visibility: public export
IsDecidable : (k : Nat) -> (ts : Vect k Type) -> Rel ts -> Type
  An n-ary relation is decidable if we can make a `Dec`
  of its result type for each combination of inputs

  Totality: total
  Visibility: public export
interface Decidable : (k : Nat) -> (ts : Vect k Type) -> Fun ts Type -> Type
  Interface for decidable n-ary Relations

  Parameters: k, ts, p
Methods:
  
decide : IsDecidable k ts p

Implementations:
  
Decidable 2 [Nat, Nat] LTE
  
Decidable 2 [Nat, Nat] LT
  
Decidable 2 [Fin k, Fin k] FinLTE
decide : Decidable k ts p => IsDecidable k ts p
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Decidable.Decidable(source)
Definitions
isNo : Dec a -> Bool
  Totality: total
  Visibility: public export
isYes : Dec a -> Bool
  Totality: total
  Visibility: public export
data IsYes : Dec a -> Type
  Proof that some `Dec` is actually `Yes`

  Totality: total
  Visibility: public export
  Constructor: 
ItIsYes : IsYes (Yes prf)

  Hint: 
Uninhabited (IsYes (No contra))
isItYes : (v : Dec a) -> Dec (IsYes v)
  Decide whether a 'Dec' is 'Yes'

  Totality: total
  Visibility: public export
IsDecidable : (k : Nat) -> (ts : Vect k Type) -> Rel ts -> Type
  An n-ary relation is decidable if we can make a `Dec`
  of its result type for each combination of inputs

  Totality: total
  Visibility: public export
interface Decidable : (k : Nat) -> (ts : Vect k Type) -> Fun ts Type -> Type
  Interface for decidable n-ary Relations

  Parameters: k, ts, p
Methods:
  
decide : IsDecidable k ts p

Implementations:
  
Decidable 2 [Nat, Nat] LTE
  
Decidable 2 [Nat, Nat] LT
  
Decidable 2 [Fin k, Fin k] FinLTE
decide : Decidable k ts p => IsDecidable k ts p
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Decidable.Equality.Core.html b/base/docs/Decidable.Equality.Core.html
index 9ffd341557..bec89251f7 100644
--- a/base/docs/Decidable.Equality.Core.html
+++ b/base/docs/Decidable.Equality.Core.html
@@ -61,4 +61,4 @@
 
 
 
-
Decidable.Equality.Core(source)
Definitions
interface DecEq : Type -> Type
  Decision procedures for propositional equality

  Parameters: t
Methods:
  
decEq : (x1 : t) -> (x2 : t) -> Dec (x1 = x2)
  Decide whether two elements of `t` are propositionally equal

Implementations:
  
DecEq (Elem x xs)
  
DecEq (Elem x sx)
  
DecEq (Elem x xs)
  
DecEq (Elem x xs)
  
DecEq ()
  
DecEq Bool
  
DecEq Nat
  
DecEq t => DecEq (Maybe t)
  
(DecEq t, DecEq s) => DecEq (Either t s)
  
DecEq t => DecEq s => DecEq (These t s)
  
(DecEq a, DecEq b) => DecEq (a, b)
  
DecEq a => DecEq (List a)
  
DecEq a => DecEq (List1 a)
  
DecEq a => DecEq (SnocList a)
  
DecEq Int
  
DecEq Bits8
  
DecEq Bits16
  
DecEq Bits32
  
DecEq Bits64
  
DecEq Int8
  
DecEq Int16
  
DecEq Int32
  
DecEq Int64
  
DecEq Char
  
DecEq Integer
  
DecEq String
  
DecEq a => DecEq (Vect n a)
  
DecEq (Fin n)
decEq : DecEq t => (x1 : t) -> (x2 : t) -> Dec (x1 = x2)
  Decide whether two elements of `t` are propositionally equal

  Totality: total
  Visibility: public export
negEqSym : Not (a = b) -> Not (b = a)
  The negation of equality is symmetric (follows from symmetry of equality)

  Totality: total
  Visibility: export
decEqSelfIsYes : {auto {conArg:2618} : DecEq a} -> decEq x x = Yes Refl
  Everything is decidably equal to itself

  Totality: total
  Visibility: export
decEqContraIsNo : {auto {conArg:2682} : DecEq a} -> Not (x = y) -> (p : x = y -> Void ** decEq x y = No p)
  If you have a proof of inequality, you're sure that `decEq` would give a `No`.

  Totality: total
  Visibility: export
decEqCong : {auto 0 _ : Injective f} -> Dec (x = y) -> Dec (f x = f y)
  Totality: total
  Visibility: public export
decEqInj : {auto 0 _ : Injective f} -> Dec (f x = f y) -> Dec (x = y)
  Totality: total
  Visibility: public export
decEqCong2 : {auto 0 _ : Biinjective f} -> Dec (x = y) -> Lazy (Dec (v = w)) -> Dec (f x v = f y w)
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Decidable.Equality.Core(source)
Definitions
interface DecEq : Type -> Type
  Decision procedures for propositional equality

  Parameters: t
Methods:
  
decEq : (x1 : t) -> (x2 : t) -> Dec (x1 = x2)
  Decide whether two elements of `t` are propositionally equal

Implementations:
  
DecEq (Elem x xs)
  
DecEq (Elem x sx)
  
DecEq (Elem x xs)
  
DecEq (Elem x xs)
  
DecEq ()
  
DecEq Bool
  
DecEq Nat
  
DecEq t => DecEq (Maybe t)
  
(DecEq t, DecEq s) => DecEq (Either t s)
  
DecEq t => DecEq s => DecEq (These t s)
  
(DecEq a, DecEq b) => DecEq (a, b)
  
DecEq a => DecEq (List a)
  
DecEq a => DecEq (List1 a)
  
DecEq a => DecEq (SnocList a)
  
DecEq Int
  
DecEq Bits8
  
DecEq Bits16
  
DecEq Bits32
  
DecEq Bits64
  
DecEq Int8
  
DecEq Int16
  
DecEq Int32
  
DecEq Int64
  
DecEq Char
  
DecEq Integer
  
DecEq String
  
DecEq a => DecEq (Vect n a)
  
DecEq (Fin n)
decEq : DecEq t => (x1 : t) -> (x2 : t) -> Dec (x1 = x2)
  Decide whether two elements of `t` are propositionally equal

  Totality: total
  Visibility: public export
negEqSym : Not (a = b) -> Not (b = a)
  The negation of equality is symmetric (follows from symmetry of equality)

  Totality: total
  Visibility: export
decEqSelfIsYes : {auto {conArg:2618} : DecEq a} -> decEq x x = Yes Refl
  Everything is decidably equal to itself

  Totality: total
  Visibility: export
decEqContraIsNo : {auto {conArg:2682} : DecEq a} -> Not (x = y) -> (p : x = y -> Void ** decEq x y = No p)
  If you have a proof of inequality, you're sure that `decEq` would give a `No`.

  Totality: total
  Visibility: export
decEqCong : {auto 0 _ : Injective f} -> Dec (x = y) -> Dec (f x = f y)
  Totality: total
  Visibility: public export
decEqInj : {auto 0 _ : Injective f} -> Dec (f x = f y) -> Dec (x = y)
  Totality: total
  Visibility: public export
decEqCong2 : {auto 0 _ : Biinjective f} -> Dec (x = y) -> Lazy (Dec (v = w)) -> Dec (f x v = f y w)
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Decidable.Equality.html b/base/docs/Decidable.Equality.html
index 50d2045e9b..bf1d4a153c 100644
--- a/base/docs/Decidable.Equality.html
+++ b/base/docs/Decidable.Equality.html
@@ -61,4 +61,4 @@
 
 
 
-
Decidable.Equality(source)
Reexports
import public Decidable.Equality.Core as Decidable.Equality
Definitions

\ No newline at end of file
+
Decidable.Equality(source)
Reexports
import public Decidable.Equality.Core as Decidable.Equality
Definitions

\ No newline at end of file
diff --git a/base/docs/Deriving.Common.html b/base/docs/Deriving.Common.html
index b5ae1e856e..8560e449ea 100644
--- a/base/docs/Deriving.Common.html
+++ b/base/docs/Deriving.Common.html
@@ -61,4 +61,4 @@
 
 
 
-
Deriving.Common(source)
Definitions
data IsFreeOf : Name -> TTImp -> Type
  IsFreeOf is parametrised by
  @ x  the name of the type variable that the functioral action will change
  @ ty the type that does not contain any mention of x

  Totality: total
  Visibility: export
  Constructor: 
TrustMeFO : IsFreeOf a x
  For now we do not bother keeping precise track of the proof that a type
  is free of x
assert_IsFreeOf : IsFreeOf x ty
  We may need to manufacture proofs and so we provide the `assert` escape hatch.

  Totality: total
  Visibility: export
isFreeOf : (x : Name) -> (ty : TTImp) -> Maybe (IsFreeOf x ty)
  Testing function deciding whether the given term is free of a particular
  variable.

  Totality: total
  Visibility: export
record IsType : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkIsType : Name -> List (Argument Name, Nat) -> List (Name, TTImp) -> IsType

  Projections:
  
.dataConstructors : IsType -> List (Name, TTImp)
  
.parameterNames : IsType -> List (Argument Name, Nat)
  
.typeConstructor : IsType -> Name
.typeConstructor : IsType -> Name
  Totality: total
  Visibility: public export
typeConstructor : IsType -> Name
  Totality: total
  Visibility: public export
.parameterNames : IsType -> List (Argument Name, Nat)
  Totality: total
  Visibility: public export
parameterNames : IsType -> List (Argument Name, Nat)
  Totality: total
  Visibility: public export
.dataConstructors : IsType -> List (Name, TTImp)
  Totality: total
  Visibility: public export
dataConstructors : IsType -> List (Name, TTImp)
  Totality: total
  Visibility: public export
isType : Elaboration m => TTImp -> m IsType
  Totality: total
  Visibility: export
record ConstructorView : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkConstructorView : SnocList (Name, Nat) -> List (Count, Argument TTImp) -> ConstructorView

  Projections:
  
.conArgTypes : ConstructorView -> List (Count, Argument TTImp)
  
.params : ConstructorView -> SnocList (Name, Nat)
.params : ConstructorView -> SnocList (Name, Nat)
  Totality: total
  Visibility: public export
params : ConstructorView -> SnocList (Name, Nat)
  Totality: total
  Visibility: public export
.conArgTypes : ConstructorView -> List (Count, Argument TTImp)
  Totality: total
  Visibility: public export
conArgTypes : ConstructorView -> List (Count, Argument TTImp)
  Totality: total
  Visibility: public export
constructorView : TTImp -> Maybe ConstructorView
  Totality: total
  Visibility: export
withParams : FC -> (Nat -> Maybe TTImp) -> List (Argument Name, Nat) -> TTImp -> TTImp
  Totality: total
  Visibility: export
data HasType : Name -> TTImp -> Type
  Type of proofs that something has a given type

  Totality: total
  Visibility: export
  Constructor: 
TrustMeHT : HasType nm ty
hasType : Elaboration m => (nm : Name) -> m (Maybe (ty : TTImp ** HasType nm ty))
  Totality: total
  Visibility: export
data IsProvable : TTImp -> Type
  Type of proofs that a type is inhabited

  Totality: total
  Visibility: export
  Constructor: 
TrustMeIP : IsProvable ty
isProvable : Elaboration m => (ty : TTImp) -> m (Maybe (IsProvable ty))
  Totality: total
  Visibility: export
data HasImplementation : (a -> Type) -> TTImp -> Type
  Type of proofs that a type satisfies a constraint.
  Internally it's vacuous. We don't export the constructor so
  that users cannot manufacture buggy proofs.

  Totality: total
  Visibility: export
  Constructor: 
TrustMeHI : HasImplementation intf t
assert_hasImplementation : HasImplementation intf t
  We may need to manufacture proofs and so we provide the `assert` escape hatch.

  Totality: total
  Visibility: export
hasImplementation : Elaboration m => (intf : (a -> Type)) -> (t : TTImp) -> m (Maybe (HasImplementation intf t))
  Given
  @ intf an interface (e.g. `Functor`, or `Bifunctor`)
  @ t    a term corresponding to a (possibly partially applied) type constructor
  check whether Idris2 can find a proof that t satisfies the interface.

  Totality: total
  Visibility: export
optionallyEta : FC -> Maybe TTImp -> (TTImp -> TTImp) -> TTImp
  Optionally eta-expand if there is no argument available

  Totality: total
  Visibility: export
apply : FC -> TTImp -> List TTImp -> TTImp
  We often apply multiple arguments, this makes things simpler

  Totality: total
  Visibility: export
cleanup : TTImp -> TTImp
  Use unqualified names (useful for more compact printing)

  Totality: total
  Visibility: export
freshName : List Name -> String -> String
  Create fresh names

  Totality: total
  Visibility: export

\ No newline at end of file
+
Deriving.Common(source)
Definitions
data IsFreeOf : Name -> TTImp -> Type
  IsFreeOf is parametrised by
  @ x  the name of the type variable that the functioral action will change
  @ ty the type that does not contain any mention of x

  Totality: total
  Visibility: export
  Constructor: 
TrustMeFO : IsFreeOf a x
  For now we do not bother keeping precise track of the proof that a type
  is free of x
assert_IsFreeOf : IsFreeOf x ty
  We may need to manufacture proofs and so we provide the `assert` escape hatch.

  Totality: total
  Visibility: export
isFreeOf : (x : Name) -> (ty : TTImp) -> Maybe (IsFreeOf x ty)
  Testing function deciding whether the given term is free of a particular
  variable.

  Totality: total
  Visibility: export
record IsType : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkIsType : Name -> List (Argument Name, Nat) -> List (Name, TTImp) -> IsType

  Projections:
  
.dataConstructors : IsType -> List (Name, TTImp)
  
.parameterNames : IsType -> List (Argument Name, Nat)
  
.typeConstructor : IsType -> Name
.typeConstructor : IsType -> Name
  Totality: total
  Visibility: public export
typeConstructor : IsType -> Name
  Totality: total
  Visibility: public export
.parameterNames : IsType -> List (Argument Name, Nat)
  Totality: total
  Visibility: public export
parameterNames : IsType -> List (Argument Name, Nat)
  Totality: total
  Visibility: public export
.dataConstructors : IsType -> List (Name, TTImp)
  Totality: total
  Visibility: public export
dataConstructors : IsType -> List (Name, TTImp)
  Totality: total
  Visibility: public export
isType : Elaboration m => TTImp -> m IsType
  Totality: total
  Visibility: export
record ConstructorView : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkConstructorView : SnocList (Name, Nat) -> List (Count, Argument TTImp) -> ConstructorView

  Projections:
  
.conArgTypes : ConstructorView -> List (Count, Argument TTImp)
  
.params : ConstructorView -> SnocList (Name, Nat)
.params : ConstructorView -> SnocList (Name, Nat)
  Totality: total
  Visibility: public export
params : ConstructorView -> SnocList (Name, Nat)
  Totality: total
  Visibility: public export
.conArgTypes : ConstructorView -> List (Count, Argument TTImp)
  Totality: total
  Visibility: public export
conArgTypes : ConstructorView -> List (Count, Argument TTImp)
  Totality: total
  Visibility: public export
constructorView : TTImp -> Maybe ConstructorView
  Totality: total
  Visibility: export
withParams : FC -> (Nat -> Maybe TTImp) -> List (Argument Name, Nat) -> TTImp -> TTImp
  Totality: total
  Visibility: export
data HasType : Name -> TTImp -> Type
  Type of proofs that something has a given type

  Totality: total
  Visibility: export
  Constructor: 
TrustMeHT : HasType nm ty
hasType : Elaboration m => (nm : Name) -> m (Maybe (ty : TTImp ** HasType nm ty))
  Totality: total
  Visibility: export
data IsProvable : TTImp -> Type
  Type of proofs that a type is inhabited

  Totality: total
  Visibility: export
  Constructor: 
TrustMeIP : IsProvable ty
isProvable : Elaboration m => (ty : TTImp) -> m (Maybe (IsProvable ty))
  Totality: total
  Visibility: export
data HasImplementation : (a -> Type) -> TTImp -> Type
  Type of proofs that a type satisfies a constraint.
  Internally it's vacuous. We don't export the constructor so
  that users cannot manufacture buggy proofs.

  Totality: total
  Visibility: export
  Constructor: 
TrustMeHI : HasImplementation intf t
assert_hasImplementation : HasImplementation intf t
  We may need to manufacture proofs and so we provide the `assert` escape hatch.

  Totality: total
  Visibility: export
hasImplementation : Elaboration m => (intf : (a -> Type)) -> (t : TTImp) -> m (Maybe (HasImplementation intf t))
  Given
  @ intf an interface (e.g. `Functor`, or `Bifunctor`)
  @ t    a term corresponding to a (possibly partially applied) type constructor
  check whether Idris2 can find a proof that t satisfies the interface.

  Totality: total
  Visibility: export
optionallyEta : FC -> Maybe TTImp -> (TTImp -> TTImp) -> TTImp
  Optionally eta-expand if there is no argument available

  Totality: total
  Visibility: export
apply : FC -> TTImp -> List TTImp -> TTImp
  We often apply multiple arguments, this makes things simpler

  Totality: total
  Visibility: export
cleanup : TTImp -> TTImp
  Use unqualified names (useful for more compact printing)

  Totality: total
  Visibility: export
freshName : List Name -> String -> String
  Create fresh names

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Deriving.Foldable.html b/base/docs/Deriving.Foldable.html
index 166c5f17bf..1575ba7706 100644
--- a/base/docs/Deriving.Foldable.html
+++ b/base/docs/Deriving.Foldable.html
@@ -68,4 +68,4 @@
 treeFoldable : Foldable Tree
 treeFoldable = %runElab derive
 ```
-
Reexports
import public Control.Monad.Either
import public Control.Monad.State
import public Data.List1
import public Data.Maybe
import public Data.Morphisms
import public Decidable.Equality
import public Language.Reflection
import public Deriving.Common
Definitions
fromFoldMap : (0 f : (Type -> Type)) -> (Monoid b => (a -> b) -> f a -> b) -> Foldable f
  Totality: total
  Visibility: public export
data Error : Type
  Possible errors for the functor-deriving machinery.

  Totality: total
  Visibility: public export
  Constructors:
  
NotFreeOf : Name -> TTImp -> Error
  
NotAnApplication : TTImp -> Error
  
NotAFoldable : TTImp -> Error
  
NotABifoldable : TTImp -> Error
  
NotFoldableInItsLastArg : TTImp -> Error
  
UnsupportedType : TTImp -> Error
  
NotAFiniteStructure : Error
  
NotAnUnconstrainedValue : Count -> Error
  
InvalidGoal : Error
  
ConfusingReturnType : Error
  
WhenCheckingConstructor : Name -> Error -> Error
  
WhenCheckingArg : TTImp -> Error -> Error

  Hint: 
Show Error
data IsFoldableIn : Name -> Name -> TTImp -> Type
  IsFoldableIn is parametrised by
  @ t  the name of the data type whose constructors are being analysed
  @ x  the name of the type variable that the foldable action will act on
  @ ty the type being analysed
  The inductive type delivers a proof that x can be folded over in ty,
  assuming that t also is foldable.

  Totality: total
  Visibility: public export
  Constructors:
  
FIVar : IsFoldableIn t x (IVar fc x)
  The type variable x occurs alone
  
FIRec : (0 _ : IsAppView ({_:4781}, t) {_:4782} f) -> IsFoldableIn t x arg -> IsFoldableIn t x (IApp fc f arg)
  There is a recursive subtree of type (t a1 ... an u) and u is Foldable in x.
  We do not insist that u is exactly x so that we can deal with nested types
  like the following:
    data Full a = Leaf a | Node (Full (a, a))
    data Term a = Var a | App (Term a) (Term a) | Lam (Term (Maybe a))
  
FIDelayed : IsFoldableIn t x ty -> IsFoldableIn t x (IDelayed fc LLazy ty)
  The subterm is delayed (Lazy only, we can't fold over infinite structures)
  
FIBifold : IsFreeOf x sp -> HasImplementation Bifoldable sp -> IsFoldableIn t x arg1 -> Either (IsFoldableIn t x arg2) (IsFreeOf x arg2) -> IsFoldableIn t x (IApp fc1 (IApp fc2 sp arg1) arg2)
  There are nested subtrees somewhere inside a 3rd party type constructor
  which satisfies the Bifoldable interface
  
FIFold : IsFreeOf x sp -> HasImplementation Foldable sp -> IsFoldableIn t x arg -> IsFoldableIn t x (IApp fc sp arg)
  There are nested subtrees somewhere inside a 3rd party type constructor
  which satisfies the Foldable interface
  
FIFree : IsFreeOf x a -> IsFoldableIn t x a
  A type free of x is trivially Foldable in it
TypeView : Elaboration m => MonadError Error m => MonadState Parameters m => Name -> List (Name, Nat) -> Name -> TTImp -> Type
  When analysing the type of a constructor for the type family t,
  we hope to observe
    1. either that it is foldable in x
    2. or that it is free of x
  If it is not the case, we will use the `MonadError Error` constraint
  to fail with an informative message.

  Totality: total
  Visibility: public export
fromTypeView : {auto elab : Elaboration m} -> {auto error : MonadError Error m} -> {auto cs : MonadState Parameters m} -> (t : Name) -> (ps : List (Name, Nat)) -> (x : Name) -> TypeView ty -> IsFoldableIn t x ty
  Totality: total
  Visibility: export
typeView : {auto elab : Elaboration m} -> {auto error : MonadError Error m} -> {auto cs : MonadState Parameters m} -> (t : Name) -> (ps : List (Name, Nat)) -> (x : Name) -> (ty : TTImp) -> m (TypeView ty)
  Hoping to observe that ty is foldable

  Totality: total
  Visibility: export
derive : {default Private _ : Visibility} -> {default Total _ : TotalReq} -> {default [] _ : List Name} -> Elab (Foldable f)
  Derive an implementation of Foldable for a type constructor.
  This can be used like so:
  ```
  data Tree a = Leaf a | Node (Tree a) (Tree a)
  treeFoldable : Foldable Tree
  treeFoldable = %runElab derive
  ```

  Totality: total
  Visibility: export

\ No newline at end of file
+
Reexports
import public Control.Monad.Either
import public Control.Monad.State
import public Data.List1
import public Data.Maybe
import public Data.Morphisms
import public Decidable.Equality
import public Language.Reflection
import public Deriving.Common
Definitions
fromFoldMap : (0 f : (Type -> Type)) -> (Monoid b => (a -> b) -> f a -> b) -> Foldable f
  Totality: total
  Visibility: public export
data Error : Type
  Possible errors for the functor-deriving machinery.

  Totality: total
  Visibility: public export
  Constructors:
  
NotFreeOf : Name -> TTImp -> Error
  
NotAnApplication : TTImp -> Error
  
NotAFoldable : TTImp -> Error
  
NotABifoldable : TTImp -> Error
  
NotFoldableInItsLastArg : TTImp -> Error
  
UnsupportedType : TTImp -> Error
  
NotAFiniteStructure : Error
  
NotAnUnconstrainedValue : Count -> Error
  
InvalidGoal : Error
  
ConfusingReturnType : Error
  
WhenCheckingConstructor : Name -> Error -> Error
  
WhenCheckingArg : TTImp -> Error -> Error

  Hint: 
Show Error
data IsFoldableIn : Name -> Name -> TTImp -> Type
  IsFoldableIn is parametrised by
  @ t  the name of the data type whose constructors are being analysed
  @ x  the name of the type variable that the foldable action will act on
  @ ty the type being analysed
  The inductive type delivers a proof that x can be folded over in ty,
  assuming that t also is foldable.

  Totality: total
  Visibility: public export
  Constructors:
  
FIVar : IsFoldableIn t x (IVar fc x)
  The type variable x occurs alone
  
FIRec : (0 _ : IsAppView ({_:4781}, t) {_:4782} f) -> IsFoldableIn t x arg -> IsFoldableIn t x (IApp fc f arg)
  There is a recursive subtree of type (t a1 ... an u) and u is Foldable in x.
  We do not insist that u is exactly x so that we can deal with nested types
  like the following:
    data Full a = Leaf a | Node (Full (a, a))
    data Term a = Var a | App (Term a) (Term a) | Lam (Term (Maybe a))
  
FIDelayed : IsFoldableIn t x ty -> IsFoldableIn t x (IDelayed fc LLazy ty)
  The subterm is delayed (Lazy only, we can't fold over infinite structures)
  
FIBifold : IsFreeOf x sp -> HasImplementation Bifoldable sp -> IsFoldableIn t x arg1 -> Either (IsFoldableIn t x arg2) (IsFreeOf x arg2) -> IsFoldableIn t x (IApp fc1 (IApp fc2 sp arg1) arg2)
  There are nested subtrees somewhere inside a 3rd party type constructor
  which satisfies the Bifoldable interface
  
FIFold : IsFreeOf x sp -> HasImplementation Foldable sp -> IsFoldableIn t x arg -> IsFoldableIn t x (IApp fc sp arg)
  There are nested subtrees somewhere inside a 3rd party type constructor
  which satisfies the Foldable interface
  
FIFree : IsFreeOf x a -> IsFoldableIn t x a
  A type free of x is trivially Foldable in it
TypeView : Elaboration m => MonadError Error m => MonadState Parameters m => Name -> List (Name, Nat) -> Name -> TTImp -> Type
  When analysing the type of a constructor for the type family t,
  we hope to observe
    1. either that it is foldable in x
    2. or that it is free of x
  If it is not the case, we will use the `MonadError Error` constraint
  to fail with an informative message.

  Totality: total
  Visibility: public export
fromTypeView : {auto elab : Elaboration m} -> {auto error : MonadError Error m} -> {auto cs : MonadState Parameters m} -> (t : Name) -> (ps : List (Name, Nat)) -> (x : Name) -> TypeView ty -> IsFoldableIn t x ty
  Totality: total
  Visibility: export
typeView : {auto elab : Elaboration m} -> {auto error : MonadError Error m} -> {auto cs : MonadState Parameters m} -> (t : Name) -> (ps : List (Name, Nat)) -> (x : Name) -> (ty : TTImp) -> m (TypeView ty)
  Hoping to observe that ty is foldable

  Totality: total
  Visibility: export
derive : {default Private _ : Visibility} -> {default Total _ : TotalReq} -> {default [] _ : List Name} -> Elab (Foldable f)
  Derive an implementation of Foldable for a type constructor.
  This can be used like so:
  ```
  data Tree a = Leaf a | Node (Tree a) (Tree a)
  treeFoldable : Foldable Tree
  treeFoldable = %runElab derive
  ```

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Deriving.Functor.html b/base/docs/Deriving.Functor.html
index 609ea543ae..1a8772e4a5 100644
--- a/base/docs/Deriving.Functor.html
+++ b/base/docs/Deriving.Functor.html
@@ -68,4 +68,4 @@
 treeFunctor : Functor Tree
 treeFunctor = %runElab derive
 ```
-
Reexports
import public Control.Monad.Either
import public Control.Monad.State
import public Data.Maybe
import public Decidable.Equality
import public Language.Reflection
import public Deriving.Common
Definitions
data Error : Type
  Possible errors for the functor-deriving machinery.

  Totality: total
  Visibility: public export
  Constructors:
  
NotFreeOf : Name -> TTImp -> Error
  
NegativeOccurrence : Name -> TTImp -> Error
  
NotAnApplication : TTImp -> Error
  
NotAFunctor : TTImp -> Error
  
NotABifunctor : TTImp -> Error
  
NotAFunctorInItsLastArg : TTImp -> Error
  
UnsupportedType : TTImp -> Error
  
InvalidGoal : Error
  
ConfusingReturnType : Error
  
WhenCheckingConstructor : Name -> Error -> Error
  
WhenCheckingArg : TTImp -> Error -> Error

  Hint: 
Show Error
data Polarity : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Positive : Polarity
  
Negative : Polarity
not : Polarity -> Polarity
  Totality: total
  Visibility: public export
data IsFunctorialIn : Polarity -> Name -> Name -> TTImp -> Type
  IsFunctorialIn is parametrised by
  @ pol the polarity of the type being analysed. We start in positive polarity
        where occurrences of x are allowed and negate the polarity every time
        we step into the domain of a Pi type.
  @ t  the name of the data type whose constructors are being analysed
  @ x  the name of the type variable that the functioral action will change
  @ ty the type being analysed
  The inductive type delivers a proof that x occurs positively in ty,
  assuming that t also is positive.

  Totality: total
  Visibility: public export
  Constructors:
  
FIVar : IsFunctorialIn Positive t x (IVar fc x)
  The type variable x occurs alone
  
FIRec : (0 _ : IsAppView ({_:4466}, t) {_:4467} f) -> IsFunctorialIn pol t x arg -> IsFunctorialIn Positive t x (IApp fc f arg)
  There is a recursive subtree of type (t a1 ... an u) and u is functorial in x.
  We do not insist that u is exactly x so that we can deal with nested types
  like the following:
    data Full a = Leaf a | Node (Full (a, a))
    data Term a = Var a | App (Term a) (Term a) | Lam (Term (Maybe a))
  
FIDelayed : IsFunctorialIn pol t x ty -> IsFunctorialIn pol t x (IDelayed fc lr ty)
  The subterm is delayed (either Inf or Lazy)
  
FIBifun : IsFreeOf x sp -> HasImplementation Bifunctor sp -> IsFunctorialIn pol t x arg1 -> Either (IsFunctorialIn pol t x arg2) (IsFreeOf x arg2) -> IsFunctorialIn pol t x (IApp fc1 (IApp fc2 sp arg1) arg2)
  There are nested subtrees somewhere inside a 3rd party type constructor
  which satisfies the Bifunctor interface
  
FIFun : IsFreeOf x sp -> HasImplementation Functor sp -> IsFunctorialIn pol t x arg -> IsFunctorialIn pol t x (IApp fc sp arg)
  There are nested subtrees somewhere inside a 3rd party type constructor
  which satisfies the Functor interface
  
FIPi : IsFunctorialIn (not pol) t x a -> IsFunctorialIn pol t x b -> IsFunctorialIn pol t x (IPi fc rig pinfo nm a b)
  A pi type, with no negative occurrence of x in its domain
  
FIFree : IsFreeOf x a -> IsFunctorialIn pol t x a
  A type free of x is trivially Functorial in it
TypeView : Elaboration m => MonadError Error m => MonadState Parameters m => Name -> List (Name, Nat) -> Name -> Polarity -> TTImp -> Type
  When analysing the type of a constructor for the type family t,
  we hope to observe
    1. either that it is functorial in x
    2. or that it is free of x
  If if it is not the case, we will use the `MonadError Error` constraint
  to fail with an informative message.

  Totality: total
  Visibility: public export
fromTypeView : {auto elab : Elaboration m} -> {auto error : MonadError Error m} -> {auto cs : MonadState Parameters m} -> (t : Name) -> (ps : List (Name, Nat)) -> (x : Name) -> TypeView pol ty -> IsFunctorialIn pol t x ty
  Totality: total
  Visibility: export
typeView : {auto elab : Elaboration m} -> {auto error : MonadError Error m} -> {auto cs : MonadState Parameters m} -> (t : Name) -> (ps : List (Name, Nat)) -> (x : Name) -> (ty : TTImp) -> m (TypeView pol ty)
  Hoping to observe that ty is functorial

  Totality: total
  Visibility: export
derive : {default Private _ : Visibility} -> {default Total _ : TotalReq} -> {default [] _ : List Name} -> Elab (Functor f)
  Derive an implementation of Functor for a type constructor.
  This can be used like so:
  ```
  data Tree a = Leaf a | Node (Tree a) (Tree a)
  treeFunctor : Functor Tree
  treeFunctor = %runElab derive
  ```

  Totality: total
  Visibility: export

\ No newline at end of file
+
Reexports
import public Control.Monad.Either
import public Control.Monad.State
import public Data.Maybe
import public Decidable.Equality
import public Language.Reflection
import public Deriving.Common
Definitions
data Error : Type
  Possible errors for the functor-deriving machinery.

  Totality: total
  Visibility: public export
  Constructors:
  
NotFreeOf : Name -> TTImp -> Error
  
NegativeOccurrence : Name -> TTImp -> Error
  
NotAnApplication : TTImp -> Error
  
NotAFunctor : TTImp -> Error
  
NotABifunctor : TTImp -> Error
  
NotAFunctorInItsLastArg : TTImp -> Error
  
UnsupportedType : TTImp -> Error
  
InvalidGoal : Error
  
ConfusingReturnType : Error
  
WhenCheckingConstructor : Name -> Error -> Error
  
WhenCheckingArg : TTImp -> Error -> Error

  Hint: 
Show Error
data Polarity : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Positive : Polarity
  
Negative : Polarity
not : Polarity -> Polarity
  Totality: total
  Visibility: public export
data IsFunctorialIn : Polarity -> Name -> Name -> TTImp -> Type
  IsFunctorialIn is parametrised by
  @ pol the polarity of the type being analysed. We start in positive polarity
        where occurrences of x are allowed and negate the polarity every time
        we step into the domain of a Pi type.
  @ t  the name of the data type whose constructors are being analysed
  @ x  the name of the type variable that the functioral action will change
  @ ty the type being analysed
  The inductive type delivers a proof that x occurs positively in ty,
  assuming that t also is positive.

  Totality: total
  Visibility: public export
  Constructors:
  
FIVar : IsFunctorialIn Positive t x (IVar fc x)
  The type variable x occurs alone
  
FIRec : (0 _ : IsAppView ({_:4466}, t) {_:4467} f) -> IsFunctorialIn pol t x arg -> IsFunctorialIn Positive t x (IApp fc f arg)
  There is a recursive subtree of type (t a1 ... an u) and u is functorial in x.
  We do not insist that u is exactly x so that we can deal with nested types
  like the following:
    data Full a = Leaf a | Node (Full (a, a))
    data Term a = Var a | App (Term a) (Term a) | Lam (Term (Maybe a))
  
FIDelayed : IsFunctorialIn pol t x ty -> IsFunctorialIn pol t x (IDelayed fc lr ty)
  The subterm is delayed (either Inf or Lazy)
  
FIBifun : IsFreeOf x sp -> HasImplementation Bifunctor sp -> IsFunctorialIn pol t x arg1 -> Either (IsFunctorialIn pol t x arg2) (IsFreeOf x arg2) -> IsFunctorialIn pol t x (IApp fc1 (IApp fc2 sp arg1) arg2)
  There are nested subtrees somewhere inside a 3rd party type constructor
  which satisfies the Bifunctor interface
  
FIFun : IsFreeOf x sp -> HasImplementation Functor sp -> IsFunctorialIn pol t x arg -> IsFunctorialIn pol t x (IApp fc sp arg)
  There are nested subtrees somewhere inside a 3rd party type constructor
  which satisfies the Functor interface
  
FIPi : IsFunctorialIn (not pol) t x a -> IsFunctorialIn pol t x b -> IsFunctorialIn pol t x (IPi fc rig pinfo nm a b)
  A pi type, with no negative occurrence of x in its domain
  
FIFree : IsFreeOf x a -> IsFunctorialIn pol t x a
  A type free of x is trivially Functorial in it
TypeView : Elaboration m => MonadError Error m => MonadState Parameters m => Name -> List (Name, Nat) -> Name -> Polarity -> TTImp -> Type
  When analysing the type of a constructor for the type family t,
  we hope to observe
    1. either that it is functorial in x
    2. or that it is free of x
  If if it is not the case, we will use the `MonadError Error` constraint
  to fail with an informative message.

  Totality: total
  Visibility: public export
fromTypeView : {auto elab : Elaboration m} -> {auto error : MonadError Error m} -> {auto cs : MonadState Parameters m} -> (t : Name) -> (ps : List (Name, Nat)) -> (x : Name) -> TypeView pol ty -> IsFunctorialIn pol t x ty
  Totality: total
  Visibility: export
typeView : {auto elab : Elaboration m} -> {auto error : MonadError Error m} -> {auto cs : MonadState Parameters m} -> (t : Name) -> (ps : List (Name, Nat)) -> (x : Name) -> (ty : TTImp) -> m (TypeView pol ty)
  Hoping to observe that ty is functorial

  Totality: total
  Visibility: export
derive : {default Private _ : Visibility} -> {default Total _ : TotalReq} -> {default [] _ : List Name} -> Elab (Functor f)
  Derive an implementation of Functor for a type constructor.
  This can be used like so:
  ```
  data Tree a = Leaf a | Node (Tree a) (Tree a)
  treeFunctor : Functor Tree
  treeFunctor = %runElab derive
  ```

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Deriving.Show.html b/base/docs/Deriving.Show.html
index 2db2e877b9..f5145b1f2c 100644
--- a/base/docs/Deriving.Show.html
+++ b/base/docs/Deriving.Show.html
@@ -68,4 +68,4 @@
 treeShow : Show a => Show (Tree a)
 treeShow = %runElab derive
 ```
-
Reexports
import public Control.Monad.Either
import public Control.Monad.State
import public Data.Maybe
import public Decidable.Equality
import public Language.Reflection
import public Deriving.Common
Definitions
fromShowPrec : (Prec -> ty -> String) -> Show ty
  Totality: total
  Visibility: public export
data Error : Type
  Possible errors for the functor-deriving machinery.

  Totality: total
  Visibility: public export
  Constructors:
  
NotAShowable : Name -> Error
  
UnsupportedType : TTImp -> Error
  
NotAFiniteStructure : Error
  
NotAnUnconstrainedValue : Count -> Error
  
InvalidGoal : Error
  
ConfusingReturnType : Error
  
WhenCheckingConstructor : Name -> Error -> Error
  
WhenCheckingArg : TTImp -> Error -> Error

  Hint: 
Show Error
data IsShowable : Name -> TTImp -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
ISDelayed : IsShowable t ty -> IsShowable t (IDelayed fc LLazy ty)
  The subterm is delayed (Lazy only, we can't traverse infinite structures)
  
ISRec : (0 _ : IsAppView ({_:4388}, t) {_:4389} ty) -> IsShowable t ty
  There is a recursive subtree of type (t a1 ... an)
  
ISShowN : (0 _ : IsAppView ({_:4416}, tcon) args ty) -> HasType tcon tconty -> IsProvable (ShowN tconty tcon) -> IsShowableArgs t tconty (args <>> []) -> IsShowable t ty
  There are nested subtrees somewhere inside a 3rd party type constructor
  which satisfies the Show interface
  
ISParam : IsShowable t ty
  Or we could be referring to one of the parameters
  
ISPrim : (ty : PrimType) -> IsShowable t (IPrimVal fc (PrT ty))
  A primitive type is trivially Showable
typeView : Elaboration m => MonadError Error m => MonadState Parameters m => (t : Name) -> List (Name, Nat) -> (ty : TTImp) -> m (IsShowable t ty)
  Hoping to observe that ty can be shown

  Totality: total
  Visibility: export
derive : {default Private _ : Visibility} -> {default Total _ : TotalReq} -> {default [] _ : List Name} -> Elab (Show f)
  Derive an implementation of Show for a type constructor.
  This can be used like so:
  ```
  data Tree a = Leaf a | Node (Tree a) (Tree a)
  treeShow : Show a => Show (Tree a)
  treeShow = %runElab derive
  ```

  Totality: total
  Visibility: export

\ No newline at end of file
+
Reexports
import public Control.Monad.Either
import public Control.Monad.State
import public Data.Maybe
import public Decidable.Equality
import public Language.Reflection
import public Deriving.Common
Definitions
fromShowPrec : (Prec -> ty -> String) -> Show ty
  Totality: total
  Visibility: public export
data Error : Type
  Possible errors for the functor-deriving machinery.

  Totality: total
  Visibility: public export
  Constructors:
  
NotAShowable : Name -> Error
  
UnsupportedType : TTImp -> Error
  
NotAFiniteStructure : Error
  
NotAnUnconstrainedValue : Count -> Error
  
InvalidGoal : Error
  
ConfusingReturnType : Error
  
WhenCheckingConstructor : Name -> Error -> Error
  
WhenCheckingArg : TTImp -> Error -> Error

  Hint: 
Show Error
data IsShowable : Name -> TTImp -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
ISDelayed : IsShowable t ty -> IsShowable t (IDelayed fc LLazy ty)
  The subterm is delayed (Lazy only, we can't traverse infinite structures)
  
ISRec : (0 _ : IsAppView ({_:4388}, t) {_:4389} ty) -> IsShowable t ty
  There is a recursive subtree of type (t a1 ... an)
  
ISShowN : (0 _ : IsAppView ({_:4416}, tcon) args ty) -> HasType tcon tconty -> IsProvable (ShowN tconty tcon) -> IsShowableArgs t tconty (args <>> []) -> IsShowable t ty
  There are nested subtrees somewhere inside a 3rd party type constructor
  which satisfies the Show interface
  
ISParam : IsShowable t ty
  Or we could be referring to one of the parameters
  
ISPrim : (ty : PrimType) -> IsShowable t (IPrimVal fc (PrT ty))
  A primitive type is trivially Showable
typeView : Elaboration m => MonadError Error m => MonadState Parameters m => (t : Name) -> List (Name, Nat) -> (ty : TTImp) -> m (IsShowable t ty)
  Hoping to observe that ty can be shown

  Totality: total
  Visibility: export
derive : {default Private _ : Visibility} -> {default Total _ : TotalReq} -> {default [] _ : List Name} -> Elab (Show f)
  Derive an implementation of Show for a type constructor.
  This can be used like so:
  ```
  data Tree a = Leaf a | Node (Tree a) (Tree a)
  treeShow : Show a => Show (Tree a)
  treeShow = %runElab derive
  ```

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Deriving.Traversable.html b/base/docs/Deriving.Traversable.html
index 7f1e150d60..504ac73771 100644
--- a/base/docs/Deriving.Traversable.html
+++ b/base/docs/Deriving.Traversable.html
@@ -68,4 +68,4 @@
 treeFoldable : Traversable Tree
 treeFoldable = %runElab derive
 ```
-
Reexports
import public Control.Monad.Either
import public Control.Monad.State
import public Data.List1
import public Data.Maybe
import public Data.Morphisms
import public Decidable.Equality
import public Language.Reflection
import public Deriving.Common
Definitions
data Error : Type
  Possible errors for the functor-deriving machinery.

  Totality: total
  Visibility: public export
  Constructors:
  
NotFreeOf : Name -> TTImp -> Error
  
NotAnApplication : TTImp -> Error
  
NotATraversable : TTImp -> Error
  
NotABitraversable : TTImp -> Error
  
NotTraversableInItsLastArg : TTImp -> Error
  
UnsupportedType : TTImp -> Error
  
NotAFiniteStructure : Error
  
NotAnUnconstrainedValue : Count -> Error
  
InvalidGoal : Error
  
ConfusingReturnType : Error
  
WhenCheckingConstructor : Name -> Error -> Error
  
WhenCheckingArg : TTImp -> Error -> Error

  Hint: 
Show Error
data IsTraversableIn : Name -> Name -> TTImp -> Type
  IsTraversableIn is parametrised by
  @ t  the name of the data type whose constructors are being analysed
  @ x  the name of the type variable that the traversable action will act on
  @ ty the type being analysed
  The inductive type delivers a proof that x can be traversed over in ty,
  assuming that t also is traversable.

  Totality: total
  Visibility: public export
  Constructors:
  
TIVar : IsTraversableIn t x (IVar fc x)
  The type variable x occurs alone
  
TIRec : (0 _ : IsAppView ({_:4523}, t) {_:4524} f) -> IsTraversableIn t x arg -> IsTraversableIn t x (IApp fc f arg)
  There is a recursive subtree of type (t a1 ... an u) and u is Traversable in x.
  We do not insist that u is exactly x so that we can deal with nested types
  like the following:
    data Full a = Leaf a | Node (Full (a, a))
    data Term a = Var a | App (Term a) (Term a) | Lam (Term (Maybe a))
  
TIDelayed : IsTraversableIn t x ty -> IsTraversableIn t x (IDelayed fc LLazy ty)
  The subterm is delayed (Lazy only, we can't traverse infinite structures)
  
TIBifold : IsFreeOf x sp -> HasImplementation Bitraversable sp -> IsTraversableIn t x arg1 -> Either (IsTraversableIn t x arg2) (IsFreeOf x arg2) -> IsTraversableIn t x (IApp fc1 (IApp fc2 sp arg1) arg2)
  There are nested subtrees somewhere inside a 3rd party type constructor
  which satisfies the Bitraversable interface
  
TIFold : IsFreeOf x sp -> HasImplementation Traversable sp -> IsTraversableIn t x arg -> IsTraversableIn t x (IApp fc sp arg)
  There are nested subtrees somewhere inside a 3rd party type constructor
  which satisfies the Traversable interface
  
TIFree : IsFreeOf x a -> IsTraversableIn t x a
  A type free of x is trivially Traversable in it
TypeView : Elaboration m => MonadError Error m => MonadState Parameters m => Name -> List (Name, Nat) -> Name -> TTImp -> Type
  When analysing the type of a constructor for the type family t,
  we hope to observe
    1. either that it is traversable in x
    2. or that it is free of x
  If it is not the case, we will use the `MonadError Error` constraint
  to fail with an informative message.

  Totality: total
  Visibility: public export
fromTypeView : {auto elab : Elaboration m} -> {auto error : MonadError Error m} -> {auto cs : MonadState Parameters m} -> (t : Name) -> (ps : List (Name, Nat)) -> (x : Name) -> TypeView ty -> IsTraversableIn t x ty
  Totality: total
  Visibility: export
typeView : {auto elab : Elaboration m} -> {auto error : MonadError Error m} -> {auto cs : MonadState Parameters m} -> (t : Name) -> (ps : List (Name, Nat)) -> (x : Name) -> (ty : TTImp) -> m (TypeView ty)
  Hoping to observe that ty is traversable

  Totality: total
  Visibility: export
derive : {default Private _ : Visibility} -> {default Total _ : TotalReq} -> {default [] _ : List Name} -> Elab (Traversable f)
  Derive an implementation of Traversable for a type constructor.
  This can be used like so:
  ```
  data Tree a = Leaf a | Node (Tree a) (Tree a)
  treeTraversable : Traversable Tree
  treeTraversable = %runElab derive
  ```

  Totality: total
  Visibility: export

\ No newline at end of file
+
Reexports
import public Control.Monad.Either
import public Control.Monad.State
import public Data.List1
import public Data.Maybe
import public Data.Morphisms
import public Decidable.Equality
import public Language.Reflection
import public Deriving.Common
Definitions
data Error : Type
  Possible errors for the functor-deriving machinery.

  Totality: total
  Visibility: public export
  Constructors:
  
NotFreeOf : Name -> TTImp -> Error
  
NotAnApplication : TTImp -> Error
  
NotATraversable : TTImp -> Error
  
NotABitraversable : TTImp -> Error
  
NotTraversableInItsLastArg : TTImp -> Error
  
UnsupportedType : TTImp -> Error
  
NotAFiniteStructure : Error
  
NotAnUnconstrainedValue : Count -> Error
  
InvalidGoal : Error
  
ConfusingReturnType : Error
  
WhenCheckingConstructor : Name -> Error -> Error
  
WhenCheckingArg : TTImp -> Error -> Error

  Hint: 
Show Error
data IsTraversableIn : Name -> Name -> TTImp -> Type
  IsTraversableIn is parametrised by
  @ t  the name of the data type whose constructors are being analysed
  @ x  the name of the type variable that the traversable action will act on
  @ ty the type being analysed
  The inductive type delivers a proof that x can be traversed over in ty,
  assuming that t also is traversable.

  Totality: total
  Visibility: public export
  Constructors:
  
TIVar : IsTraversableIn t x (IVar fc x)
  The type variable x occurs alone
  
TIRec : (0 _ : IsAppView ({_:4523}, t) {_:4524} f) -> IsTraversableIn t x arg -> IsTraversableIn t x (IApp fc f arg)
  There is a recursive subtree of type (t a1 ... an u) and u is Traversable in x.
  We do not insist that u is exactly x so that we can deal with nested types
  like the following:
    data Full a = Leaf a | Node (Full (a, a))
    data Term a = Var a | App (Term a) (Term a) | Lam (Term (Maybe a))
  
TIDelayed : IsTraversableIn t x ty -> IsTraversableIn t x (IDelayed fc LLazy ty)
  The subterm is delayed (Lazy only, we can't traverse infinite structures)
  
TIBifold : IsFreeOf x sp -> HasImplementation Bitraversable sp -> IsTraversableIn t x arg1 -> Either (IsTraversableIn t x arg2) (IsFreeOf x arg2) -> IsTraversableIn t x (IApp fc1 (IApp fc2 sp arg1) arg2)
  There are nested subtrees somewhere inside a 3rd party type constructor
  which satisfies the Bitraversable interface
  
TIFold : IsFreeOf x sp -> HasImplementation Traversable sp -> IsTraversableIn t x arg -> IsTraversableIn t x (IApp fc sp arg)
  There are nested subtrees somewhere inside a 3rd party type constructor
  which satisfies the Traversable interface
  
TIFree : IsFreeOf x a -> IsTraversableIn t x a
  A type free of x is trivially Traversable in it
TypeView : Elaboration m => MonadError Error m => MonadState Parameters m => Name -> List (Name, Nat) -> Name -> TTImp -> Type
  When analysing the type of a constructor for the type family t,
  we hope to observe
    1. either that it is traversable in x
    2. or that it is free of x
  If it is not the case, we will use the `MonadError Error` constraint
  to fail with an informative message.

  Totality: total
  Visibility: public export
fromTypeView : {auto elab : Elaboration m} -> {auto error : MonadError Error m} -> {auto cs : MonadState Parameters m} -> (t : Name) -> (ps : List (Name, Nat)) -> (x : Name) -> TypeView ty -> IsTraversableIn t x ty
  Totality: total
  Visibility: export
typeView : {auto elab : Elaboration m} -> {auto error : MonadError Error m} -> {auto cs : MonadState Parameters m} -> (t : Name) -> (ps : List (Name, Nat)) -> (x : Name) -> (ty : TTImp) -> m (TypeView ty)
  Hoping to observe that ty is traversable

  Totality: total
  Visibility: export
derive : {default Private _ : Visibility} -> {default Total _ : TotalReq} -> {default [] _ : List Name} -> Elab (Traversable f)
  Derive an implementation of Traversable for a type constructor.
  This can be used like so:
  ```
  data Tree a = Leaf a | Node (Tree a) (Tree a)
  treeTraversable : Traversable Tree
  treeTraversable = %runElab derive
  ```

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Language.Reflection.TT.html b/base/docs/Language.Reflection.TT.html
index 254ca711a9..a640e35ba0 100644
--- a/base/docs/Language.Reflection.TT.html
+++ b/base/docs/Language.Reflection.TT.html
@@ -61,4 +61,4 @@
 
 
 
-
Language.Reflection.TT(source)
Reexports
import public Data.List
import public Data.String
Definitions
data Namespace : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkNS : List String -> Namespace

  Hints:
  
Biinjective NS
  
DecEq Namespace
  
Eq Namespace
  
Injective MkNS
  
Ord Namespace
  
Show Namespace
data ModuleIdent : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkMI : List String -> ModuleIdent
showSep : String -> List String -> String
  Totality: total
  Visibility: export
FilePos : Type
  Totality: total
  Visibility: public export
data VirtualIdent : Type
  Totality: total
  Visibility: public export
  Constructor: 
Interactive : VirtualIdent
data OriginDesc : Type
  Totality: total
  Visibility: public export
  Constructors:
  
PhysicalIdrSrc : ModuleIdent -> OriginDesc
  Anything that originates in physical Idris source files is assigned a
  `PhysicalIdrSrc modIdent`,
    where `modIdent` is the top-level module identifier of that file.
  
PhysicalPkgSrc : String -> OriginDesc
  Anything parsed from a package file is decorated with `PhysicalPkgSrc fname`,
    where `fname` is path to the package file.
  
Virtual : VirtualIdent -> OriginDesc
data FC : Type
  A file context is a filename together with starting and ending positions.
  It's often carried by AST nodes that might have been created from a source
  file or by the compiler. That makes it useful to have the notion of
  `EmptyFC` as part of the type.

  Totality: total
  Visibility: public export
  Constructors:
  
MkFC : OriginDesc -> FilePos -> FilePos -> FC
  
MkVirtualFC : OriginDesc -> FilePos -> FilePos -> FC
  Virtual FCs are FC attached to desugared/generated code. They can help with marking
  errors, but we shouldn't attach semantic highlighting metadata to them.
  
EmptyFC : FC
emptyFC : FC
  Totality: total
  Visibility: public export
data NameType : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Bound : NameType
  
Func : NameType
  
DataCon : Int -> Nat -> NameType
  
TyCon : Int -> Nat -> NameType
data PrimType : Type
  Totality: total
  Visibility: public export
  Constructors:
  
IntType : PrimType
  
IntegerType : PrimType
  
Int8Type : PrimType
  
Int16Type : PrimType
  
Int32Type : PrimType
  
Int64Type : PrimType
  
Bits8Type : PrimType
  
Bits16Type : PrimType
  
Bits32Type : PrimType
  
Bits64Type : PrimType
  
StringType : PrimType
  
CharType : PrimType
  
DoubleType : PrimType
  
WorldType : PrimType

  Hints:
  
Eq PrimType
  
Show PrimType
data Constant : Type
  Totality: total
  Visibility: public export
  Constructors:
  
I : Int -> Constant
  
BI : Integer -> Constant
  
I8 : Int8 -> Constant
  
I16 : Int16 -> Constant
  
I32 : Int32 -> Constant
  
I64 : Int64 -> Constant
  
B8 : Bits8 -> Constant
  
B16 : Bits16 -> Constant
  
B32 : Bits32 -> Constant
  
B64 : Bits64 -> Constant
  
Str : String -> Constant
  
Ch : Char -> Constant
  
Db : Double -> Constant
  
PrT : PrimType -> Constant
  
WorldVal : Constant

  Hints:
  
Eq Constant
  
Show Constant
data UserName : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Basic : String -> UserName
  
Field : String -> UserName
  
Underscore : UserName

  Hints:
  
DecEq UserName
  
Eq UserName
  
Injective Basic
  
Injective Field
  
Injective UN
  
Ord UserName
  
Show UserName
data Name : Type
  Totality: total
  Visibility: public export
  Constructors:
  
NS : Namespace -> Name -> Name
  
UN : UserName -> Name
  
MN : String -> Int -> Name
  
DN : String -> Name -> Name
  
Nested : (Int, Int) -> Name -> Name
  
CaseBlock : String -> Int -> Name
  
WithBlock : String -> Int -> Name

  Hints:
  
Biinjective NS
  
Biinjective MN
  
Biinjective DN
  
Biinjective Nested
  
Biinjective CaseBlock
  
Biinjective WithBlock
  
DecEq Name
  
Eq Name
  
Injective UN
  
Ord Name
  
Show Name
dropNS : Name -> Name
  Totality: total
  Visibility: export
isOp : Name -> Bool
  Totality: total
  Visibility: export
showPrefix : Bool -> Name -> String
  Totality: total
  Visibility: export
record NameInfo : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkNameInfo : NameType -> NameInfo

  Projection: 
.nametype : NameInfo -> NameType
.nametype : NameInfo -> NameType
  Totality: total
  Visibility: public export
nametype : NameInfo -> NameType
  Totality: total
  Visibility: public export
data Count : Type
  Totality: total
  Visibility: public export
  Constructors:
  
M0 : Count
  
M1 : Count
  
MW : Count

  Hints:
  
Eq Count
  
Ord Count
enunciate : Count -> String
  Totality: total
  Visibility: export
showCount : Count -> String -> String
  Totality: total
  Visibility: export
data PiInfo : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
ImplicitArg : PiInfo t
  
ExplicitArg : PiInfo t
  
AutoImplicit : PiInfo t
  
DefImplicit : t -> PiInfo t

  Hint: 
Eq a => Eq (PiInfo a)
showPiInfo : Show a => {default True _ : Bool} -> PiInfo a -> String -> String
  Totality: total
  Visibility: export
data IsVar : Name -> Nat -> List Name -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
First : IsVar n 0 (n :: ns)
  
Later : IsVar n i ns -> IsVar n (S i) (m :: ns)
data LazyReason : Type
  Totality: total
  Visibility: public export
  Constructors:
  
LInf : LazyReason
  
LLazy : LazyReason
  
LUnknown : LazyReason

  Hints:
  
Eq LazyReason
  
Show LazyReason
data TotalReq : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Total : TotalReq
  
CoveringOnly : TotalReq
  
PartialOK : TotalReq

  Hints:
  
Eq TotalReq
  
Show TotalReq
showTotalReq : Maybe TotalReq -> String -> String
  Totality: total
  Visibility: export
data Visibility : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Private : Visibility
  
Export : Visibility
  
Public : Visibility

  Hints:
  
Eq Visibility
  
Show Visibility
data BuiltinType : Type
  Totality: total
  Visibility: public export
  Constructors:
  
BuiltinNatural : BuiltinType
  
NaturalToInteger : BuiltinType
  
IntegerToNatural : BuiltinType

  Hints:
  
Eq BuiltinType
  
Show BuiltinType

\ No newline at end of file
+
Language.Reflection.TT(source)
Reexports
import public Data.List
import public Data.String
Definitions
data Namespace : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkNS : List String -> Namespace

  Hints:
  
Biinjective NS
  
DecEq Namespace
  
Eq Namespace
  
Injective MkNS
  
Ord Namespace
  
Show Namespace
data ModuleIdent : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkMI : List String -> ModuleIdent
showSep : String -> List String -> String
  Totality: total
  Visibility: export
FilePos : Type
  Totality: total
  Visibility: public export
data VirtualIdent : Type
  Totality: total
  Visibility: public export
  Constructor: 
Interactive : VirtualIdent
data OriginDesc : Type
  Totality: total
  Visibility: public export
  Constructors:
  
PhysicalIdrSrc : ModuleIdent -> OriginDesc
  Anything that originates in physical Idris source files is assigned a
  `PhysicalIdrSrc modIdent`,
    where `modIdent` is the top-level module identifier of that file.
  
PhysicalPkgSrc : String -> OriginDesc
  Anything parsed from a package file is decorated with `PhysicalPkgSrc fname`,
    where `fname` is path to the package file.
  
Virtual : VirtualIdent -> OriginDesc
data FC : Type
  A file context is a filename together with starting and ending positions.
  It's often carried by AST nodes that might have been created from a source
  file or by the compiler. That makes it useful to have the notion of
  `EmptyFC` as part of the type.

  Totality: total
  Visibility: public export
  Constructors:
  
MkFC : OriginDesc -> FilePos -> FilePos -> FC
  
MkVirtualFC : OriginDesc -> FilePos -> FilePos -> FC
  Virtual FCs are FC attached to desugared/generated code. They can help with marking
  errors, but we shouldn't attach semantic highlighting metadata to them.
  
EmptyFC : FC
emptyFC : FC
  Totality: total
  Visibility: public export
data NameType : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Bound : NameType
  
Func : NameType
  
DataCon : Int -> Nat -> NameType
  
TyCon : Int -> Nat -> NameType
data PrimType : Type
  Totality: total
  Visibility: public export
  Constructors:
  
IntType : PrimType
  
IntegerType : PrimType
  
Int8Type : PrimType
  
Int16Type : PrimType
  
Int32Type : PrimType
  
Int64Type : PrimType
  
Bits8Type : PrimType
  
Bits16Type : PrimType
  
Bits32Type : PrimType
  
Bits64Type : PrimType
  
StringType : PrimType
  
CharType : PrimType
  
DoubleType : PrimType
  
WorldType : PrimType

  Hints:
  
Eq PrimType
  
Show PrimType
data Constant : Type
  Totality: total
  Visibility: public export
  Constructors:
  
I : Int -> Constant
  
BI : Integer -> Constant
  
I8 : Int8 -> Constant
  
I16 : Int16 -> Constant
  
I32 : Int32 -> Constant
  
I64 : Int64 -> Constant
  
B8 : Bits8 -> Constant
  
B16 : Bits16 -> Constant
  
B32 : Bits32 -> Constant
  
B64 : Bits64 -> Constant
  
Str : String -> Constant
  
Ch : Char -> Constant
  
Db : Double -> Constant
  
PrT : PrimType -> Constant
  
WorldVal : Constant

  Hints:
  
Eq Constant
  
Show Constant
data UserName : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Basic : String -> UserName
  
Field : String -> UserName
  
Underscore : UserName

  Hints:
  
DecEq UserName
  
Eq UserName
  
Injective Basic
  
Injective Field
  
Injective UN
  
Ord UserName
  
Show UserName
data Name : Type
  Totality: total
  Visibility: public export
  Constructors:
  
NS : Namespace -> Name -> Name
  
UN : UserName -> Name
  
MN : String -> Int -> Name
  
DN : String -> Name -> Name
  
Nested : (Int, Int) -> Name -> Name
  
CaseBlock : String -> Int -> Name
  
WithBlock : String -> Int -> Name

  Hints:
  
Biinjective NS
  
Biinjective MN
  
Biinjective DN
  
Biinjective Nested
  
Biinjective CaseBlock
  
Biinjective WithBlock
  
DecEq Name
  
Eq Name
  
Injective UN
  
Ord Name
  
Show Name
dropNS : Name -> Name
  Totality: total
  Visibility: export
isOp : Name -> Bool
  Totality: total
  Visibility: export
showPrefix : Bool -> Name -> String
  Totality: total
  Visibility: export
record NameInfo : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkNameInfo : NameType -> NameInfo

  Projection: 
.nametype : NameInfo -> NameType
.nametype : NameInfo -> NameType
  Totality: total
  Visibility: public export
nametype : NameInfo -> NameType
  Totality: total
  Visibility: public export
data Count : Type
  Totality: total
  Visibility: public export
  Constructors:
  
M0 : Count
  
M1 : Count
  
MW : Count

  Hints:
  
Eq Count
  
Ord Count
enunciate : Count -> String
  Totality: total
  Visibility: export
showCount : Count -> String -> String
  Totality: total
  Visibility: export
data PiInfo : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
ImplicitArg : PiInfo t
  
ExplicitArg : PiInfo t
  
AutoImplicit : PiInfo t
  
DefImplicit : t -> PiInfo t

  Hint: 
Eq a => Eq (PiInfo a)
showPiInfo : Show a => {default True _ : Bool} -> PiInfo a -> String -> String
  Totality: total
  Visibility: export
data IsVar : Name -> Nat -> List Name -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
First : IsVar n 0 (n :: ns)
  
Later : IsVar n i ns -> IsVar n (S i) (m :: ns)
data LazyReason : Type
  Totality: total
  Visibility: public export
  Constructors:
  
LInf : LazyReason
  
LLazy : LazyReason
  
LUnknown : LazyReason

  Hints:
  
Eq LazyReason
  
Show LazyReason
data TotalReq : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Total : TotalReq
  
CoveringOnly : TotalReq
  
PartialOK : TotalReq

  Hints:
  
Eq TotalReq
  
Show TotalReq
showTotalReq : Maybe TotalReq -> String -> String
  Totality: total
  Visibility: export
data Visibility : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Private : Visibility
  
Export : Visibility
  
Public : Visibility

  Hints:
  
Eq Visibility
  
Show Visibility
data BuiltinType : Type
  Totality: total
  Visibility: public export
  Constructors:
  
BuiltinNatural : BuiltinType
  
NaturalToInteger : BuiltinType
  
IntegerToNatural : BuiltinType

  Hints:
  
Eq BuiltinType
  
Show BuiltinType

\ No newline at end of file
diff --git a/base/docs/Language.Reflection.TTImp.html b/base/docs/Language.Reflection.TTImp.html
index cdbb788a25..bcdda7e383 100644
--- a/base/docs/Language.Reflection.TTImp.html
+++ b/base/docs/Language.Reflection.TTImp.html
@@ -61,4 +61,4 @@
 
 
 
-
Language.Reflection.TTImp(source)
Reexports
import public Language.Reflection.TT
Definitions
data BindMode : Type
  Totality: total
  Visibility: public export
  Constructors:
  
PI : Count -> BindMode
  
PATTERN : BindMode
  
COVERAGE : BindMode
  
NONE : BindMode

  Hint: 
Eq BindMode
data UseSide : Type
  Totality: total
  Visibility: public export
  Constructors:
  
UseLeft : UseSide
  
UseRight : UseSide

  Hint: 
Eq UseSide
data DotReason : Type
  Totality: total
  Visibility: public export
  Constructors:
  
NonLinearVar : DotReason
  
VarApplied : DotReason
  
NotConstructor : DotReason
  
ErasedArg : DotReason
  
UserDotted : DotReason
  
UnknownDot : DotReason
  
UnderAppliedCon : DotReason

  Hint: 
Eq DotReason
data TTImp : Type
  Totality: total
  Visibility: public export
  Constructors:
  
IVar : FC -> Name -> TTImp
  
IPi : FC -> Count -> PiInfo TTImp -> Maybe Name -> TTImp -> TTImp -> TTImp
  
ILam : FC -> Count -> PiInfo TTImp -> Maybe Name -> TTImp -> TTImp -> TTImp
  
ILet : FC -> FC -> Count -> Name -> TTImp -> TTImp -> TTImp -> TTImp
  
ICase : FC -> List FnOpt -> TTImp -> TTImp -> List Clause -> TTImp
  
ILocal : FC -> List Decl -> TTImp -> TTImp
  
IUpdate : FC -> List IFieldUpdate -> TTImp -> TTImp
  
IApp : FC -> TTImp -> TTImp -> TTImp
  
INamedApp : FC -> TTImp -> Name -> TTImp -> TTImp
  
IAutoApp : FC -> TTImp -> TTImp -> TTImp
  
IWithApp : FC -> TTImp -> TTImp -> TTImp
  
ISearch : FC -> Nat -> TTImp
  
IAlternative : FC -> AltType -> List TTImp -> TTImp
  
IRewrite : FC -> TTImp -> TTImp -> TTImp
  
IBindHere : FC -> BindMode -> TTImp -> TTImp
  
IBindVar : FC -> String -> TTImp
  
IAs : FC -> FC -> UseSide -> Name -> TTImp -> TTImp
  
IMustUnify : FC -> DotReason -> TTImp -> TTImp
  
IDelayed : FC -> LazyReason -> TTImp -> TTImp
  
IDelay : FC -> TTImp -> TTImp
  
IForce : FC -> TTImp -> TTImp
  
IQuote : FC -> TTImp -> TTImp
  
IQuoteName : FC -> Name -> TTImp
  
IQuoteDecl : FC -> List Decl -> TTImp
  
IUnquote : FC -> TTImp -> TTImp
  
IPrimVal : FC -> Constant -> TTImp
  
IType : FC -> TTImp
  
IHole : FC -> String -> TTImp
  
Implicit : FC -> Bool -> TTImp
  
IWithUnambigNames : FC -> List (FC, Name) -> TTImp -> TTImp

  Hints:
  
Eq TTImp => Eq Clause
  
Eq TTImp => Eq IFieldUpdate
  
Eq TTImp => Eq AltType
  
Eq TTImp => Eq FnOpt
  
Eq TTImp => Eq ITy
  
Eq TTImp => Eq Data
  
Eq TTImp => Eq IField
  
Eq TTImp => Eq Record
  
Eq TTImp => Eq Decl
  
Eq TTImp
  
Show TTImp
data IFieldUpdate : Type
  Totality: total
  Visibility: public export
  Constructors:
  
ISetField : List String -> TTImp -> IFieldUpdate
  
ISetFieldApp : List String -> TTImp -> IFieldUpdate

  Hints:
  
Eq TTImp => Eq IFieldUpdate
  
Show IFieldUpdate
data AltType : Type
  Totality: total
  Visibility: public export
  Constructors:
  
FirstSuccess : AltType
  
Unique : AltType
  
UniqueDefault : TTImp -> AltType

  Hint: 
Eq TTImp => Eq AltType
data FnOpt : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Inline : FnOpt
  
NoInline : FnOpt
  
Deprecate : FnOpt
  
TCInline : FnOpt
  
Hint : Bool -> FnOpt
  
GlobalHint : Bool -> FnOpt
  
ExternFn : FnOpt
  
ForeignFn : List TTImp -> FnOpt
  
ForeignExport : List TTImp -> FnOpt
  
Invertible : FnOpt
  
Totality : TotalReq -> FnOpt
  
Macro : FnOpt
  
SpecArgs : List Name -> FnOpt

  Hint: 
Eq TTImp => Eq FnOpt
data ITy : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkTy : FC -> FC -> Name -> TTImp -> ITy

  Hints:
  
Eq TTImp => Eq ITy
  
Show ITy
data DataOpt : Type
  Totality: total
  Visibility: public export
  Constructors:
  
SearchBy : List Name -> DataOpt
  
NoHints : DataOpt
  
UniqueSearch : DataOpt
  
External : DataOpt
  
NoNewtype : DataOpt

  Hint: 
Eq DataOpt
data Data : Type
  Totality: total
  Visibility: public export
  Constructors:
  
MkData : FC -> Name -> Maybe TTImp -> List DataOpt -> List ITy -> Data
  
MkLater : FC -> Name -> TTImp -> Data

  Hints:
  
Eq TTImp => Eq Data
  
Show Data
data IField : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkIField : FC -> Count -> PiInfo TTImp -> Name -> TTImp -> IField

  Hints:
  
Eq TTImp => Eq IField
  
Show IField
data Record : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkRecord : FC -> Name -> List (Name, (Count, (PiInfo TTImp, TTImp))) -> List DataOpt -> Name -> List IField -> Record

  Hints:
  
Eq TTImp => Eq Record
  
Show Record
data WithFlag : Type
  Totality: total
  Visibility: public export
  Constructor: 
Syntactic : WithFlag

  Hint: 
Eq WithFlag
data Clause : Type
  Totality: total
  Visibility: public export
  Constructors:
  
PatClause : FC -> TTImp -> TTImp -> Clause
  
WithClause : FC -> TTImp -> Count -> TTImp -> Maybe Name -> List WithFlag -> List Clause -> Clause
  
ImpossibleClause : FC -> TTImp -> Clause

  Hint: 
Eq TTImp => Eq Clause
data WithDefault : (a : Type) -> a -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
DefaultedValue : WithDefault a def
  
SpecifiedValue : a -> WithDefault a def

  Hints:
  
Eq a => Eq (WithDefault a def)
  
Ord a => Ord (WithDefault a def)
  
Show a => Show (WithDefault a def)
specified : a -> WithDefault a def
  Totality: total
  Visibility: export
defaulted : WithDefault a def
  Totality: total
  Visibility: export
collapseDefault : WithDefault a def -> a
  Totality: total
  Visibility: export
onWithDefault : Lazy b -> (a -> b) -> WithDefault a def -> b
  Totality: total
  Visibility: export
data Decl : Type
  Totality: total
  Visibility: public export
  Constructors:
  
IClaim : FC -> Count -> Visibility -> List FnOpt -> ITy -> Decl
  
IData : FC -> WithDefault Visibility Private -> Maybe TotalReq -> Data -> Decl
  
IDef : FC -> Name -> List Clause -> Decl
  
IParameters : FC -> List (Name, (Count, (PiInfo TTImp, TTImp))) -> List Decl -> Decl
  
IRecord : FC -> Maybe String -> WithDefault Visibility Private -> Maybe TotalReq -> Record -> Decl
  
INamespace : FC -> Namespace -> List Decl -> Decl
  
ITransform : FC -> Name -> TTImp -> TTImp -> Decl
  
IRunElabDecl : FC -> TTImp -> Decl
  
ILog : Maybe (List String, Nat) -> Decl
  
IBuiltin : FC -> BuiltinType -> Name -> Decl

  Hints:
  
Eq TTImp => Eq Decl
  
Show Decl
getFC : TTImp -> FC
  Totality: total
  Visibility: public export
mapTopmostFC : (FC -> FC) -> TTImp -> TTImp
  Totality: total
  Visibility: public export
data Mode : Type
  Totality: total
  Visibility: public export
  Constructors:
  
InDecl : Mode
  
InCase : Mode
showClause : Mode -> Clause -> String
  Totality: total
  Visibility: public export
data Argument : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Arg : FC -> a -> Argument a
  
NamedArg : FC -> Name -> a -> Argument a
  
AutoArg : FC -> a -> Argument a

  Hint: 
Functor Argument
isExplicit : Argument a -> Maybe (FC, a)
  Totality: total
  Visibility: public export
fromPiInfo : FC -> PiInfo t -> Maybe Name -> a -> Maybe (Argument a)
  Totality: total
  Visibility: public export
iApp : TTImp -> Argument TTImp -> TTImp
  Totality: total
  Visibility: public export
unArg : Argument a -> a
  Totality: total
  Visibility: public export
apply : TTImp -> List (Argument TTImp) -> TTImp
  We often apply multiple arguments, this makes things simpler

  Totality: total
  Visibility: public export
data IsAppView : (FC, Name) -> SnocList (Argument TTImp) -> TTImp -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
AVVar : IsAppView (fc, t) [<] (IVar fc t)
  
AVApp : IsAppView x ts f -> IsAppView x (ts :< Arg fc t) (IApp fc f t)
  
AVNamedApp : IsAppView x ts f -> IsAppView x (ts :< NamedArg fc n t) (INamedApp fc f n t)
  
AVAutoApp : IsAppView x ts f -> IsAppView x (ts :< AutoArg fc t) (IAutoApp fc f a)
record AppView : TTImp -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkAppView : (head : (FC, Name)) -> (args : SnocList (Argument TTImp)) -> (0 _ : IsAppView head args t) -> AppView t

  Projections:
  
.args : AppView t -> SnocList (Argument TTImp)
  
.head : AppView t -> (FC, Name)
  
0 .isAppView : ({rec:0} : AppView t) -> IsAppView (head {rec:0}) (args {rec:0}) t
.head : AppView t -> (FC, Name)
  Totality: total
  Visibility: public export
head : AppView t -> (FC, Name)
  Totality: total
  Visibility: public export
.args : AppView t -> SnocList (Argument TTImp)
  Totality: total
  Visibility: public export
args : AppView t -> SnocList (Argument TTImp)
  Totality: total
  Visibility: public export
0 .isAppView : ({rec:0} : AppView t) -> IsAppView (head {rec:0}) (args {rec:0}) t
  Totality: total
  Visibility: public export
0 isAppView : ({rec:0} : AppView t) -> IsAppView (head {rec:0}) (args {rec:0}) t
  Totality: total
  Visibility: public export
appView : (t : TTImp) -> Maybe (AppView t)
  Totality: total
  Visibility: public export
mapTTImp : (TTImp -> TTImp) -> TTImp -> TTImp
  Totality: total
  Visibility: public export
mapPiInfo : (TTImp -> TTImp) -> PiInfo TTImp -> PiInfo TTImp
  Totality: total
  Visibility: public export
mapClause : (TTImp -> TTImp) -> Clause -> Clause
  Totality: total
  Visibility: public export
mapITy : (TTImp -> TTImp) -> ITy -> ITy
  Totality: total
  Visibility: public export
mapFnOpt : (TTImp -> TTImp) -> FnOpt -> FnOpt
  Totality: total
  Visibility: public export
mapData : (TTImp -> TTImp) -> Data -> Data
  Totality: total
  Visibility: public export
mapIField : (TTImp -> TTImp) -> IField -> IField
  Totality: total
  Visibility: public export
mapRecord : (TTImp -> TTImp) -> Record -> Record
  Totality: total
  Visibility: public export
mapDecl : (TTImp -> TTImp) -> Decl -> Decl
  Totality: total
  Visibility: public export
mapIFieldUpdate : (TTImp -> TTImp) -> IFieldUpdate -> IFieldUpdate
  Totality: total
  Visibility: public export
mapAltType : (TTImp -> TTImp) -> AltType -> AltType
  Totality: total
  Visibility: public export
mapATTImp : Applicative m => (m TTImp -> m TTImp) -> TTImp -> m TTImp
  Totality: total
  Visibility: public export
mapMPiInfo : Applicative m => (m TTImp -> m TTImp) -> PiInfo TTImp -> m (PiInfo TTImp)
  Totality: total
  Visibility: public export
mapMClause : Applicative m => (m TTImp -> m TTImp) -> Clause -> m Clause
  Totality: total
  Visibility: public export
mapMITy : Applicative m => (m TTImp -> m TTImp) -> ITy -> m ITy
  Totality: total
  Visibility: public export
mapMFnOpt : Applicative m => (m TTImp -> m TTImp) -> FnOpt -> m FnOpt
  Totality: total
  Visibility: public export
mapMData : Applicative m => (m TTImp -> m TTImp) -> Data -> m Data
  Totality: total
  Visibility: public export
mapMIField : Applicative m => (m TTImp -> m TTImp) -> IField -> m IField
  Totality: total
  Visibility: public export
mapMRecord : Applicative m => (m TTImp -> m TTImp) -> Record -> m Record
  Totality: total
  Visibility: public export
mapMDecl : Applicative m => (m TTImp -> m TTImp) -> Decl -> m Decl
  Totality: total
  Visibility: public export
mapMIFieldUpdate : Applicative m => (m TTImp -> m TTImp) -> IFieldUpdate -> m IFieldUpdate
  Totality: total
  Visibility: public export
mapMAltType : Applicative m => (m TTImp -> m TTImp) -> AltType -> m AltType
  Totality: total
  Visibility: public export
mapMTTImp : Monad m => (TTImp -> m TTImp) -> TTImp -> m TTImp
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Language.Reflection.TTImp(source)
Reexports
import public Language.Reflection.TT
Definitions
data BindMode : Type
  Totality: total
  Visibility: public export
  Constructors:
  
PI : Count -> BindMode
  
PATTERN : BindMode
  
COVERAGE : BindMode
  
NONE : BindMode

  Hint: 
Eq BindMode
data UseSide : Type
  Totality: total
  Visibility: public export
  Constructors:
  
UseLeft : UseSide
  
UseRight : UseSide

  Hint: 
Eq UseSide
data DotReason : Type
  Totality: total
  Visibility: public export
  Constructors:
  
NonLinearVar : DotReason
  
VarApplied : DotReason
  
NotConstructor : DotReason
  
ErasedArg : DotReason
  
UserDotted : DotReason
  
UnknownDot : DotReason
  
UnderAppliedCon : DotReason

  Hint: 
Eq DotReason
data TTImp : Type
  Totality: total
  Visibility: public export
  Constructors:
  
IVar : FC -> Name -> TTImp
  
IPi : FC -> Count -> PiInfo TTImp -> Maybe Name -> TTImp -> TTImp -> TTImp
  
ILam : FC -> Count -> PiInfo TTImp -> Maybe Name -> TTImp -> TTImp -> TTImp
  
ILet : FC -> FC -> Count -> Name -> TTImp -> TTImp -> TTImp -> TTImp
  
ICase : FC -> List FnOpt -> TTImp -> TTImp -> List Clause -> TTImp
  
ILocal : FC -> List Decl -> TTImp -> TTImp
  
IUpdate : FC -> List IFieldUpdate -> TTImp -> TTImp
  
IApp : FC -> TTImp -> TTImp -> TTImp
  
INamedApp : FC -> TTImp -> Name -> TTImp -> TTImp
  
IAutoApp : FC -> TTImp -> TTImp -> TTImp
  
IWithApp : FC -> TTImp -> TTImp -> TTImp
  
ISearch : FC -> Nat -> TTImp
  
IAlternative : FC -> AltType -> List TTImp -> TTImp
  
IRewrite : FC -> TTImp -> TTImp -> TTImp
  
IBindHere : FC -> BindMode -> TTImp -> TTImp
  
IBindVar : FC -> String -> TTImp
  
IAs : FC -> FC -> UseSide -> Name -> TTImp -> TTImp
  
IMustUnify : FC -> DotReason -> TTImp -> TTImp
  
IDelayed : FC -> LazyReason -> TTImp -> TTImp
  
IDelay : FC -> TTImp -> TTImp
  
IForce : FC -> TTImp -> TTImp
  
IQuote : FC -> TTImp -> TTImp
  
IQuoteName : FC -> Name -> TTImp
  
IQuoteDecl : FC -> List Decl -> TTImp
  
IUnquote : FC -> TTImp -> TTImp
  
IPrimVal : FC -> Constant -> TTImp
  
IType : FC -> TTImp
  
IHole : FC -> String -> TTImp
  
Implicit : FC -> Bool -> TTImp
  
IWithUnambigNames : FC -> List (FC, Name) -> TTImp -> TTImp

  Hints:
  
Eq TTImp => Eq Clause
  
Eq TTImp => Eq IFieldUpdate
  
Eq TTImp => Eq AltType
  
Eq TTImp => Eq FnOpt
  
Eq TTImp => Eq ITy
  
Eq TTImp => Eq Data
  
Eq TTImp => Eq IField
  
Eq TTImp => Eq Record
  
Eq TTImp => Eq Decl
  
Eq TTImp
  
Show TTImp
data IFieldUpdate : Type
  Totality: total
  Visibility: public export
  Constructors:
  
ISetField : List String -> TTImp -> IFieldUpdate
  
ISetFieldApp : List String -> TTImp -> IFieldUpdate

  Hints:
  
Eq TTImp => Eq IFieldUpdate
  
Show IFieldUpdate
data AltType : Type
  Totality: total
  Visibility: public export
  Constructors:
  
FirstSuccess : AltType
  
Unique : AltType
  
UniqueDefault : TTImp -> AltType

  Hint: 
Eq TTImp => Eq AltType
data FnOpt : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Inline : FnOpt
  
NoInline : FnOpt
  
Deprecate : FnOpt
  
TCInline : FnOpt
  
Hint : Bool -> FnOpt
  
GlobalHint : Bool -> FnOpt
  
ExternFn : FnOpt
  
ForeignFn : List TTImp -> FnOpt
  
ForeignExport : List TTImp -> FnOpt
  
Invertible : FnOpt
  
Totality : TotalReq -> FnOpt
  
Macro : FnOpt
  
SpecArgs : List Name -> FnOpt

  Hint: 
Eq TTImp => Eq FnOpt
data ITy : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkTy : FC -> FC -> Name -> TTImp -> ITy

  Hints:
  
Eq TTImp => Eq ITy
  
Show ITy
data DataOpt : Type
  Totality: total
  Visibility: public export
  Constructors:
  
SearchBy : List Name -> DataOpt
  
NoHints : DataOpt
  
UniqueSearch : DataOpt
  
External : DataOpt
  
NoNewtype : DataOpt

  Hint: 
Eq DataOpt
data Data : Type
  Totality: total
  Visibility: public export
  Constructors:
  
MkData : FC -> Name -> Maybe TTImp -> List DataOpt -> List ITy -> Data
  
MkLater : FC -> Name -> TTImp -> Data

  Hints:
  
Eq TTImp => Eq Data
  
Show Data
data IField : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkIField : FC -> Count -> PiInfo TTImp -> Name -> TTImp -> IField

  Hints:
  
Eq TTImp => Eq IField
  
Show IField
data Record : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkRecord : FC -> Name -> List (Name, (Count, (PiInfo TTImp, TTImp))) -> List DataOpt -> Name -> List IField -> Record

  Hints:
  
Eq TTImp => Eq Record
  
Show Record
data WithFlag : Type
  Totality: total
  Visibility: public export
  Constructor: 
Syntactic : WithFlag

  Hint: 
Eq WithFlag
data Clause : Type
  Totality: total
  Visibility: public export
  Constructors:
  
PatClause : FC -> TTImp -> TTImp -> Clause
  
WithClause : FC -> TTImp -> Count -> TTImp -> Maybe Name -> List WithFlag -> List Clause -> Clause
  
ImpossibleClause : FC -> TTImp -> Clause

  Hint: 
Eq TTImp => Eq Clause
data WithDefault : (a : Type) -> a -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
DefaultedValue : WithDefault a def
  
SpecifiedValue : a -> WithDefault a def

  Hints:
  
Eq a => Eq (WithDefault a def)
  
Ord a => Ord (WithDefault a def)
  
Show a => Show (WithDefault a def)
specified : a -> WithDefault a def
  Totality: total
  Visibility: export
defaulted : WithDefault a def
  Totality: total
  Visibility: export
collapseDefault : WithDefault a def -> a
  Totality: total
  Visibility: export
onWithDefault : Lazy b -> (a -> b) -> WithDefault a def -> b
  Totality: total
  Visibility: export
data Decl : Type
  Totality: total
  Visibility: public export
  Constructors:
  
IClaim : FC -> Count -> Visibility -> List FnOpt -> ITy -> Decl
  
IData : FC -> WithDefault Visibility Private -> Maybe TotalReq -> Data -> Decl
  
IDef : FC -> Name -> List Clause -> Decl
  
IParameters : FC -> List (Name, (Count, (PiInfo TTImp, TTImp))) -> List Decl -> Decl
  
IRecord : FC -> Maybe String -> WithDefault Visibility Private -> Maybe TotalReq -> Record -> Decl
  
INamespace : FC -> Namespace -> List Decl -> Decl
  
ITransform : FC -> Name -> TTImp -> TTImp -> Decl
  
IRunElabDecl : FC -> TTImp -> Decl
  
ILog : Maybe (List String, Nat) -> Decl
  
IBuiltin : FC -> BuiltinType -> Name -> Decl

  Hints:
  
Eq TTImp => Eq Decl
  
Show Decl
getFC : TTImp -> FC
  Totality: total
  Visibility: public export
mapTopmostFC : (FC -> FC) -> TTImp -> TTImp
  Totality: total
  Visibility: public export
data Mode : Type
  Totality: total
  Visibility: public export
  Constructors:
  
InDecl : Mode
  
InCase : Mode
showClause : Mode -> Clause -> String
  Totality: total
  Visibility: public export
data Argument : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Arg : FC -> a -> Argument a
  
NamedArg : FC -> Name -> a -> Argument a
  
AutoArg : FC -> a -> Argument a

  Hint: 
Functor Argument
isExplicit : Argument a -> Maybe (FC, a)
  Totality: total
  Visibility: public export
fromPiInfo : FC -> PiInfo t -> Maybe Name -> a -> Maybe (Argument a)
  Totality: total
  Visibility: public export
iApp : TTImp -> Argument TTImp -> TTImp
  Totality: total
  Visibility: public export
unArg : Argument a -> a
  Totality: total
  Visibility: public export
apply : TTImp -> List (Argument TTImp) -> TTImp
  We often apply multiple arguments, this makes things simpler

  Totality: total
  Visibility: public export
data IsAppView : (FC, Name) -> SnocList (Argument TTImp) -> TTImp -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
AVVar : IsAppView (fc, t) [<] (IVar fc t)
  
AVApp : IsAppView x ts f -> IsAppView x (ts :< Arg fc t) (IApp fc f t)
  
AVNamedApp : IsAppView x ts f -> IsAppView x (ts :< NamedArg fc n t) (INamedApp fc f n t)
  
AVAutoApp : IsAppView x ts f -> IsAppView x (ts :< AutoArg fc t) (IAutoApp fc f a)
record AppView : TTImp -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkAppView : (head : (FC, Name)) -> (args : SnocList (Argument TTImp)) -> (0 _ : IsAppView head args t) -> AppView t

  Projections:
  
.args : AppView t -> SnocList (Argument TTImp)
  
.head : AppView t -> (FC, Name)
  
0 .isAppView : ({rec:0} : AppView t) -> IsAppView (head {rec:0}) (args {rec:0}) t
.head : AppView t -> (FC, Name)
  Totality: total
  Visibility: public export
head : AppView t -> (FC, Name)
  Totality: total
  Visibility: public export
.args : AppView t -> SnocList (Argument TTImp)
  Totality: total
  Visibility: public export
args : AppView t -> SnocList (Argument TTImp)
  Totality: total
  Visibility: public export
0 .isAppView : ({rec:0} : AppView t) -> IsAppView (head {rec:0}) (args {rec:0}) t
  Totality: total
  Visibility: public export
0 isAppView : ({rec:0} : AppView t) -> IsAppView (head {rec:0}) (args {rec:0}) t
  Totality: total
  Visibility: public export
appView : (t : TTImp) -> Maybe (AppView t)
  Totality: total
  Visibility: public export
mapTTImp : (TTImp -> TTImp) -> TTImp -> TTImp
  Totality: total
  Visibility: public export
mapPiInfo : (TTImp -> TTImp) -> PiInfo TTImp -> PiInfo TTImp
  Totality: total
  Visibility: public export
mapClause : (TTImp -> TTImp) -> Clause -> Clause
  Totality: total
  Visibility: public export
mapITy : (TTImp -> TTImp) -> ITy -> ITy
  Totality: total
  Visibility: public export
mapFnOpt : (TTImp -> TTImp) -> FnOpt -> FnOpt
  Totality: total
  Visibility: public export
mapData : (TTImp -> TTImp) -> Data -> Data
  Totality: total
  Visibility: public export
mapIField : (TTImp -> TTImp) -> IField -> IField
  Totality: total
  Visibility: public export
mapRecord : (TTImp -> TTImp) -> Record -> Record
  Totality: total
  Visibility: public export
mapDecl : (TTImp -> TTImp) -> Decl -> Decl
  Totality: total
  Visibility: public export
mapIFieldUpdate : (TTImp -> TTImp) -> IFieldUpdate -> IFieldUpdate
  Totality: total
  Visibility: public export
mapAltType : (TTImp -> TTImp) -> AltType -> AltType
  Totality: total
  Visibility: public export
mapATTImp' : Applicative m => (TTImp -> m TTImp -> m TTImp) -> TTImp -> m TTImp
  Totality: total
  Visibility: public export
mapMPiInfo : Applicative m => (TTImp -> m TTImp -> m TTImp) -> PiInfo TTImp -> m (PiInfo TTImp)
  Totality: total
  Visibility: public export
mapMClause : Applicative m => (TTImp -> m TTImp -> m TTImp) -> Clause -> m Clause
  Totality: total
  Visibility: public export
mapMITy : Applicative m => (TTImp -> m TTImp -> m TTImp) -> ITy -> m ITy
  Totality: total
  Visibility: public export
mapMFnOpt : Applicative m => (TTImp -> m TTImp -> m TTImp) -> FnOpt -> m FnOpt
  Totality: total
  Visibility: public export
mapMData : Applicative m => (TTImp -> m TTImp -> m TTImp) -> Data -> m Data
  Totality: total
  Visibility: public export
mapMIField : Applicative m => (TTImp -> m TTImp -> m TTImp) -> IField -> m IField
  Totality: total
  Visibility: public export
mapMRecord : Applicative m => (TTImp -> m TTImp -> m TTImp) -> Record -> m Record
  Totality: total
  Visibility: public export
mapMDecl : Applicative m => (TTImp -> m TTImp -> m TTImp) -> Decl -> m Decl
  Totality: total
  Visibility: public export
mapMIFieldUpdate : Applicative m => (TTImp -> m TTImp -> m TTImp) -> IFieldUpdate -> m IFieldUpdate
  Totality: total
  Visibility: public export
mapMAltType : Applicative m => (TTImp -> m TTImp -> m TTImp) -> AltType -> m AltType
  Totality: total
  Visibility: public export
mapATTImp : Monad m => (m TTImp -> m TTImp) -> TTImp -> m TTImp
  Totality: total
  Visibility: public export
mapMTTImp' : Monad m => (TTImp -> TTImp -> m TTImp) -> TTImp -> m TTImp
  Totality: total
  Visibility: public export
mapMTTImp : Monad m => (TTImp -> m TTImp) -> TTImp -> m TTImp
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/Language.Reflection.html b/base/docs/Language.Reflection.html
index 8f7aeab1ad..c7cfd8b18a 100644
--- a/base/docs/Language.Reflection.html
+++ b/base/docs/Language.Reflection.html
@@ -61,4 +61,4 @@
 
 
 
-
Language.Reflection(source)
Reexports
import public Language.Reflection.TT
import public Language.Reflection.TTImp
import public Control.Monad.Trans
Definitions
data LookupDir : Type
  Totality: total
  Visibility: public export
  Constructors:
  
ProjectDir : LookupDir
  The dir of the `ipkg`-file, or the current dir if there is no one
  
SourceDir : LookupDir
  The source dir set in the `ipkg`-file, or the current dir if there is no one
  
CurrentModuleDir : LookupDir
  The dir where the current module is located
  
  For the module `Language.Reflection` it would be `<source_dir>/Language/`
  
SubmodulesDir : LookupDir
  The dir where submodules of the current module are located
  
  For the module `Language.Reflection` it would be `<source_dir>/Language/Reflection/`
  
BuildDir : LookupDir
  The dir where built files are located, set in the `ipkg`-file and defaulted to `build`
data Elab : Type -> Type
  Elaboration scripts
  Where types/terms are returned, binders will have unique, if not
  necessarily human readabe, names

  Totality: total
  Visibility: export
  Constructors:
  
Pure : a -> Elab a
  
Map : (a -> b) -> Elab a -> Elab b
  
Ap : Elab (a -> b) -> Elab a -> Elab b
  
Bind : Elab a -> (a -> Elab b) -> Elab b
  
Fail : FC -> String -> Elab a
  
Warn : FC -> String -> Elab ()
  
Try : Elab a -> Elab a -> Elab a
  
LogMsg : String -> Nat -> String -> Elab ()
  Log a message. Takes a
  * topic
  * level
  * message
  
LogTerm : String -> Nat -> String -> TTImp -> Elab ()
  Print and log a term. Takes a
  * topic
  * level
  * message
  * term
  
LogSugaredTerm : String -> Nat -> String -> TTImp -> Elab ()
  Resugar, print and log a term. Takes a
  * topic
  * level
  * message
  * term
  
Check : TTImp -> Elab expected
  
Quote : (0 _ : val) -> Elab TTImp
  
Lambda : (0 x : Type) -> {0 ty : x -> Type} -> ((val : x) -> Elab (ty val)) -> Elab ((val : x) -> ty val)
  
Goal : Elab (Maybe TTImp)
  
LocalVars : Elab (List Name)
  
GenSym : String -> Elab Name
  
InCurrentNS : Name -> Elab Name
  
GetType : Name -> Elab (List (Name, TTImp))
  
GetInfo : Name -> Elab (List (Name, NameInfo))
  
GetLocalType : Name -> Elab TTImp
  
GetCons : Name -> Elab (List Name)
  
GetReferredFns : Name -> Elab (List Name)
  
GetCurrentFn : Elab (SnocList Name)
  
Declare : List Decl -> Elab ()
  
ReadFile : LookupDir -> String -> Elab (Maybe String)
  
WriteFile : LookupDir -> String -> String -> Elab ()
  
IdrisDir : LookupDir -> Elab String

  Hints:
  
Alternative Elab
  
Applicative Elab
  
Elaboration Elab
  
Functor Elab
  
Monad Elab
interface Elaboration : (Type -> Type) -> Type
  Parameters: m
Constraints: Monad m
Methods:
  
failAt : FC -> String -> m a
  Report an error in elaboration at some location
  
warnAt : FC -> String -> m ()
  Report a warning in elaboration at some location
  
try : Elab a -> Elab a -> m a
  Try the first elaborator. If it fails, reset the elaborator state and
  run the second
  
logMsg : String -> Nat -> String -> m ()
  Write a log message, if the log level is >= the given level
  
logTerm : String -> Nat -> String -> TTImp -> m ()
  Write a log message and a rendered term, if the log level is >= the given level
  
logSugaredTerm : String -> Nat -> String -> TTImp -> m ()
  Write a log message and a resugared & rendered term, if the log level is >= the given level
  
check : TTImp -> m expected
  Check that some TTImp syntax has the expected type
  Returns the type checked value
  
quote : (0 _ : val) -> m TTImp
  Return TTImp syntax of a given value
  
lambda : (0 x : Type) -> {0 ty : x -> Type} -> ((val : x) -> Elab (ty val)) -> m ((val : x) -> ty val)
  Build a lambda expression
  
goal : m (Maybe TTImp)
  Get the goal type of the current elaboration
  
  `Nothing` means the script is run in the top-level `%runElab` clause.
  If elaboration script is run in expression mode, this function will always return `Just`.
  In the case of unknown result type in the expression mode, returned `TTImp` would be an `IHole`.
  
localVars : m (List Name)
  Get the names of the local variables in scope
  
genSym : String -> m Name
  Generate a new unique name
  
inCurrentNS : Name -> m Name
  Given a name, return the name decorated with the current namespace
  
getType : Name -> m (List (Name, TTImp))
  Given a possibly ambiguous name, get all the matching names and their types
  
getInfo : Name -> m (List (Name, NameInfo))
  Get the metadata associated with a name. Returns all matching names and their types
  
getLocalType : Name -> m TTImp
  Get the type of a local variable
  
getCons : Name -> m (List Name)
  Get the constructors of a fully qualified data type name
  
getReferredFns : Name -> m (List Name)
  Get all the name of function definitions that a given definition refers to (transitively)
  
getCurrentFn : m (SnocList Name)
  Get the name of the current and outer functions, if we are in a function
  
declare : List Decl -> m ()
  Make some top level declarations
  
readFile : LookupDir -> String -> m (Maybe String)
  Read the contents of a file, if it is present
  
writeFile : LookupDir -> String -> String -> m ()
  Writes to a file, replacing existing contents, if were present
  
idrisDir : LookupDir -> m String
  Returns the specified type of dir related to the current idris project

Implementations:
  
Elaboration Elab
  
Elaboration m => MonadTrans t => Monad (t m) => Elaboration (t m)
failAt : Elaboration m => FC -> String -> m a
  Report an error in elaboration at some location

  Totality: total
  Visibility: public export
warnAt : Elaboration m => FC -> String -> m ()
  Report a warning in elaboration at some location

  Totality: total
  Visibility: public export
try : Elaboration m => Elab a -> Elab a -> m a
  Try the first elaborator. If it fails, reset the elaborator state and
  run the second

  Totality: total
  Visibility: public export
logMsg : Elaboration m => String -> Nat -> String -> m ()
  Write a log message, if the log level is >= the given level

  Totality: total
  Visibility: public export
logTerm : Elaboration m => String -> Nat -> String -> TTImp -> m ()
  Write a log message and a rendered term, if the log level is >= the given level

  Totality: total
  Visibility: public export
logSugaredTerm : Elaboration m => String -> Nat -> String -> TTImp -> m ()
  Write a log message and a resugared & rendered term, if the log level is >= the given level

  Totality: total
  Visibility: public export
check : Elaboration m => TTImp -> m expected
  Check that some TTImp syntax has the expected type
  Returns the type checked value

  Totality: total
  Visibility: public export
quote : Elaboration m => (0 _ : val) -> m TTImp
  Return TTImp syntax of a given value

  Totality: total
  Visibility: public export
lambda : Elaboration m => (0 x : Type) -> {0 ty : x -> Type} -> ((val : x) -> Elab (ty val)) -> m ((val : x) -> ty val)
  Build a lambda expression

  Totality: total
  Visibility: public export
goal : Elaboration m => m (Maybe TTImp)
  Get the goal type of the current elaboration
  
  `Nothing` means the script is run in the top-level `%runElab` clause.
  If elaboration script is run in expression mode, this function will always return `Just`.
  In the case of unknown result type in the expression mode, returned `TTImp` would be an `IHole`.

  Totality: total
  Visibility: public export
localVars : Elaboration m => m (List Name)
  Get the names of the local variables in scope

  Totality: total
  Visibility: public export
genSym : Elaboration m => String -> m Name
  Generate a new unique name

  Totality: total
  Visibility: public export
inCurrentNS : Elaboration m => Name -> m Name
  Given a name, return the name decorated with the current namespace

  Totality: total
  Visibility: public export
getType : Elaboration m => Name -> m (List (Name, TTImp))
  Given a possibly ambiguous name, get all the matching names and their types

  Totality: total
  Visibility: public export
getInfo : Elaboration m => Name -> m (List (Name, NameInfo))
  Get the metadata associated with a name. Returns all matching names and their types

  Totality: total
  Visibility: public export
getLocalType : Elaboration m => Name -> m TTImp
  Get the type of a local variable

  Totality: total
  Visibility: public export
getCons : Elaboration m => Name -> m (List Name)
  Get the constructors of a fully qualified data type name

  Totality: total
  Visibility: public export
getReferredFns : Elaboration m => Name -> m (List Name)
  Get all the name of function definitions that a given definition refers to (transitively)

  Totality: total
  Visibility: public export
getCurrentFn : Elaboration m => m (SnocList Name)
  Get the name of the current and outer functions, if we are in a function

  Totality: total
  Visibility: public export
declare : Elaboration m => List Decl -> m ()
  Make some top level declarations

  Totality: total
  Visibility: public export
readFile : Elaboration m => LookupDir -> String -> m (Maybe String)
  Read the contents of a file, if it is present

  Totality: total
  Visibility: public export
writeFile : Elaboration m => LookupDir -> String -> String -> m ()
  Writes to a file, replacing existing contents, if were present

  Totality: total
  Visibility: public export
idrisDir : Elaboration m => LookupDir -> m String
  Returns the specified type of dir related to the current idris project

  Totality: total
  Visibility: public export
fail : Elaboration m => String -> m a
  Report an error in elaboration

  Totality: total
  Visibility: export
warn : Elaboration m => String -> m ()
  Report an error in elaboration

  Totality: total
  Visibility: export
logGoal : Elaboration m => String -> Nat -> String -> m ()
  Log the current goal type, if the log level is >= the given level

  Totality: total
  Visibility: export
catch : Elaboration m => Elab a -> m (Maybe a)
  Catch failures and use the `Maybe` monad instead

  Totality: total
  Visibility: export
search : Elaboration m => (ty : Type) -> m (Maybe ty)
  Run proof search to attempt to find a value of the input type.
  Useful to check whether a give interface constraint is satisfied.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Language.Reflection(source)
Reexports
import public Language.Reflection.TT
import public Language.Reflection.TTImp
import public Control.Monad.Trans
Definitions
data LookupDir : Type
  Totality: total
  Visibility: public export
  Constructors:
  
ProjectDir : LookupDir
  The dir of the `ipkg`-file, or the current dir if there is no one
  
SourceDir : LookupDir
  The source dir set in the `ipkg`-file, or the current dir if there is no one
  
CurrentModuleDir : LookupDir
  The dir where the current module is located
  
  For the module `Language.Reflection` it would be `<source_dir>/Language/`
  
SubmodulesDir : LookupDir
  The dir where submodules of the current module are located
  
  For the module `Language.Reflection` it would be `<source_dir>/Language/Reflection/`
  
BuildDir : LookupDir
  The dir where built files are located, set in the `ipkg`-file and defaulted to `build`
data Elab : Type -> Type
  Elaboration scripts
  Where types/terms are returned, binders will have unique, if not
  necessarily human readabe, names

  Totality: total
  Visibility: export
  Constructors:
  
Pure : a -> Elab a
  
Map : (a -> b) -> Elab a -> Elab b
  
Ap : Elab (a -> b) -> Elab a -> Elab b
  
Bind : Elab a -> (a -> Elab b) -> Elab b
  
Fail : FC -> String -> Elab a
  
Warn : FC -> String -> Elab ()
  
Try : Elab a -> Elab a -> Elab a
  
LogMsg : String -> Nat -> String -> Elab ()
  Log a message. Takes a
  * topic
  * level
  * message
  
LogTerm : String -> Nat -> String -> TTImp -> Elab ()
  Print and log a term. Takes a
  * topic
  * level
  * message
  * term
  
LogSugaredTerm : String -> Nat -> String -> TTImp -> Elab ()
  Resugar, print and log a term. Takes a
  * topic
  * level
  * message
  * term
  
Check : TTImp -> Elab expected
  
Quote : (0 _ : val) -> Elab TTImp
  
Lambda : (0 x : Type) -> {0 ty : x -> Type} -> ((val : x) -> Elab (ty val)) -> Elab ((val : x) -> ty val)
  
Goal : Elab (Maybe TTImp)
  
LocalVars : Elab (List Name)
  
GenSym : String -> Elab Name
  
InCurrentNS : Name -> Elab Name
  
GetType : Name -> Elab (List (Name, TTImp))
  
GetInfo : Name -> Elab (List (Name, NameInfo))
  
GetLocalType : Name -> Elab TTImp
  
GetCons : Name -> Elab (List Name)
  
GetReferredFns : Name -> Elab (List Name)
  
GetCurrentFn : Elab (SnocList Name)
  
Declare : List Decl -> Elab ()
  
ReadFile : LookupDir -> String -> Elab (Maybe String)
  
WriteFile : LookupDir -> String -> String -> Elab ()
  
IdrisDir : LookupDir -> Elab String

  Hints:
  
Alternative Elab
  
Applicative Elab
  
Elaboration Elab
  
Functor Elab
  
Monad Elab
interface Elaboration : (Type -> Type) -> Type
  Parameters: m
Constraints: Monad m
Methods:
  
failAt : FC -> String -> m a
  Report an error in elaboration at some location
  
warnAt : FC -> String -> m ()
  Report a warning in elaboration at some location
  
try : Elab a -> Elab a -> m a
  Try the first elaborator. If it fails, reset the elaborator state and
  run the second
  
logMsg : String -> Nat -> String -> m ()
  Write a log message, if the log level is >= the given level
  
logTerm : String -> Nat -> String -> TTImp -> m ()
  Write a log message and a rendered term, if the log level is >= the given level
  
logSugaredTerm : String -> Nat -> String -> TTImp -> m ()
  Write a log message and a resugared & rendered term, if the log level is >= the given level
  
check : TTImp -> m expected
  Check that some TTImp syntax has the expected type
  Returns the type checked value
  
quote : (0 _ : val) -> m TTImp
  Return TTImp syntax of a given value
  
lambda : (0 x : Type) -> {0 ty : x -> Type} -> ((val : x) -> Elab (ty val)) -> m ((val : x) -> ty val)
  Build a lambda expression
  
goal : m (Maybe TTImp)
  Get the goal type of the current elaboration
  
  `Nothing` means the script is run in the top-level `%runElab` clause.
  If elaboration script is run in expression mode, this function will always return `Just`.
  In the case of unknown result type in the expression mode, returned `TTImp` would be an `IHole`.
  
localVars : m (List Name)
  Get the names of the local variables in scope
  
genSym : String -> m Name
  Generate a new unique name
  
inCurrentNS : Name -> m Name
  Given a name, return the name decorated with the current namespace
  
getType : Name -> m (List (Name, TTImp))
  Given a possibly ambiguous name, get all the matching names and their types
  
getInfo : Name -> m (List (Name, NameInfo))
  Get the metadata associated with a name. Returns all matching names and their types
  
getLocalType : Name -> m TTImp
  Get the type of a local variable
  
getCons : Name -> m (List Name)
  Get the constructors of a fully qualified data type name
  
getReferredFns : Name -> m (List Name)
  Get all the name of function definitions that a given definition refers to (transitively)
  
getCurrentFn : m (SnocList Name)
  Get the name of the current and outer functions, if we are in a function
  
declare : List Decl -> m ()
  Make some top level declarations
  
readFile : LookupDir -> String -> m (Maybe String)
  Read the contents of a file, if it is present
  
writeFile : LookupDir -> String -> String -> m ()
  Writes to a file, replacing existing contents, if were present
  
idrisDir : LookupDir -> m String
  Returns the specified type of dir related to the current idris project

Implementations:
  
Elaboration Elab
  
Elaboration m => MonadTrans t => Monad (t m) => Elaboration (t m)
failAt : Elaboration m => FC -> String -> m a
  Report an error in elaboration at some location

  Totality: total
  Visibility: public export
warnAt : Elaboration m => FC -> String -> m ()
  Report a warning in elaboration at some location

  Totality: total
  Visibility: public export
try : Elaboration m => Elab a -> Elab a -> m a
  Try the first elaborator. If it fails, reset the elaborator state and
  run the second

  Totality: total
  Visibility: public export
logMsg : Elaboration m => String -> Nat -> String -> m ()
  Write a log message, if the log level is >= the given level

  Totality: total
  Visibility: public export
logTerm : Elaboration m => String -> Nat -> String -> TTImp -> m ()
  Write a log message and a rendered term, if the log level is >= the given level

  Totality: total
  Visibility: public export
logSugaredTerm : Elaboration m => String -> Nat -> String -> TTImp -> m ()
  Write a log message and a resugared & rendered term, if the log level is >= the given level

  Totality: total
  Visibility: public export
check : Elaboration m => TTImp -> m expected
  Check that some TTImp syntax has the expected type
  Returns the type checked value

  Totality: total
  Visibility: public export
quote : Elaboration m => (0 _ : val) -> m TTImp
  Return TTImp syntax of a given value

  Totality: total
  Visibility: public export
lambda : Elaboration m => (0 x : Type) -> {0 ty : x -> Type} -> ((val : x) -> Elab (ty val)) -> m ((val : x) -> ty val)
  Build a lambda expression

  Totality: total
  Visibility: public export
goal : Elaboration m => m (Maybe TTImp)
  Get the goal type of the current elaboration
  
  `Nothing` means the script is run in the top-level `%runElab` clause.
  If elaboration script is run in expression mode, this function will always return `Just`.
  In the case of unknown result type in the expression mode, returned `TTImp` would be an `IHole`.

  Totality: total
  Visibility: public export
localVars : Elaboration m => m (List Name)
  Get the names of the local variables in scope

  Totality: total
  Visibility: public export
genSym : Elaboration m => String -> m Name
  Generate a new unique name

  Totality: total
  Visibility: public export
inCurrentNS : Elaboration m => Name -> m Name
  Given a name, return the name decorated with the current namespace

  Totality: total
  Visibility: public export
getType : Elaboration m => Name -> m (List (Name, TTImp))
  Given a possibly ambiguous name, get all the matching names and their types

  Totality: total
  Visibility: public export
getInfo : Elaboration m => Name -> m (List (Name, NameInfo))
  Get the metadata associated with a name. Returns all matching names and their types

  Totality: total
  Visibility: public export
getLocalType : Elaboration m => Name -> m TTImp
  Get the type of a local variable

  Totality: total
  Visibility: public export
getCons : Elaboration m => Name -> m (List Name)
  Get the constructors of a fully qualified data type name

  Totality: total
  Visibility: public export
getReferredFns : Elaboration m => Name -> m (List Name)
  Get all the name of function definitions that a given definition refers to (transitively)

  Totality: total
  Visibility: public export
getCurrentFn : Elaboration m => m (SnocList Name)
  Get the name of the current and outer functions, if we are in a function

  Totality: total
  Visibility: public export
declare : Elaboration m => List Decl -> m ()
  Make some top level declarations

  Totality: total
  Visibility: public export
readFile : Elaboration m => LookupDir -> String -> m (Maybe String)
  Read the contents of a file, if it is present

  Totality: total
  Visibility: public export
writeFile : Elaboration m => LookupDir -> String -> String -> m ()
  Writes to a file, replacing existing contents, if were present

  Totality: total
  Visibility: public export
idrisDir : Elaboration m => LookupDir -> m String
  Returns the specified type of dir related to the current idris project

  Totality: total
  Visibility: public export
fail : Elaboration m => String -> m a
  Report an error in elaboration

  Totality: total
  Visibility: export
warn : Elaboration m => String -> m ()
  Report an error in elaboration

  Totality: total
  Visibility: export
logGoal : Elaboration m => String -> Nat -> String -> m ()
  Log the current goal type, if the log level is >= the given level

  Totality: total
  Visibility: export
catch : Elaboration m => Elab a -> m (Maybe a)
  Catch failures and use the `Maybe` monad instead

  Totality: total
  Visibility: export
search : Elaboration m => (ty : Type) -> m (Maybe ty)
  Run proof search to attempt to find a value of the input type.
  Useful to check whether a give interface constraint is satisfied.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/Syntax.PreorderReasoning.Generic.html b/base/docs/Syntax.PreorderReasoning.Generic.html
index caf48006da..459f672554 100644
--- a/base/docs/Syntax.PreorderReasoning.Generic.html
+++ b/base/docs/Syntax.PreorderReasoning.Generic.html
@@ -61,4 +61,4 @@
 
 
 
-
Syntax.PreorderReasoning.Generic(source)
Definitions
data Step : (a -> a -> Type) -> a -> a -> Type
  Totality: total
  Visibility: public export
  Constructor: 
(...) : (y : a) -> leq x y -> Step leq x y
data FastDerivation : (a -> a -> Type) -> a -> a -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
(|~) : (x : a) -> FastDerivation leq x x
  
(<~) : FastDerivation leq x y -> Step leq y z -> FastDerivation leq x z
data DerivationType : FastDerivation leq x y -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
TrivialDerivation : DerivationType ((|~) x)
  
SingleStepDerivation : DerivationType ((|~) x <~ step)
  
NonTrivialDerivation : DerivationType ((der <~ step1) <~ step2)
derivationType : (der : FastDerivation leq x y) -> DerivationType der
  Visibility: public export
0 Prerequisite : DerivationType der -> Type
  Visibility: public export
inductivePrerequisite : (der : FastDerivation leq x y) -> (0 step1 : Step leq y z) -> (0 step2 : Step leq z w) -> Prerequisite (derivationType ((der <~ step1) <~ step2)) -> Prerequisite (derivationType (der <~ step1))
  Visibility: public export
preorderPrerequisite : Preorder dom leq => (der : FastDerivation leq x y) -> Prerequisite (derivationType der)
  Visibility: public export
CalcSmart : (der : FastDerivation leq x y) -> Prerequisite (derivationType der) => leq x y
  The Prerequisite for the derivation:
  0-length derivation: Reflexive dom leq
  1-length derivation: Unit (no prerequisite)
  2 steps of longer: Transitivity

  Visibility: public export
CalcWith : Preorder dom leq => FastDerivation leq x y -> leq x y
  Visibility: public export
(~~) : FastDerivation leq x y -> (0 _ : Step Equal y z) -> FastDerivation leq x z
  Visibility: public export
  Fixity Declarations:
  infixl operator, level 0
infixl operator, level 0
(..<) : Symmetric a leq => (y : a) -> leq y x -> Step leq x y
  Visibility: public export
  Fixity Declarations:
  infix operator, level 1
infix operator, level 1
(..>) : (y : a) -> leq x y -> Step leq x y
  Visibility: public export
  Fixity Declarations:
  infix operator, level 1
infix operator, level 1
(.=.) : Reflexive a leq => (y : a) -> x = y -> Step leq x y
  Visibility: public export
  Fixity Declarations:
  infix operator, level 1
infix operator, level 1
(.=>) : Reflexive a leq => (y : a) -> x = y -> Step leq x y
  Visibility: public export
  Fixity Declarations:
  infix operator, level 1
infix operator, level 1
(.=<) : Reflexive a leq => (y : a) -> y = x -> Step leq x y
  Visibility: public export
  Fixity Declarations:
  infix operator, level 1
infix operator, level 1
(~=) : FastDerivation leq x y -> (0 z : dom) -> y = z => FastDerivation leq x z
  Visibility: public export
  Fixity Declarations:
  infixl operator, level 0
infixl operator, level 0

\ No newline at end of file
+
Syntax.PreorderReasoning.Generic(source)
Definitions
data Step : (a -> a -> Type) -> a -> a -> Type
  Totality: total
  Visibility: public export
  Constructor: 
(...) : (y : a) -> leq x y -> Step leq x y
data FastDerivation : (a -> a -> Type) -> a -> a -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
(|~) : (x : a) -> FastDerivation leq x x
  
(<~) : FastDerivation leq x y -> Step leq y z -> FastDerivation leq x z
data DerivationType : FastDerivation leq x y -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
TrivialDerivation : DerivationType ((|~) x)
  
SingleStepDerivation : DerivationType ((|~) x <~ step)
  
NonTrivialDerivation : DerivationType ((der <~ step1) <~ step2)
derivationType : (der : FastDerivation leq x y) -> DerivationType der
  Visibility: public export
0 Prerequisite : DerivationType der -> Type
  Visibility: public export
inductivePrerequisite : (der : FastDerivation leq x y) -> (0 step1 : Step leq y z) -> (0 step2 : Step leq z w) -> Prerequisite (derivationType ((der <~ step1) <~ step2)) -> Prerequisite (derivationType (der <~ step1))
  Visibility: public export
preorderPrerequisite : Preorder dom leq => (der : FastDerivation leq x y) -> Prerequisite (derivationType der)
  Visibility: public export
CalcSmart : (der : FastDerivation leq x y) -> Prerequisite (derivationType der) => leq x y
  The Prerequisite for the derivation:
  0-length derivation: Reflexive dom leq
  1-length derivation: Unit (no prerequisite)
  2 steps of longer: Transitivity

  Visibility: public export
CalcWith : Preorder dom leq => FastDerivation leq x y -> leq x y
  Visibility: public export
(~~) : FastDerivation leq x y -> (0 _ : Step Equal y z) -> FastDerivation leq x z
  Visibility: public export
  Fixity Declarations:
  infixl operator, level 0
infixl operator, level 0
(..<) : Symmetric a leq => (y : a) -> leq y x -> Step leq x y
  Visibility: public export
  Fixity Declarations:
  infix operator, level 1
infix operator, level 1
(..>) : (y : a) -> leq x y -> Step leq x y
  Visibility: public export
  Fixity Declarations:
  infix operator, level 1
infix operator, level 1
(.=.) : Reflexive a leq => (y : a) -> x = y -> Step leq x y
  Visibility: public export
  Fixity Declarations:
  infix operator, level 1
infix operator, level 1
(.=>) : Reflexive a leq => (y : a) -> x = y -> Step leq x y
  Visibility: public export
  Fixity Declarations:
  infix operator, level 1
infix operator, level 1
(.=<) : Reflexive a leq => (y : a) -> y = x -> Step leq x y
  Visibility: public export
  Fixity Declarations:
  infix operator, level 1
infix operator, level 1
(~=) : FastDerivation leq x y -> (0 z : dom) -> y = z => FastDerivation leq x z
  Visibility: public export
  Fixity Declarations:
  infixl operator, level 0
infixl operator, level 0

\ No newline at end of file
diff --git a/base/docs/Syntax.PreorderReasoning.html b/base/docs/Syntax.PreorderReasoning.html
index 2833bd0774..6ae6e1e831 100644
--- a/base/docs/Syntax.PreorderReasoning.html
+++ b/base/docs/Syntax.PreorderReasoning.html
@@ -63,4 +63,4 @@
 
 
Syntax.PreorderReasoning(source)
Until Idris2 starts supporting the 'syntax' keyword, here's a
 poor-man's equational reasoning
-
Definitions
data Step : a -> b -> Type
  Slightly nicer syntax for justifying equations:
  ```
  |~ a
  ~~ b ...( justification )
  ```
  and we can think of the `...( justification )` as ASCII art for a thought bubble.

  Totality: total
  Visibility: public export
  Constructor: 
(...) : (0 y : a) -> (0 _ : x = y) -> Step x y
data FastDerivation : a -> b -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
(|~) : (0 x : a) -> FastDerivation x x
  
(~~) : FastDerivation x y -> Step y z -> FastDerivation x z
Calc : (0 _ : FastDerivation x y) -> x = y
  Visibility: public export
(..<) : (0 y : a) -> (0 _ : y = x) -> Step x y
  Visibility: public export
  Fixity Declarations:
  infix operator, level 1
infix operator, level 1
(..>) : (0 y : a) -> (0 _ : x = y) -> Step x y
  Visibility: public export
  Fixity Declarations:
  infix operator, level 1
infix operator, level 1
(~=) : FastDerivation x y -> (0 z : dom) -> {auto 0 _ : y = z} -> FastDerivation x z
  Use a judgemental equality but is not trivial to the reader.

  Visibility: public export
  Fixity Declarations:
  infixl operator, level 0
infixl operator, level 0

\ No newline at end of file
+
Definitions
data Step : a -> b -> Type
  Slightly nicer syntax for justifying equations:
  ```
  |~ a
  ~~ b ...( justification )
  ```
  and we can think of the `...( justification )` as ASCII art for a thought bubble.

  Totality: total
  Visibility: public export
  Constructor: 
(...) : (0 y : a) -> (0 _ : x = y) -> Step x y
data FastDerivation : a -> b -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
(|~) : (0 x : a) -> FastDerivation x x
  
(~~) : FastDerivation x y -> Step y z -> FastDerivation x z
Calc : (0 _ : FastDerivation x y) -> x = y
  Visibility: public export
(..<) : (0 y : a) -> (0 _ : y = x) -> Step x y
  Visibility: public export
  Fixity Declarations:
  infix operator, level 1
infix operator, level 1
(..>) : (0 y : a) -> (0 _ : x = y) -> Step x y
  Visibility: public export
  Fixity Declarations:
  infix operator, level 1
infix operator, level 1
(~=) : FastDerivation x y -> (0 z : dom) -> {auto 0 _ : y = z} -> FastDerivation x z
  Use a judgemental equality but is not trivial to the reader.

  Visibility: public export
  Fixity Declarations:
  infixl operator, level 0
infixl operator, level 0

\ No newline at end of file
diff --git a/base/docs/System.Clock.html b/base/docs/System.Clock.html
index 598dd57501..9560f07a01 100644
--- a/base/docs/System.Clock.html
+++ b/base/docs/System.Clock.html
@@ -62,4 +62,4 @@
 
 
 
System.Clock(source)
Types and functions for reasoning about time.
-
Definitions
data ClockType : Type
  The various types of system clock available.

  Totality: total
  Visibility: public export
  Constructors:
  
UTC : ClockType
  The time elapsed since the "epoch:" 00:00:00 UTC, January 1, 1970
  
Monotonic : ClockType
  The time elapsed since some arbitrary point in the past
  
Duration : ClockType
  Representing a time duration.
  
Process : ClockType
  The amount of CPU time used by the current process.
  
Thread : ClockType
  The amount of CPU time used by the current thread.
  
GCCPU : ClockType
  The current process's CPU time consumed by the garbage collector.
  
GCReal : ClockType
  The current process's real time consumed by the garbage collector.

  Hints:
  
Eq (Clock type)
  
Ord (Clock type)
  
Show ClockType
  
Show (Clock type)
data Clock : ClockType -> Type
  A clock recording some time in seconds and nanoseconds. The "type" of time
  recorded is indicated by the given `ClockType`.

  Totality: total
  Visibility: public export
  Constructor: 
MkClock : Integer -> Integer -> Clock type

  Hints:
  
Eq (Clock type)
  
Ord (Clock type)
  
Show (Clock type)
showTime : Nat -> Nat -> Clock type -> String
  Display a `Clock`'s content, padding the seconds and nanoseconds as
  appropriate.
  
  @ s   the number of digits used to display the seconds
  @ ns  the number of digits used to display the nanosecondns
  @ clk the Clock whose contents to display

  Totality: total
  Visibility: export
seconds : Clock type -> Integer
  A helper to deconstruct a Clock.

  Totality: total
  Visibility: public export
nanoseconds : Clock type -> Integer
  A helper to deconstruct a Clock.

  Totality: total
  Visibility: public export
makeDuration : Integer -> Integer -> Clock Duration
  Make a duration value.
  
  @ s  the number of seconds in the duration
  @ ns the number of nanoseconds in the duration

  Totality: total
  Visibility: public export
data ClockTypeMandatory : Type
  Note: Backends are required to implement UTC, monotonic time, CPU time in
  current process/thread, and time duration; the rest are optional.

  Totality: total
  Visibility: export
  Constructors:
  
Mandatory : ClockTypeMandatory
  
Optional : ClockTypeMandatory
isClockMandatory : ClockType -> ClockTypeMandatory
  Determine whether the specified `ClockType` is required to be implemented by
  all backends.

  Totality: total
  Visibility: public export
clockTimeReturnType : ClockType -> Type
  The return type of a function using a `Clock` depends on the type of
  `Clock`:
  * `Optional` clocks may not be implemented, so we might not return anything
  * `Mandatory` clocks have to be implemented, so we _will_ return something

  Totality: total
  Visibility: public export
clockTime : (typ : ClockType) -> IO (clockTimeReturnType typ)
  Fetch the system clock of a given kind. If the clock is mandatory,
  we return a `Clock type` else, we return a `Maybe (Clock type)`.

  Totality: total
  Visibility: public export
toNano : Clock type -> Integer
  Convert the time in the given clock to nanoseconds.

  Totality: total
  Visibility: public export
fromNano : Integer -> Clock type
  Convert some time in nanoseconds to a `Clock` containing that time.
  
  @ n the time in nanoseconds

  Totality: total
  Visibility: public export
timeDifference : Clock type -> Clock type -> Clock Duration
  Compute difference between two clocks of the same type.
  @ end the end time
  @ start the start time

  Totality: total
  Visibility: public export
addDuration : Clock type -> Clock Duration -> Clock type
  Add a duration to a clock value.

  Totality: total
  Visibility: public export
subtractDuration : Clock type -> Clock Duration -> Clock type
  Subtract a duration from a clock value.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
data ClockType : Type
  The various types of system clock available.

  Totality: total
  Visibility: public export
  Constructors:
  
UTC : ClockType
  The time elapsed since the "epoch:" 00:00:00 UTC, January 1, 1970
  
Monotonic : ClockType
  The time elapsed since some arbitrary point in the past
  
Duration : ClockType
  Representing a time duration.
  
Process : ClockType
  The amount of CPU time used by the current process.
  
Thread : ClockType
  The amount of CPU time used by the current thread.
  
GCCPU : ClockType
  The current process's CPU time consumed by the garbage collector.
  
GCReal : ClockType
  The current process's real time consumed by the garbage collector.

  Hints:
  
Eq (Clock type)
  
Ord (Clock type)
  
Show ClockType
  
Show (Clock type)
data Clock : ClockType -> Type
  A clock recording some time in seconds and nanoseconds. The "type" of time
  recorded is indicated by the given `ClockType`.

  Totality: total
  Visibility: public export
  Constructor: 
MkClock : Integer -> Integer -> Clock type

  Hints:
  
Eq (Clock type)
  
Ord (Clock type)
  
Show (Clock type)
showTime : Nat -> Nat -> Clock type -> String
  Display a `Clock`'s content, padding the seconds and nanoseconds as
  appropriate.
  
  @ s   the number of digits used to display the seconds
  @ ns  the number of digits used to display the nanosecondns
  @ clk the Clock whose contents to display

  Totality: total
  Visibility: export
seconds : Clock type -> Integer
  A helper to deconstruct a Clock.

  Totality: total
  Visibility: public export
nanoseconds : Clock type -> Integer
  A helper to deconstruct a Clock.

  Totality: total
  Visibility: public export
makeDuration : Integer -> Integer -> Clock Duration
  Make a duration value.
  
  @ s  the number of seconds in the duration
  @ ns the number of nanoseconds in the duration

  Totality: total
  Visibility: public export
data ClockTypeMandatory : Type
  Note: Backends are required to implement UTC, monotonic time, CPU time in
  current process/thread, and time duration; the rest are optional.

  Totality: total
  Visibility: export
  Constructors:
  
Mandatory : ClockTypeMandatory
  
Optional : ClockTypeMandatory
isClockMandatory : ClockType -> ClockTypeMandatory
  Determine whether the specified `ClockType` is required to be implemented by
  all backends.

  Totality: total
  Visibility: public export
clockTimeReturnType : ClockType -> Type
  The return type of a function using a `Clock` depends on the type of
  `Clock`:
  * `Optional` clocks may not be implemented, so we might not return anything
  * `Mandatory` clocks have to be implemented, so we _will_ return something

  Totality: total
  Visibility: public export
clockTime : (typ : ClockType) -> IO (clockTimeReturnType typ)
  Fetch the system clock of a given kind. If the clock is mandatory,
  we return a `Clock type` else, we return a `Maybe (Clock type)`.

  Totality: total
  Visibility: public export
toNano : Clock type -> Integer
  Convert the time in the given clock to nanoseconds.

  Totality: total
  Visibility: public export
fromNano : Integer -> Clock type
  Convert some time in nanoseconds to a `Clock` containing that time.
  
  @ n the time in nanoseconds

  Totality: total
  Visibility: public export
timeDifference : Clock type -> Clock type -> Clock Duration
  Compute difference between two clocks of the same type.
  @ end the end time
  @ start the start time

  Totality: total
  Visibility: public export
addDuration : Clock type -> Clock Duration -> Clock type
  Add a duration to a clock value.

  Totality: total
  Visibility: public export
subtractDuration : Clock type -> Clock Duration -> Clock type
  Subtract a duration from a clock value.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/System.Concurrency.html b/base/docs/System.Concurrency.html
index c7f493d6c3..40b8f6430a 100644
--- a/base/docs/System.Concurrency.html
+++ b/base/docs/System.Concurrency.html
@@ -67,4 +67,4 @@
 Given that different back ends will have entirely different threading
 models, it might be unavoidable, but we might want to think about possible
 primitives that back ends should support.
-
Definitions
setThreadData : HasIO io => a -> io ()
  Set the data stored in a thread's parameter to the given value.
  Currently only supported under the scheme backends.

  Totality: total
  Visibility: export
getThreadData : HasIO io => (a : Type) -> io a
  Get the data stored in a thread's parameter.
  Currently only supported under the scheme backends.

  Totality: total
  Visibility: export
data Mutex : Type
  Totality: total
  Visibility: export
makeMutex : HasIO io => io Mutex
  Creates and returns a new mutex.

  Totality: total
  Visibility: export
mutexAcquire : HasIO io => Mutex -> io ()
  Acquires the mutex identified by `mutex`. The thread blocks until the mutex
  has been acquired.
  
  Mutexes are recursive in Posix threads terminology, which means that the
  calling thread can use mutex-acquire to (re)acquire a mutex it already has.
  In this case, an equal number of mutex-release calls is necessary to release
  the mutex.

  Totality: total
  Visibility: export
mutexRelease : HasIO io => Mutex -> io ()
  Releases the mutex identified by `mutex`. Unpredictable behavior results if
  the mutex is not owned by the calling thread.

  Totality: total
  Visibility: export
data Condition : Type
  Totality: total
  Visibility: export
makeCondition : HasIO io => io Condition
  Creates and returns a new condition variable.

  Totality: total
  Visibility: export
conditionWait : HasIO io => Condition -> Mutex -> io ()
  Waits up to the specified timeout for the condition identified by the
  condition variable `cond`. The calling thread must have acquired the mutex
  identified by `mutex` at the time `conditionWait` is called. The mutex is
  released as a side effect of the call to `conditionWait`. When a thread is
  later released from the condition variable by one of the procedures
  described below, the mutex is reacquired and `conditionWait` returns.

  Totality: total
  Visibility: export
conditionWaitTimeout : HasIO io => Condition -> Mutex -> Int -> io ()
  Variant of `conditionWait` with a timeout in microseconds.
  When the timeout expires, the thread is released, `mutex` is reacquired, and
  `conditionWaitTimeout` returns.

  Totality: total
  Visibility: export
conditionSignal : HasIO io => Condition -> io ()
  Releases one of the threads waiting for the condition identified by `cond`.

  Totality: total
  Visibility: export
conditionBroadcast : HasIO io => Condition -> io ()
  Releases all of the threads waiting for the condition identified by `cond`.

  Totality: total
  Visibility: export
data Semaphore : Type
  Totality: total
  Visibility: export
makeSemaphore : HasIO io => Int -> io Semaphore
  Creates and returns a new semaphore with the counter initially set to `init`.

  Totality: total
  Visibility: export
semaphorePost : HasIO io => Semaphore -> io ()
  Increments the semaphore's internal counter.

  Totality: total
  Visibility: export
semaphoreWait : HasIO io => Semaphore -> io ()
  Blocks until the internal counter for semaphore sema is non-zero. When the
  counter is non-zero, it is decremented and `semaphoreWait` returns.

  Totality: total
  Visibility: export
data Barrier : Type
  A barrier enables multiple threads to synchronize the beginning of some
  computation.

  Totality: total
  Visibility: export
makeBarrier : HasIO io => Int -> io Barrier
  Creates a new barrier that can block a given number of threads.
  
  @ numThreads the number of threads to block

  Totality: total
  Visibility: export
barrierWait : HasIO io => Barrier -> io ()
  Blocks the current thread until all threads have rendezvoused here.

  Totality: total
  Visibility: export
data Channel : Type -> Type
  Totality: total
  Visibility: export
makeChannel : HasIO io => io (Channel a)
  Creates and returns a new `Channel`.
  
  The channel can be used with `channelGet` to receive a value through the
  channel.
  The channel can be used with `channelPut` to send a value through the
  channel.

  Totality: total
  Visibility: export
channelGet : HasIO io => Channel a -> io a
  Blocks until a sender is ready to provide a value through `chan`. The result
  is the sent value.
  
  @ chan the channel to receive on

  Totality: total
  Visibility: export
channelPut : HasIO io => Channel a -> a -> io ()
  Puts a value on the given channel.
  
  @ chan the `Channel` to send the value over
  @ val  the value to send

  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
setThreadData : HasIO io => a -> io ()
  Set the data stored in a thread's parameter to the given value.
  Currently only supported under the scheme backends.

  Totality: total
  Visibility: export
getThreadData : HasIO io => (a : Type) -> io a
  Get the data stored in a thread's parameter.
  Currently only supported under the scheme backends.

  Totality: total
  Visibility: export
data Mutex : Type
  Totality: total
  Visibility: export
makeMutex : HasIO io => io Mutex
  Creates and returns a new mutex.

  Totality: total
  Visibility: export
mutexAcquire : HasIO io => Mutex -> io ()
  Acquires the mutex identified by `mutex`. The thread blocks until the mutex
  has been acquired.
  
  Mutexes are recursive in Posix threads terminology, which means that the
  calling thread can use mutex-acquire to (re)acquire a mutex it already has.
  In this case, an equal number of mutex-release calls is necessary to release
  the mutex.

  Totality: total
  Visibility: export
mutexRelease : HasIO io => Mutex -> io ()
  Releases the mutex identified by `mutex`. Unpredictable behavior results if
  the mutex is not owned by the calling thread.

  Totality: total
  Visibility: export
data Condition : Type
  Totality: total
  Visibility: export
makeCondition : HasIO io => io Condition
  Creates and returns a new condition variable.

  Totality: total
  Visibility: export
conditionWait : HasIO io => Condition -> Mutex -> io ()
  Waits up to the specified timeout for the condition identified by the
  condition variable `cond`. The calling thread must have acquired the mutex
  identified by `mutex` at the time `conditionWait` is called. The mutex is
  released as a side effect of the call to `conditionWait`. When a thread is
  later released from the condition variable by one of the procedures
  described below, the mutex is reacquired and `conditionWait` returns.

  Totality: total
  Visibility: export
conditionWaitTimeout : HasIO io => Condition -> Mutex -> Int -> io ()
  Variant of `conditionWait` with a timeout in microseconds.
  When the timeout expires, the thread is released, `mutex` is reacquired, and
  `conditionWaitTimeout` returns.

  Totality: total
  Visibility: export
conditionSignal : HasIO io => Condition -> io ()
  Releases one of the threads waiting for the condition identified by `cond`.

  Totality: total
  Visibility: export
conditionBroadcast : HasIO io => Condition -> io ()
  Releases all of the threads waiting for the condition identified by `cond`.

  Totality: total
  Visibility: export
data Semaphore : Type
  Totality: total
  Visibility: export
makeSemaphore : HasIO io => Int -> io Semaphore
  Creates and returns a new semaphore with the counter initially set to `init`.

  Totality: total
  Visibility: export
semaphorePost : HasIO io => Semaphore -> io ()
  Increments the semaphore's internal counter.

  Totality: total
  Visibility: export
semaphoreWait : HasIO io => Semaphore -> io ()
  Blocks until the internal counter for semaphore sema is non-zero. When the
  counter is non-zero, it is decremented and `semaphoreWait` returns.

  Totality: total
  Visibility: export
data Barrier : Type
  A barrier enables multiple threads to synchronize the beginning of some
  computation.

  Totality: total
  Visibility: export
makeBarrier : HasIO io => Int -> io Barrier
  Creates a new barrier that can block a given number of threads.
  
  @ numThreads the number of threads to block

  Totality: total
  Visibility: export
barrierWait : HasIO io => Barrier -> io ()
  Blocks the current thread until all threads have rendezvoused here.

  Totality: total
  Visibility: export
data Channel : Type -> Type
  Totality: total
  Visibility: export
makeChannel : HasIO io => io (Channel a)
  Creates and returns a new `Channel`.
  
  The channel can be used with `channelGet` to receive a value through the
  channel.
  The channel can be used with `channelPut` to send a value through the
  channel.

  Totality: total
  Visibility: export
channelGet : HasIO io => Channel a -> io a
  Blocks until a sender is ready to provide a value through `chan`. The result
  is the sent value.
  
  @ chan the channel to receive on

  Totality: total
  Visibility: export
channelPut : HasIO io => Channel a -> a -> io ()
  Puts a value on the given channel.
  
  @ chan the `Channel` to send the value over
  @ val  the value to send

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.Directory.html b/base/docs/System.Directory.html
index 35350446c1..3ad59b3b81 100644
--- a/base/docs/System.Directory.html
+++ b/base/docs/System.Directory.html
@@ -62,4 +62,4 @@
 
 
 
System.Directory(source)
Directory access and handling.
-
Reexports
import public System.File
Definitions
DirPtr : Type
  Totality: total
  Visibility: public export
data Directory : Type
  Data structure for managing the pointer to a directory.

  Totality: total
  Visibility: export
  Constructor: 
MkDir : DirPtr -> Directory
createDir : HasIO io => String -> io (Either FileError ())
  Try to create a directory at the specified path.

  Totality: total
  Visibility: export
changeDir : HasIO io => String -> io Bool
  Change the current working directory to the specified path. Returns whether
  the operation succeeded.

  Totality: total
  Visibility: export
currentDir : HasIO io => io (Maybe String)
  Get the absolute path of the current working directory. Returns `Nothing` if
  an error occurred.

  Totality: total
  Visibility: export
openDir : HasIO io => String -> io (Either FileError Directory)
  Try to open the directory at the specified path.

  Totality: total
  Visibility: export
closeDir : HasIO io => Directory -> io ()
  Close the given `Directory`.

  Totality: total
  Visibility: export
removeDir : HasIO io => String -> io ()
  Remove the directory at the specified path.
  If the directory is not empty, this operation fails.

  Totality: total
  Visibility: export
nextDirEntry : HasIO io => Directory -> io (Either FileError (Maybe String))
  Get the next entry in the `Directory`, omitting the '.' and '..' entries.

  Totality: total
  Visibility: export
listDir : HasIO io => String -> io (Either FileError (List String))
  Get a list of all the entries in the directory at the specified path,
  excluding the '.' and '..' entries.
  
  @ name the directory to list

  Totality: total
  Visibility: export

\ No newline at end of file
+
Reexports
import public System.File
Definitions
DirPtr : Type
  Totality: total
  Visibility: public export
data Directory : Type
  Data structure for managing the pointer to a directory.

  Totality: total
  Visibility: export
  Constructor: 
MkDir : DirPtr -> Directory
createDir : HasIO io => String -> io (Either FileError ())
  Try to create a directory at the specified path.

  Totality: total
  Visibility: export
changeDir : HasIO io => String -> io Bool
  Change the current working directory to the specified path. Returns whether
  the operation succeeded.

  Totality: total
  Visibility: export
currentDir : HasIO io => io (Maybe String)
  Get the absolute path of the current working directory. Returns `Nothing` if
  an error occurred.

  Totality: total
  Visibility: export
openDir : HasIO io => String -> io (Either FileError Directory)
  Try to open the directory at the specified path.

  Totality: total
  Visibility: export
closeDir : HasIO io => Directory -> io ()
  Close the given `Directory`.

  Totality: total
  Visibility: export
removeDir : HasIO io => String -> io ()
  Remove the directory at the specified path.
  If the directory is not empty, this operation fails.

  Totality: total
  Visibility: export
nextDirEntry : HasIO io => Directory -> io (Either FileError (Maybe String))
  Get the next entry in the `Directory`, omitting the '.' and '..' entries.

  Totality: total
  Visibility: export
listDir : HasIO io => String -> io (Either FileError (List String))
  Get a list of all the entries in the directory at the specified path,
  excluding the '.' and '..' entries.
  
  @ name the directory to list

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.Errno.html b/base/docs/System.Errno.html
index 9fc64f1b2c..39918a6398 100644
--- a/base/docs/System.Errno.html
+++ b/base/docs/System.Errno.html
@@ -62,4 +62,4 @@
 
 
 
System.Errno(source)
Managing error codes.
-
Definitions
getErrno : HasIO io => io Int
  Fetch libc `errno` global variable.

  Totality: total
  Visibility: export
strerror : Int -> String
  Convert numeric `errno` to string.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
getErrno : HasIO io => io Int
  Fetch libc `errno` global variable.

  Totality: total
  Visibility: export
strerror : Int -> String
  Convert numeric `errno` to string.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.Escape.html b/base/docs/System.Escape.html
index 02bc169fcf..ec20eefc9f 100644
--- a/base/docs/System.Escape.html
+++ b/base/docs/System.Escape.html
@@ -61,4 +61,4 @@
 
 
 
-
System.Escape(source)
Definitions
escapeArg : String -> String
  Escape special characters in an Idris string, for use as a string literal
  in the shell

  Visibility: public export
escapeCmd : List String -> String
  Escape special characters in a list of shell arguments, as a single command
  for the shell.
  eg. the list ["a", "b", "c d"] is interpreted as the command `a b "c d"`

  Visibility: public export

\ No newline at end of file
+
System.Escape(source)
Definitions
escapeArg : String -> String
  Escape special characters in an Idris string, for use as a string literal
  in the shell

  Visibility: public export
escapeCmd : List String -> String
  Escape special characters in a list of shell arguments, as a single command
  for the shell.
  eg. the list ["a", "b", "c d"] is interpreted as the command `a b "c d"`

  Visibility: public export

\ No newline at end of file
diff --git a/base/docs/System.FFI.html b/base/docs/System.FFI.html
index 74d9abb73c..193042e731 100644
--- a/base/docs/System.FFI.html
+++ b/base/docs/System.FFI.html
@@ -62,4 +62,4 @@
 
 
 
System.FFI(source)
Additional FFI help for more interesting C types
-
Definitions
data Struct : String -> List (String, Type) -> Type
  A struct with a name and a list of key-value pairs of field names and their
  types.

  Totality: total
  Visibility: export
data FieldType : String -> Type -> List (String, Type) -> Type
  A proof that the field exists as an entry in the list of field names and
  their types.

  Totality: total
  Visibility: public export
  Constructors:
  
First : FieldType n t ((n, t) :: ts)
  
Later : FieldType n t ts -> FieldType n t (f :: ts)
getField : Struct sn fs -> (n : String) -> FieldType n ty fs => ty
  Retrieve the value of the specified field in the given `Struct`.
  
  @ s the `Struct` to retrieve the value from
  @ n the name of the field in the `Struct`.

  Totality: total
  Visibility: public export
setField : Struct sn fs -> (n : String) -> FieldType n ty fs => ty -> IO ()
  Set the value of the specified field in the given `Struct`.
  
  @ s   the `Struct` in which the field exists
  @ n   the name of the field to set
  @ val the value to set the field to

  Totality: total
  Visibility: public export
malloc : HasIO io => Int -> io AnyPtr
  Allocate memory with libc `malloc`.
  
  @ size the number of bytes to allocate

  Totality: total
  Visibility: export
free : HasIO io => AnyPtr -> io ()
  Release memory with libc `free`.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
data Struct : String -> List (String, Type) -> Type
  A struct with a name and a list of key-value pairs of field names and their
  types.

  Totality: total
  Visibility: export
data FieldType : String -> Type -> List (String, Type) -> Type
  A proof that the field exists as an entry in the list of field names and
  their types.

  Totality: total
  Visibility: public export
  Constructors:
  
First : FieldType n t ((n, t) :: ts)
  
Later : FieldType n t ts -> FieldType n t (f :: ts)
getField : Struct sn fs -> (n : String) -> FieldType n ty fs => ty
  Retrieve the value of the specified field in the given `Struct`.
  
  @ s the `Struct` to retrieve the value from
  @ n the name of the field in the `Struct`.

  Totality: total
  Visibility: public export
setField : Struct sn fs -> (n : String) -> FieldType n ty fs => ty -> IO ()
  Set the value of the specified field in the given `Struct`.
  
  @ s   the `Struct` in which the field exists
  @ n   the name of the field to set
  @ val the value to set the field to

  Totality: total
  Visibility: public export
malloc : HasIO io => Int -> io AnyPtr
  Allocate memory with libc `malloc`.
  
  @ size the number of bytes to allocate

  Totality: total
  Visibility: export
free : HasIO io => AnyPtr -> io ()
  Release memory with libc `free`.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.File.Buffer.html b/base/docs/System.File.Buffer.html
index e8c39abbdc..f63126f9b1 100644
--- a/base/docs/System.File.Buffer.html
+++ b/base/docs/System.File.Buffer.html
@@ -61,4 +61,4 @@
 
 
 
-
System.File.Buffer(source)
Reexports
import public System.File.Error
import public System.File.Types
Definitions
readBufferData : HasIO io => File -> Buffer -> Int -> Int -> io (Either FileError Int)
  Read the data from the file into the given buffer.
  
  @ fh       the file handle to read from
  @ buf      the buffer to read the data into
  @ offset   the position in buffer to start adding
  @ maxbytes the maximum size to read; must not exceed buffer length

  Totality: total
  Visibility: export
writeBufferData : HasIO io => File -> Buffer -> Int -> Int -> io (Either (FileError, Int) ())
  Write the data from the buffer to the given `File`. Returns the number
  of bytes that have been written upon a write error. Otherwise, it can
  be assumed that `size` number of bytes have been written.
  (If you do not have a `File` and just want to write to a file at a known
  path, you probably want to use `writeBufferToFile`.)
  
  @ fh       the file handle to write to
  @ buf      the buffer from which to get the data to write
  @ offset   the position in buffer to write from
  @ size     the number of bytes to write; must not exceed buffer length

  Totality: total
  Visibility: export
writeBufferToFile : HasIO io => String -> Buffer -> Int -> io (Either (FileError, Int) ())
  Attempt to write the data from the buffer to the file at the specified file
  name. Returns the number of bytes that have been written upon a write error.
  Otherwise, it can be assumed that `size` number of bytes have been written.
  
  @ fn   the file name to write to
  @ buf  the buffer from which to get the data to write
  @ size the number of bytes to write; must not exceed buffer length

  Totality: total
  Visibility: export
createBufferFromFile : HasIO io => String -> io (Either FileError Buffer)
  Create a new buffer by opening a file and reading its contents into a new
  buffer whose size matches the file size.
  
  @ fn the name of the file to read

  Totality: total
  Visibility: export

\ No newline at end of file
+
System.File.Buffer(source)
Reexports
import public System.File.Error
import public System.File.Types
Definitions
readBufferData : HasIO io => File -> Buffer -> Int -> Int -> io (Either FileError Int)
  Read the data from the file into the given buffer.
  
  @ fh       the file handle to read from
  @ buf      the buffer to read the data into
  @ offset   the position in buffer to start adding
  @ maxbytes the maximum size to read; must not exceed buffer length

  Totality: total
  Visibility: export
writeBufferData : HasIO io => File -> Buffer -> Int -> Int -> io (Either (FileError, Int) ())
  Write the data from the buffer to the given `File`. Returns the number
  of bytes that have been written upon a write error. Otherwise, it can
  be assumed that `size` number of bytes have been written.
  (If you do not have a `File` and just want to write to a file at a known
  path, you probably want to use `writeBufferToFile`.)
  
  @ fh       the file handle to write to
  @ buf      the buffer from which to get the data to write
  @ offset   the position in buffer to write from
  @ size     the number of bytes to write; must not exceed buffer length

  Totality: total
  Visibility: export
writeBufferToFile : HasIO io => String -> Buffer -> Int -> io (Either (FileError, Int) ())
  Attempt to write the data from the buffer to the file at the specified file
  name. Returns the number of bytes that have been written upon a write error.
  Otherwise, it can be assumed that `size` number of bytes have been written.
  
  @ fn   the file name to write to
  @ buf  the buffer from which to get the data to write
  @ size the number of bytes to write; must not exceed buffer length

  Totality: total
  Visibility: export
createBufferFromFile : HasIO io => String -> io (Either FileError Buffer)
  Create a new buffer by opening a file and reading its contents into a new
  buffer whose size matches the file size.
  
  @ fn the name of the file to read

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.File.Error.html b/base/docs/System.File.Error.html
index 1140c5e51c..addf6fd21c 100644
--- a/base/docs/System.File.Error.html
+++ b/base/docs/System.File.Error.html
@@ -61,4 +61,4 @@
 
 
 
-
System.File.Error(source)
Reexports
import public System.File.Types
Definitions
data FileError : Type
  The types of errors that can occur during file operations.

  Totality: total
  Visibility: public export
  Constructors:
  
GenericFileError : Int -> FileError
  A generic error with an errno
  
FileReadError : FileError
  
FileWriteError : FileError
  
FileNotFound : FileError
  
PermissionDenied : FileError
  
FileExists : FileError

  Hint: 
Show FileError
returnError : HasIO io => io (Either FileError a)
  Return the `FileError` corresponding to the errno that was set when the
  function call before this one errored.

  Totality: total
  Visibility: export
fileError : HasIO io => File -> io Bool
  Check if the error indicator for the given file handle is set.

  Totality: total
  Visibility: export

\ No newline at end of file
+
System.File.Error(source)
Reexports
import public System.File.Types
Definitions
data FileError : Type
  The types of errors that can occur during file operations.

  Totality: total
  Visibility: public export
  Constructors:
  
GenericFileError : Int -> FileError
  A generic error with an errno
  
FileReadError : FileError
  
FileWriteError : FileError
  
FileNotFound : FileError
  
PermissionDenied : FileError
  
FileExists : FileError

  Hint: 
Show FileError
returnError : HasIO io => io (Either FileError a)
  Return the `FileError` corresponding to the errno that was set when the
  function call before this one errored.

  Totality: total
  Visibility: export
fileError : HasIO io => File -> io Bool
  Check if the error indicator for the given file handle is set.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.File.Handle.html b/base/docs/System.File.Handle.html
index 1804954f91..bb97699ac0 100644
--- a/base/docs/System.File.Handle.html
+++ b/base/docs/System.File.Handle.html
@@ -61,4 +61,4 @@
 
 
 
-
System.File.Handle(source)
Reexports
import public System.File.Error
import public System.File.Mode
import public System.File.Types
Definitions
openFile : HasIO io => String -> Mode -> io (Either FileError File)
  Open the given file name with the specified mode.
  
  @ f the file name to open
  @ m the mode to open the file with

  Totality: total
  Visibility: export
closeFile : HasIO io => File -> io ()
  Close the given file handle.
  
  @ fh the file handle to close

  Totality: total
  Visibility: export
withFile : HasIO io => String -> Mode -> (FileError -> io a) -> (File -> io (Either a b)) -> io (Either a b)
  Perform a given operation on successful file open
  and ensure the file is closed afterwards or perform
  a different operation if the file fails to open.

  Totality: total
  Visibility: export

\ No newline at end of file
+
System.File.Handle(source)
Reexports
import public System.File.Error
import public System.File.Mode
import public System.File.Types
Definitions
openFile : HasIO io => String -> Mode -> io (Either FileError File)
  Open the given file name with the specified mode.
  
  @ f the file name to open
  @ m the mode to open the file with

  Totality: total
  Visibility: export
closeFile : HasIO io => File -> io ()
  Close the given file handle.
  
  @ fh the file handle to close

  Totality: total
  Visibility: export
withFile : HasIO io => String -> Mode -> (FileError -> io a) -> (File -> io (Either a b)) -> io (Either a b)
  Perform a given operation on successful file open
  and ensure the file is closed afterwards or perform
  a different operation if the file fails to open.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.File.Meta.html b/base/docs/System.File.Meta.html
index 53c90a6200..36574d771e 100644
--- a/base/docs/System.File.Meta.html
+++ b/base/docs/System.File.Meta.html
@@ -62,4 +62,4 @@
 
 
 
System.File.Meta(source)
Functions for accessing file metadata.
-
Reexports
import public System.File.Types
Definitions
exists : HasIO io => String -> io Bool
  Check if a file exists for reading.

  Totality: total
  Visibility: export
firstExists : HasIO io => List String -> io (Maybe String)
  Pick the first existing file

  Totality: total
  Visibility: export
record Timestamp : Type
  Record that holds timestamps with nanosecond precision

  Totality: total
  Visibility: public export
  Constructor: 
MkTimestamp : Int -> Int -> Timestamp

  Projections:
  
.nsec : Timestamp -> Int
  
.sec : Timestamp -> Int

  Hints:
  
Eq Timestamp
  
Ord Timestamp
  
Show Timestamp
.sec : Timestamp -> Int
  Totality: total
  Visibility: public export
sec : Timestamp -> Int
  Totality: total
  Visibility: public export
.nsec : Timestamp -> Int
  Totality: total
  Visibility: public export
nsec : Timestamp -> Int
  Totality: total
  Visibility: public export
record FileTime : Type
  Record that holds file's time attributes

  Totality: total
  Visibility: public export
  Constructor: 
MkFileTime : Timestamp -> Timestamp -> Timestamp -> FileTime

  Projections:
  
.atime : FileTime -> Timestamp
  
.ctime : FileTime -> Timestamp
  
.mtime : FileTime -> Timestamp
.atime : FileTime -> Timestamp
  Totality: total
  Visibility: public export
atime : FileTime -> Timestamp
  Totality: total
  Visibility: public export
.mtime : FileTime -> Timestamp
  Totality: total
  Visibility: public export
mtime : FileTime -> Timestamp
  Totality: total
  Visibility: public export
.ctime : FileTime -> Timestamp
  Totality: total
  Visibility: public export
ctime : FileTime -> Timestamp
  Totality: total
  Visibility: public export
fileTime : HasIO io => File -> io (Either FileError FileTime)
  Get File's time attributes

  Totality: total
  Visibility: export
fileAccessTime : HasIO io => File -> io (Either FileError Int)
  Get the File's atime.

  Totality: total
  Visibility: export
fileModifiedTime : HasIO io => File -> io (Either FileError Int)
  Get the File's mtime.

  Totality: total
  Visibility: export
fileStatusTime : HasIO io => File -> io (Either FileError Int)
  Get the File's ctime.

  Totality: total
  Visibility: export
fileSize : HasIO io => File -> io (Either FileError Int)
  Get the File's size.

  Totality: total
  Visibility: export
fPoll : HasIO io => File -> io Bool
  Check whether the given File's size is non-zero.

  Totality: total
  Visibility: export
isTTY : HasIO io => File -> io Bool
  Check whether the given File is a terminal device.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Reexports
import public System.File.Types
Definitions
exists : HasIO io => String -> io Bool
  Check if a file exists for reading.

  Totality: total
  Visibility: export
firstExists : HasIO io => List String -> io (Maybe String)
  Pick the first existing file

  Totality: total
  Visibility: export
record Timestamp : Type
  Record that holds timestamps with nanosecond precision

  Totality: total
  Visibility: public export
  Constructor: 
MkTimestamp : Int -> Int -> Timestamp

  Projections:
  
.nsec : Timestamp -> Int
  
.sec : Timestamp -> Int

  Hints:
  
Eq Timestamp
  
Ord Timestamp
  
Show Timestamp
.sec : Timestamp -> Int
  Totality: total
  Visibility: public export
sec : Timestamp -> Int
  Totality: total
  Visibility: public export
.nsec : Timestamp -> Int
  Totality: total
  Visibility: public export
nsec : Timestamp -> Int
  Totality: total
  Visibility: public export
record FileTime : Type
  Record that holds file's time attributes

  Totality: total
  Visibility: public export
  Constructor: 
MkFileTime : Timestamp -> Timestamp -> Timestamp -> FileTime

  Projections:
  
.atime : FileTime -> Timestamp
  
.ctime : FileTime -> Timestamp
  
.mtime : FileTime -> Timestamp
.atime : FileTime -> Timestamp
  Totality: total
  Visibility: public export
atime : FileTime -> Timestamp
  Totality: total
  Visibility: public export
.mtime : FileTime -> Timestamp
  Totality: total
  Visibility: public export
mtime : FileTime -> Timestamp
  Totality: total
  Visibility: public export
.ctime : FileTime -> Timestamp
  Totality: total
  Visibility: public export
ctime : FileTime -> Timestamp
  Totality: total
  Visibility: public export
fileTime : HasIO io => File -> io (Either FileError FileTime)
  Get File's time attributes

  Totality: total
  Visibility: export
fileAccessTime : HasIO io => File -> io (Either FileError Int)
  Get the File's atime.

  Totality: total
  Visibility: export
fileModifiedTime : HasIO io => File -> io (Either FileError Int)
  Get the File's mtime.

  Totality: total
  Visibility: export
fileStatusTime : HasIO io => File -> io (Either FileError Int)
  Get the File's ctime.

  Totality: total
  Visibility: export
fileSize : HasIO io => File -> io (Either FileError Int)
  Get the File's size.

  Totality: total
  Visibility: export
fPoll : HasIO io => File -> io Bool
  Check whether the given File's size is non-zero.

  Totality: total
  Visibility: export
isTTY : HasIO io => File -> io Bool
  Check whether the given File is a terminal device.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.File.Mode.html b/base/docs/System.File.Mode.html
index bebb73aa7c..74d64114ee 100644
--- a/base/docs/System.File.Mode.html
+++ b/base/docs/System.File.Mode.html
@@ -61,4 +61,4 @@
 
 
 
-
System.File.Mode(source)
Definitions
data Mode : Type
  The different modes a file can be opened.

  Totality: total
  Visibility: public export
  Constructors:
  
Read : Mode
  
WriteTruncate : Mode
  
Append : Mode
  
ReadWrite : Mode
  
ReadWriteTruncate : Mode
  
ReadAppend : Mode
modeStr : Mode -> String
  Convert a file `Mode` to the OS-appropriate string representation.

  Totality: total
  Visibility: export

\ No newline at end of file
+
System.File.Mode(source)
Definitions
data Mode : Type
  The different modes a file can be opened.

  Totality: total
  Visibility: public export
  Constructors:
  
Read : Mode
  
WriteTruncate : Mode
  
Append : Mode
  
ReadWrite : Mode
  
ReadWriteTruncate : Mode
  
ReadAppend : Mode
modeStr : Mode -> String
  Convert a file `Mode` to the OS-appropriate string representation.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.File.Permissions.html b/base/docs/System.File.Permissions.html
index cfbae1bc0b..7ebc076af4 100644
--- a/base/docs/System.File.Permissions.html
+++ b/base/docs/System.File.Permissions.html
@@ -61,4 +61,4 @@
 
 
 
-
System.File.Permissions(source)
Reexports
import public System.File.Error
import public System.File.Types
Definitions
data FileMode : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Read : FileMode
  
Write : FileMode
  
Execute : FileMode
record Permissions : Type
  The permissions of a file, grouped by the 3 types of owners of a file.

  Totality: total
  Visibility: public export
  Constructor: 
MkPermissions : List FileMode -> List FileMode -> List FileMode -> Permissions

  Projections:
  
.group : Permissions -> List FileMode
  
.others : Permissions -> List FileMode
  
.user : Permissions -> List FileMode
.user : Permissions -> List FileMode
  Totality: total
  Visibility: public export
user : Permissions -> List FileMode
  Totality: total
  Visibility: public export
.group : Permissions -> List FileMode
  Totality: total
  Visibility: public export
group : Permissions -> List FileMode
  Totality: total
  Visibility: public export
.others : Permissions -> List FileMode
  Totality: total
  Visibility: public export
others : Permissions -> List FileMode
  Totality: total
  Visibility: public export
chmodRaw : HasIO io => String -> Int -> io (Either FileError ())
  Change the permissions of the file with the specified name to the given
  integer representation of some permissions.
  You likely want to use `chmod` and `Permissions`, or go via `mkMode`
  instead of using this.
  
  @ fname the name of the file whose permissions to change
  @ p     the integer representation of the permissions to set

  Totality: total
  Visibility: export
chmod : HasIO io => String -> Permissions -> io (Either FileError ())
  Change the permissions of the file with the specified name to the
  permissions in the given `Permissions` record.
  
  @ fname the name of the file whose permissions to change
  @ p     a `Permissions` record containing the permissions to set

  Totality: total
  Visibility: export

\ No newline at end of file
+
System.File.Permissions(source)
Reexports
import public System.File.Error
import public System.File.Types
Definitions
data FileMode : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Read : FileMode
  
Write : FileMode
  
Execute : FileMode
record Permissions : Type
  The permissions of a file, grouped by the 3 types of owners of a file.

  Totality: total
  Visibility: public export
  Constructor: 
MkPermissions : List FileMode -> List FileMode -> List FileMode -> Permissions

  Projections:
  
.group : Permissions -> List FileMode
  
.others : Permissions -> List FileMode
  
.user : Permissions -> List FileMode
.user : Permissions -> List FileMode
  Totality: total
  Visibility: public export
user : Permissions -> List FileMode
  Totality: total
  Visibility: public export
.group : Permissions -> List FileMode
  Totality: total
  Visibility: public export
group : Permissions -> List FileMode
  Totality: total
  Visibility: public export
.others : Permissions -> List FileMode
  Totality: total
  Visibility: public export
others : Permissions -> List FileMode
  Totality: total
  Visibility: public export
chmodRaw : HasIO io => String -> Int -> io (Either FileError ())
  Change the permissions of the file with the specified name to the given
  integer representation of some permissions.
  You likely want to use `chmod` and `Permissions`, or go via `mkMode`
  instead of using this.
  
  @ fname the name of the file whose permissions to change
  @ p     the integer representation of the permissions to set

  Totality: total
  Visibility: export
chmod : HasIO io => String -> Permissions -> io (Either FileError ())
  Change the permissions of the file with the specified name to the
  permissions in the given `Permissions` record.
  
  @ fname the name of the file whose permissions to change
  @ p     a `Permissions` record containing the permissions to set

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.File.Process.html b/base/docs/System.File.Process.html
index 69a1d4d3b6..3903e3e308 100644
--- a/base/docs/System.File.Process.html
+++ b/base/docs/System.File.Process.html
@@ -61,4 +61,4 @@
 
 
 
-
System.File.Process(source)
Reexports
import public System.Escape
import public System.File.Error
import public System.File.Mode
import public System.File.Types
Definitions
fflush : HasIO io => File -> io ()
  Force a write of all user-space buffered data for the given `File`.
  
  @ h the file handle to flush

  Visibility: export
popen : HasIO io => String -> Mode -> io (Either FileError File)
  Create a new unidirectional pipe by invoking the shell, which is passed the
  given command-string using the '-c' flag, in a new process. The pipe is
  opened with the given mode.
  
  IMPORTANT: The NodeJS backend only currently supports the Read mode. Also with
             the NodeJS backend, the opened process will finish execution before
             popen returns (it blocks on open) which is different than other
             backends which will block on close.
  
  @ cmd the command to pass to the shell
  @ m   the mode the pipe should have

  Visibility: export
pclose : HasIO io => File -> io Int
  Wait for the process associated with the pipe to terminate.
  
  @ fh the file handle to the stream to close/wait on

  Visibility: export
record SubProcess : Type
  Result of a popen2 command, containing the

  Totality: total
  Visibility: public export
  Constructor: 
MkSubProcess : Int -> AnyPtr -> File -> File -> SubProcess

  Projections:
  
.handler : SubProcess -> AnyPtr
  The way to manipulate the spawned process, for systems where pid is not enough for this
  
.input : SubProcess -> File
  The input stream of the spawned process
  
.output : SubProcess -> File
  The output stream of the spawned process
  
.pid : SubProcess -> Int
  Process id of the spawned process
.pid : SubProcess -> Int
  Process id of the spawned process

  Visibility: public export
pid : SubProcess -> Int
  Process id of the spawned process

  Visibility: public export
.handler : SubProcess -> AnyPtr
  The way to manipulate the spawned process, for systems where pid is not enough for this

  Visibility: public export
handler : SubProcess -> AnyPtr
  The way to manipulate the spawned process, for systems where pid is not enough for this

  Visibility: public export
.input : SubProcess -> File
  The input stream of the spawned process

  Visibility: public export
input : SubProcess -> File
  The input stream of the spawned process

  Visibility: public export
.output : SubProcess -> File
  The output stream of the spawned process

  Visibility: public export
output : SubProcess -> File
  The output stream of the spawned process

  Visibility: public export
popen2 : HasIO io => String -> io (Either FileError SubProcess)
  Create a new bidirectional pipe by invoking the shell, which is passed the
  given command-string using the '-c' flag, in a new process. On success
  a SubProcess is returned which holds the process id and file handles
  for input and output.
  You should call `popen2Wait` after you've done with the child process
  in order to clean up all system resources.
  
  IMPORTANT: You may deadlock if write to a process which is waiting to flush
             its output.  It is recommended to read and write from separate threads.
  
  This function is not supported on node at this time.

  Visibility: export
popen2Wait : HasIO io => SubProcess -> io Int
  Blocks and waits until the process created by `popen2` finished
  
  This function relates to `popen2` like `pclose` relates to `popen`.
  Returns exit code of the process being waited.
  IMPORTANT: this function mustn't be called twice for the same argument.
  
  Support of this function in the backends must be the same as for `popen2`.

  Visibility: export
popen : HasIO io => List String -> Mode -> io (Either FileError File)
  Visibility: export
popen2 : HasIO io => List String -> io (Either FileError SubProcess)
  Visibility: export

\ No newline at end of file
+
System.File.Process(source)
Reexports
import public System.Escape
import public System.File.Error
import public System.File.Mode
import public System.File.Types
Definitions
fflush : HasIO io => File -> io ()
  Force a write of all user-space buffered data for the given `File`.
  
  @ h the file handle to flush

  Visibility: export
popen : HasIO io => String -> Mode -> io (Either FileError File)
  Create a new unidirectional pipe by invoking the shell, which is passed the
  given command-string using the '-c' flag, in a new process. The pipe is
  opened with the given mode.
  
  IMPORTANT: The NodeJS backend only currently supports the Read mode. Also with
             the NodeJS backend, the opened process will finish execution before
             popen returns (it blocks on open) which is different than other
             backends which will block on close.
  
  @ cmd the command to pass to the shell
  @ m   the mode the pipe should have

  Visibility: export
pclose : HasIO io => File -> io Int
  Wait for the process associated with the pipe to terminate.
  
  @ fh the file handle to the stream to close/wait on

  Visibility: export
record SubProcess : Type
  Result of a popen2 command, containing the

  Totality: total
  Visibility: public export
  Constructor: 
MkSubProcess : Int -> AnyPtr -> File -> File -> SubProcess

  Projections:
  
.handler : SubProcess -> AnyPtr
  The way to manipulate the spawned process, for systems where pid is not enough for this
  
.input : SubProcess -> File
  The input stream of the spawned process
  
.output : SubProcess -> File
  The output stream of the spawned process
  
.pid : SubProcess -> Int
  Process id of the spawned process
.pid : SubProcess -> Int
  Process id of the spawned process

  Visibility: public export
pid : SubProcess -> Int
  Process id of the spawned process

  Visibility: public export
.handler : SubProcess -> AnyPtr
  The way to manipulate the spawned process, for systems where pid is not enough for this

  Visibility: public export
handler : SubProcess -> AnyPtr
  The way to manipulate the spawned process, for systems where pid is not enough for this

  Visibility: public export
.input : SubProcess -> File
  The input stream of the spawned process

  Visibility: public export
input : SubProcess -> File
  The input stream of the spawned process

  Visibility: public export
.output : SubProcess -> File
  The output stream of the spawned process

  Visibility: public export
output : SubProcess -> File
  The output stream of the spawned process

  Visibility: public export
popen2 : HasIO io => String -> io (Either FileError SubProcess)
  Create a new bidirectional pipe by invoking the shell, which is passed the
  given command-string using the '-c' flag, in a new process. On success
  a SubProcess is returned which holds the process id and file handles
  for input and output.
  You should call `popen2Wait` after you've done with the child process
  in order to clean up all system resources.
  
  IMPORTANT: You may deadlock if write to a process which is waiting to flush
             its output.  It is recommended to read and write from separate threads.
  
  This function is not supported on node at this time.

  Visibility: export
popen2Wait : HasIO io => SubProcess -> io Int
  Blocks and waits until the process created by `popen2` finished
  
  This function relates to `popen2` like `pclose` relates to `popen`.
  Returns exit code of the process being waited.
  IMPORTANT: this function mustn't be called twice for the same argument.
  
  Support of this function in the backends must be the same as for `popen2`.

  Visibility: export
popen : HasIO io => List String -> Mode -> io (Either FileError File)
  Visibility: export
popen2 : HasIO io => List String -> io (Either FileError SubProcess)
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.File.ReadWrite.html b/base/docs/System.File.ReadWrite.html
index 74b7f256c7..0f3cee1f47 100644
--- a/base/docs/System.File.ReadWrite.html
+++ b/base/docs/System.File.ReadWrite.html
@@ -61,4 +61,4 @@
 
 
 
-
System.File.ReadWrite(source)
Reexports
import public Data.Fuel
import public System.File.Error
import public System.File.Types
Definitions
fSeekLine : HasIO io => File -> io (Either FileError ())
  Seek through the next newline.
  This is @fGetLine@ without the overhead of copying
  any characters.
  
  @ h the file handle to seek through

  Visibility: export
getStringAndFree : HasIO io => File -> Ptr String -> io (Either FileError String)
  Get a garbage collected String from a Ptr String and and free the original

  Totality: total
  Visibility: export
fGetLine : HasIO io => File -> io (Either FileError String)
  Get the next line from the given file handle, returning the empty string if
  nothing was read.
  
  @ h the file handle to get the line from

  Visibility: export
fGetChars : HasIO io => File -> Int -> io (Either FileError String)
  Get a number of characters from the given file handle.
  
  @ h   the file handle to read from
  @ max the number of characters to read

  Totality: total
  Visibility: export
fGetChar : HasIO io => File -> io (Either FileError Char)
  Get the next character from the given file handle.
  
  @ h the file handle to read from

  Totality: total
  Visibility: export
fPutStr : HasIO io => File -> String -> io (Either FileError ())
  Write the given string to the file handle.
  
  @ h   the file handle to write to
  @ str the string to write

  Totality: total
  Visibility: export
fPutStrLn : HasIO io => File -> String -> io (Either FileError ())
  Write the given string, followed by a newline, to the file handle.
  
  @ fh  the file handle to write to
  @ str the string to write

  Totality: total
  Visibility: export
fEOF : HasIO io => File -> io Bool
  Check whether the end-of-file indicator for the given file handle is set.
  
  @ h the file handle to check

  Totality: total
  Visibility: export
fRead : HasIO io => File -> io (Either FileError String)
  Read all the remaining contents of a file handle

  Visibility: export
removeFile : HasIO io => String -> io (Either FileError ())
  Delete the file at the given name.
  
  @ fname the file to delete

  Totality: total
  Visibility: export
readFilePage : HasIO io => Nat -> Fuel -> String -> io (Either FileError (Bool, List String))
  Read a chunk of a file in a line-delimited fashion.
  You can use this function to read an entire file
  as with @readFile@ by reading until @forever@ or by
  iterating through pages until hitting the end of
  the file.
  
  The @limit@ function can provide you with enough
  fuel to read exactly a given number of lines.
  
  On success, returns a tuple of whether the end of
  the file was reached or not and the lines read in
  from the file.
  
  Note that each line will still have a newline
  character at the end.
  
  Important: because we are chunking by lines, this
  function's totality depends on the assumption that
  no single line in the input file is infinite.
  
  @ offset the offset to start reading at
  @ until  the `Fuel` limiting how far we can read
  @ fname  the name of the file to read

  Totality: total
  Visibility: export
readFile : HasIO io => String -> io (Either FileError String)
  Read the entire file at the given name. This function is `partial` since
  there is no guarantee that the given file isn't infinite.
  
  @ fname the name of the file to read

  Visibility: export
writeFile : HasIO io => String -> String -> io (Either FileError ())
  Write the given string to the file at the specified name. Opens the file
  with the `WriteTruncate` mode.
  (If you have a file handle (a `File`), you may be looking for `fPutStr`.)
  
  @ filePath the file to write to
  @ contents the string to write to the file

  Totality: total
  Visibility: export
appendFile : HasIO io => String -> String -> io (Either FileError ())
  Append the given string to the file at the specified name. Opens the file in
  with the `Append` mode.
  
  @ filePath the file to write to
  @ contents the string to write to the file

  Totality: total
  Visibility: export

\ No newline at end of file
+
System.File.ReadWrite(source)
Reexports
import public Data.Fuel
import public System.File.Error
import public System.File.Types
Definitions
fSeekLine : HasIO io => File -> io (Either FileError ())
  Seek through the next newline.
  This is @fGetLine@ without the overhead of copying
  any characters.
  
  @ h the file handle to seek through

  Visibility: export
getStringAndFree : HasIO io => File -> Ptr String -> io (Either FileError String)
  Get a garbage collected String from a Ptr String and and free the original

  Totality: total
  Visibility: export
fGetLine : HasIO io => File -> io (Either FileError String)
  Get the next line from the given file handle, returning the empty string if
  nothing was read.
  
  @ h the file handle to get the line from

  Visibility: export
fGetChars : HasIO io => File -> Int -> io (Either FileError String)
  Get a number of characters from the given file handle.
  
  @ h   the file handle to read from
  @ max the number of characters to read

  Totality: total
  Visibility: export
fGetChar : HasIO io => File -> io (Either FileError Char)
  Get the next character from the given file handle.
  
  @ h the file handle to read from

  Totality: total
  Visibility: export
fPutStr : HasIO io => File -> String -> io (Either FileError ())
  Write the given string to the file handle.
  
  @ h   the file handle to write to
  @ str the string to write

  Totality: total
  Visibility: export
fPutStrLn : HasIO io => File -> String -> io (Either FileError ())
  Write the given string, followed by a newline, to the file handle.
  
  @ fh  the file handle to write to
  @ str the string to write

  Totality: total
  Visibility: export
fEOF : HasIO io => File -> io Bool
  Check whether the end-of-file indicator for the given file handle is set.
  
  @ h the file handle to check

  Totality: total
  Visibility: export
fRead : HasIO io => File -> io (Either FileError String)
  Read all the remaining contents of a file handle

  Visibility: export
removeFile : HasIO io => String -> io (Either FileError ())
  Delete the file at the given name.
  
  @ fname the file to delete

  Totality: total
  Visibility: export
readFilePage : HasIO io => Nat -> Fuel -> String -> io (Either FileError (Bool, List String))
  Read a chunk of a file in a line-delimited fashion.
  You can use this function to read an entire file
  as with @readFile@ by reading until @forever@ or by
  iterating through pages until hitting the end of
  the file.
  
  The @limit@ function can provide you with enough
  fuel to read exactly a given number of lines.
  
  On success, returns a tuple of whether the end of
  the file was reached or not and the lines read in
  from the file.
  
  Note that each line will still have a newline
  character at the end.
  
  Important: because we are chunking by lines, this
  function's totality depends on the assumption that
  no single line in the input file is infinite.
  
  @ offset the offset to start reading at
  @ until  the `Fuel` limiting how far we can read
  @ fname  the name of the file to read

  Totality: total
  Visibility: export
readFile : HasIO io => String -> io (Either FileError String)
  Read the entire file at the given name. This function is `partial` since
  there is no guarantee that the given file isn't infinite.
  
  @ fname the name of the file to read

  Visibility: export
writeFile : HasIO io => String -> String -> io (Either FileError ())
  Write the given string to the file at the specified name. Opens the file
  with the `WriteTruncate` mode.
  (If you have a file handle (a `File`), you may be looking for `fPutStr`.)
  
  @ filePath the file to write to
  @ contents the string to write to the file

  Totality: total
  Visibility: export
appendFile : HasIO io => String -> String -> io (Either FileError ())
  Append the given string to the file at the specified name. Opens the file in
  with the `Append` mode.
  
  @ filePath the file to write to
  @ contents the string to write to the file

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.File.Support.html b/base/docs/System.File.Support.html
index c35cd597ec..052aa8040f 100644
--- a/base/docs/System.File.Support.html
+++ b/base/docs/System.File.Support.html
@@ -61,4 +61,4 @@
 
 
 
-
System.File.Support(source)
Definitions
supportC : String -> String
  Shorthand for referring to the C support library
  
  @ fn the function name to refer to in the C support library

  Totality: total
  Visibility: public export
supportNode : String -> String
  Shorthand for referring to the Node system support library
  
  @ fn the function name to refer to in the js/system_support_file.js file

  Totality: total
  Visibility: public export
ok : HasIO io => a -> io (Either err a)
  Wrap x in the `Right` part of an `io . Either`.

  Totality: total
  Visibility: export

\ No newline at end of file
+
System.File.Support(source)
Definitions
supportC : String -> String
  Shorthand for referring to the C support library
  
  @ fn the function name to refer to in the C support library

  Totality: total
  Visibility: public export
supportNode : String -> String
  Shorthand for referring to the Node system support library
  
  @ fn the function name to refer to in the js/system_support_file.js file

  Totality: total
  Visibility: public export
ok : HasIO io => a -> io (Either err a)
  Wrap x in the `Right` part of an `io . Either`.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.File.Types.html b/base/docs/System.File.Types.html
index 15a82d7156..c6c1bb2e52 100644
--- a/base/docs/System.File.Types.html
+++ b/base/docs/System.File.Types.html
@@ -61,4 +61,4 @@
 
 
 
-
System.File.Types(source)
Definitions
FilePtr : Type
  A pointer to a file.

  Totality: total
  Visibility: public export
data File : Type
  A file handle.

  Totality: total
  Visibility: public export
  Constructor: 
FHandle : FilePtr -> File

\ No newline at end of file
+
System.File.Types(source)
Definitions
FilePtr : Type
  A pointer to a file.

  Totality: total
  Visibility: public export
data File : Type
  A file handle.

  Totality: total
  Visibility: public export
  Constructor: 
FHandle : FilePtr -> File

\ No newline at end of file
diff --git a/base/docs/System.File.Virtual.html b/base/docs/System.File.Virtual.html
index 42060e4430..3dd1e9ed43 100644
--- a/base/docs/System.File.Virtual.html
+++ b/base/docs/System.File.Virtual.html
@@ -62,4 +62,4 @@
 
 
 
System.File.Virtual(source)
Magic/Virtual files
-
Reexports
import public System.File.Types
Definitions
stdin : File
  The standard input.

  Totality: total
  Visibility: export
stdout : File
  The standard output.

  Totality: total
  Visibility: export
stderr : File
  The standard error.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Reexports
import public System.File.Types
Definitions
stdin : File
  The standard input.

  Totality: total
  Visibility: export
stdout : File
  The standard output.

  Totality: total
  Visibility: export
stderr : File
  The standard error.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.File.html b/base/docs/System.File.html
index 5b9ec5eb33..c336113660 100644
--- a/base/docs/System.File.html
+++ b/base/docs/System.File.html
@@ -61,4 +61,4 @@
 
 
 
-
System.File(source)
Reexports
import public System.File.Buffer
import public System.File.Error
import public System.File.Handle
import public System.File.Meta
import public System.File.Mode
import public System.File.Permissions
import public System.File.Process
import public System.File.ReadWrite
import public System.File.Types
import public System.File.Virtual
Definitions
copyFile : HasIO io => String -> String -> io (Either (FileError, Int) ())
  Copy the file at the specified source to the given destination.
  Returns the number of bytes that have been written upon a write error.
  
  @ src  the file to copy
  @ dest the place to copy the file to

  Visibility: export

\ No newline at end of file
+
System.File(source)
Reexports
import public System.File.Buffer
import public System.File.Error
import public System.File.Handle
import public System.File.Meta
import public System.File.Mode
import public System.File.Permissions
import public System.File.Process
import public System.File.ReadWrite
import public System.File.Types
import public System.File.Virtual
Definitions
copyFile : HasIO io => String -> String -> io (Either (FileError, Int) ())
  Copy the file at the specified source to the given destination.
  Returns the number of bytes that have been written upon a write error.
  
  @ src  the file to copy
  @ dest the place to copy the file to

  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.Info.html b/base/docs/System.Info.html
index 20f59db09b..5cdfa5c3d3 100644
--- a/base/docs/System.Info.html
+++ b/base/docs/System.Info.html
@@ -62,4 +62,4 @@
 
 
 
System.Info(source)
Miscellaneous functions for getting information about the system.
-
Definitions
os : String
  The current operating system.

  Totality: total
  Visibility: export
codegen : String
  The codegen/backend used.

  Totality: total
  Visibility: export
isWindows : Bool
  Whether we are running on MS Windows, either directly or with a compability
  layer (e.g. cygwin).

  Totality: total
  Visibility: export
getNProcessors : IO (Maybe Nat)
  Get the number of processors on the system. Returns `Nothing` if we somehow
  got 0 processors.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
os : String
  The current operating system.

  Totality: total
  Visibility: export
codegen : String
  The codegen/backend used.

  Totality: total
  Visibility: export
isWindows : Bool
  Whether we are running on MS Windows, either directly or with a compability
  layer (e.g. cygwin).

  Totality: total
  Visibility: export
getNProcessors : IO (Maybe Nat)
  Get the number of processors on the system. Returns `Nothing` if we somehow
  got 0 processors.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.REPL.html b/base/docs/System.REPL.html
index f83ff41a68..2d4685b94e 100644
--- a/base/docs/System.REPL.html
+++ b/base/docs/System.REPL.html
@@ -61,4 +61,4 @@
 
 
 
-
System.REPL(source)
Definitions
replWith : HasIO io => a -> String -> (a -> String -> Maybe (String, a)) -> io ()
  A basic read-eval-print loop, maintaining a state
  
  @ state   the input state
  @ prompt  the prompt to show
  @ onInput the function to run on reading input, returning a String to
            output and a new state. Returns Nothing if the repl should exit

  Visibility: export
repl : HasIO io => String -> (String -> String) -> io ()
  A basic read-eval-print loop
  
  @ prompt  the prompt to show
  @ onInput the function to run on reading input, returning a String to
            output

  Visibility: export

\ No newline at end of file
+
System.REPL(source)
Definitions
replWith : HasIO io => a -> String -> (a -> String -> Maybe (String, a)) -> io ()
  A basic read-eval-print loop, maintaining a state
  
  @ state   the input state
  @ prompt  the prompt to show
  @ onInput the function to run on reading input, returning a String to
            output and a new state. Returns Nothing if the repl should exit

  Visibility: export
repl : HasIO io => String -> (String -> String) -> io ()
  A basic read-eval-print loop
  
  @ prompt  the prompt to show
  @ onInput the function to run on reading input, returning a String to
            output

  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.Signal.html b/base/docs/System.Signal.html
index 8578ccff2d..28c66e649b 100644
--- a/base/docs/System.Signal.html
+++ b/base/docs/System.Signal.html
@@ -68,4 +68,4 @@
 operating systems. This module tries to honor both
 by putting things only available in POSIX environments
 into appropriately named namespaces or data types.
-
Definitions
data PosixSignal : Type
  Totality: total
  Visibility: public export
  Constructors:
  
SigHUP : PosixSignal
  Hangup (i.e. controlling terminal closed)
  
SigQUIT : PosixSignal
  Quit
  
SigTRAP : PosixSignal
  Trap (as used by debuggers)
  
SigUser1 : PosixSignal
  
SigUser2 : PosixSignal

  Hint: 
Eq PosixSignal
data Signal : Type
  Totality: total
  Visibility: public export
  Constructors:
  
SigINT : Signal
  Interrupt (e.g. ctrl+c pressed)
  
SigABRT : Signal
  Abnormal termination
  
SigILL : Signal
  Ill-formed instruction
  
SigSEGV : Signal
  Segmentation fault
  
SigFPE : Signal
  Floating-point error
  
SigPosix : PosixSignal -> Signal
  Signals only available on POSIX operating systems

  Hint: 
Eq Signal
data SignalError : Type
  An Error represented by a code. See
  relevant `errno` documentation.
  https://man7.org/linux/man-pages/man3/errno.3.html

  Totality: total
  Visibility: public export
  Constructor: 
Error : Int -> SignalError
ignoreSignal : HasIO io => Signal -> io (Either SignalError ())
  Ignore the given signal.
  Be careful doing this, as most signals have useful
  default behavior -- you might want to set the signal
  to its default behavior instead with `defaultSignal`.

  Totality: total
  Visibility: export
defaultSignal : HasIO io => Signal -> io (Either SignalError ())
  Use the default handler for the given signal.
  You can use this function to unset custom
  handling of a signal.

  Totality: total
  Visibility: export
collectSignal : HasIO io => Signal -> io (Either SignalError ())
  Collect the given signal.
  
  This replaces the existing handling of the given signal
  and instead results in Idris collecting occurrences of
  the signal until you call `handleNextCollectedSignal`.
  
  First, call `collectSignal` for any number of signals.
  Then, call `handleNextCollectedSignal` in each main loop
  of your program to retrieve (and mark as handled) the next
  signal that was collected, if any.
  
  Signals are not queued, so the return order of signals is
  not specified and signals may be deduplicated.

  Totality: total
  Visibility: export
handleNextCollectedSignal : HasIO io => io (Maybe Signal)
  Get next collected signal under the pretense of handling it.
  
  Calling this "marks" the signal as handled so the next time
  this function is called you will retrieve the next unhandled
  signal instead of the same signal again.
  
  You get back Nothing if there are no pending signals.

  Totality: total
  Visibility: export
handleManyCollectedSignals : HasIO io => Fuel -> io (List Signal)
  Get many collected signals and mark them as handled.
  
  Use `forever` as your fuel if you don't want or need to
  retain totality. Alternatively, pick a max number to
  retrieve and use `limit/1` as your fuel.

  Totality: total
  Visibility: export
raiseSignal : HasIO io => Signal -> io (Either SignalError ())
  Send a signal to the current process.

  Totality: total
  Visibility: export
sendSignal : HasIO io => Signal -> Int -> io (Either SignalError ())
  Send a signal to a POSIX process using a PID to identify the process.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
data PosixSignal : Type
  Totality: total
  Visibility: public export
  Constructors:
  
SigHUP : PosixSignal
  Hangup (i.e. controlling terminal closed)
  
SigQUIT : PosixSignal
  Quit
  
SigTRAP : PosixSignal
  Trap (as used by debuggers)
  
SigUser1 : PosixSignal
  
SigUser2 : PosixSignal

  Hint: 
Eq PosixSignal
data Signal : Type
  Totality: total
  Visibility: public export
  Constructors:
  
SigINT : Signal
  Interrupt (e.g. ctrl+c pressed)
  
SigABRT : Signal
  Abnormal termination
  
SigILL : Signal
  Ill-formed instruction
  
SigSEGV : Signal
  Segmentation fault
  
SigFPE : Signal
  Floating-point error
  
SigPosix : PosixSignal -> Signal
  Signals only available on POSIX operating systems

  Hint: 
Eq Signal
data SignalError : Type
  An Error represented by a code. See
  relevant `errno` documentation.
  https://man7.org/linux/man-pages/man3/errno.3.html

  Totality: total
  Visibility: public export
  Constructor: 
Error : Int -> SignalError
ignoreSignal : HasIO io => Signal -> io (Either SignalError ())
  Ignore the given signal.
  Be careful doing this, as most signals have useful
  default behavior -- you might want to set the signal
  to its default behavior instead with `defaultSignal`.

  Totality: total
  Visibility: export
defaultSignal : HasIO io => Signal -> io (Either SignalError ())
  Use the default handler for the given signal.
  You can use this function to unset custom
  handling of a signal.

  Totality: total
  Visibility: export
collectSignal : HasIO io => Signal -> io (Either SignalError ())
  Collect the given signal.
  
  This replaces the existing handling of the given signal
  and instead results in Idris collecting occurrences of
  the signal until you call `handleNextCollectedSignal`.
  
  First, call `collectSignal` for any number of signals.
  Then, call `handleNextCollectedSignal` in each main loop
  of your program to retrieve (and mark as handled) the next
  signal that was collected, if any.
  
  Signals are not queued, so the return order of signals is
  not specified and signals may be deduplicated.

  Totality: total
  Visibility: export
handleNextCollectedSignal : HasIO io => io (Maybe Signal)
  Get next collected signal under the pretense of handling it.
  
  Calling this "marks" the signal as handled so the next time
  this function is called you will retrieve the next unhandled
  signal instead of the same signal again.
  
  You get back Nothing if there are no pending signals.

  Totality: total
  Visibility: export
handleManyCollectedSignals : HasIO io => Fuel -> io (List Signal)
  Get many collected signals and mark them as handled.
  
  Use `forever` as your fuel if you don't want or need to
  retain totality. Alternatively, pick a max number to
  retrieve and use `limit/1` as your fuel.

  Totality: total
  Visibility: export
raiseSignal : HasIO io => Signal -> io (Either SignalError ())
  Send a signal to the current process.

  Totality: total
  Visibility: export
sendSignal : HasIO io => Signal -> Int -> io (Either SignalError ())
  Send a signal to a POSIX process using a PID to identify the process.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.Term.html b/base/docs/System.Term.html
index be542fa714..af95825d88 100644
--- a/base/docs/System.Term.html
+++ b/base/docs/System.Term.html
@@ -61,4 +61,4 @@
 
 
 
-
System.Term(source)
Definitions
setupTerm : IO ()
  Totality: total
  Visibility: export
getTermCols : IO Int
  Totality: total
  Visibility: export
getTermLines : IO Int
  Totality: total
  Visibility: export

\ No newline at end of file
+
System.Term(source)
Definitions
setupTerm : IO ()
  Totality: total
  Visibility: export
getTermCols : IO Int
  Totality: total
  Visibility: export
getTermLines : IO Int
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/docs/System.html b/base/docs/System.html
index 32bc005329..6c14a56f20 100644
--- a/base/docs/System.html
+++ b/base/docs/System.html
@@ -61,4 +61,4 @@
 
 
 
-
System(source)
Reexports
import public Data.So
import public System.Escape
Definitions
sleep : HasIO io => Int -> io ()
  Sleep for the specified number of seconds or, if signals are supported,
  until an un-ignored signal arrives.
  The exact wall-clock time slept might slighly differ depending on how busy
  the system is and the resolution of the system's clock.
  
  @ sec the number of seconds to sleep for

  Totality: total
  Visibility: export
usleep : HasIO io => (usec : Int) -> So (usec >= 0) => io ()
  Sleep for the specified number of microseconds or, if signals are supported,
  until an un-ignored signal arrives.
  The exact wall-clock time slept might slighly differ depending on how busy
  the system is and the resolution of the system's clock.
  
  @ usec the number of microseconds to sleep for

  Totality: total
  Visibility: export
getArgs : HasIO io => io (List String)
  Retrieve the arguments to the program call, if there were any.

  Totality: total
  Visibility: export
enableRawMode : HasIO io => io (Either FileError ())
  `enableRawMode` enables raw mode for stdin, allowing characters
  to be read one at a time, without buffering or echoing.
  If `enableRawMode` is used, the program should call `resetRawMode` before
  exiting. Consider using `withRawMode` instead to ensure the tty is reset.
  
  This is not supported on windows.

  Totality: total
  Visibility: export
resetRawMode : HasIO io => io ()
  `resetRawMode` resets stdin raw mode to original state if
  `enableRawMode` had been previously called.

  Totality: total
  Visibility: export
withRawMode : HasIO io => (FileError -> io a) -> (() -> io a) -> io a
  `withRawMode` performs a given operation after setting stdin to raw mode
  and ensure that stdin is reset to its original state afterwards.
  
  This is not supported on windows.

  Totality: total
  Visibility: export
getEnv : HasIO io => String -> io (Maybe String)
  Retrieve the specified environment variable's value string, or `Nothing` if
  there is no such environment variable.
  
  @ var the name of the environment variable to look up

  Totality: total
  Visibility: export
getEnvironment : HasIO io => io (List (String, String))
  Retrieve all the key-value pairs of the environment variables, and return a
  list containing them.

  Visibility: export
setEnv : HasIO io => String -> String -> Bool -> io Bool
  Add the specified variable with the given value string to the environment,
  optionally overwriting any existing environment variable with the same name.
  Returns True whether the value is set, overwritten, or not overwritten because
  overwrite was False. Returns False if a system error occurred. You can `getErrno`
  to check the error.
  
  @ var       the name of the environment variable to set
  @ val       the value string to set the environment variable to
  @ overwrite whether to overwrite the existing value if an environment
              variable with the specified name already exists

  Totality: total
  Visibility: export
unsetEnv : HasIO io => String -> io Bool
  Delete the specified environment variable. Returns `True` either if the
  value was deleted or if the value was not defined/didn't exist. Returns
  `False` if a system error occurred. You can `getErrno` to check the error.

  Totality: total
  Visibility: export
system : HasIO io => String -> io Int
  Execute a shell command, returning its termination status or -1 if an error
  occurred.

  Totality: total
  Visibility: export
system : HasIO io => List String -> io Int
  Totality: total
  Visibility: export
run : HasIO io => String -> io (String, Int)
  Run a shell command, returning its stdout, and exit code.

  Visibility: export
run : HasIO io => List String -> io (String, Int)
  Visibility: export
runProcessingOutput : HasIO io => (String -> io ()) -> String -> io Int
  Run a shell command, allowing processing its stdout line by line.
  
  Notice that is the line of the command ends with a newline character,
  it will be present in the string passed to the processing function.
  
  This function returns an exit code which value should be consistent with the `run` function.

  Visibility: export
runProcessingOutput : HasIO io => (String -> io ()) -> List String -> io Int
  Visibility: export
time : HasIO io => io Integer
  Return the number of seconds since epoch.

  Totality: total
  Visibility: export
getPID : HasIO io => io Int
  Get the ID of the currently running process.

  Totality: total
  Visibility: export
data ExitCode : Type
  Programs can either terminate successfully, or end in a caught
  failure.

  Totality: total
  Visibility: public export
  Constructors:
  
ExitSuccess : ExitCode
  Terminate successfully.
  
ExitFailure : (errNo : Int) -> So (not (errNo == 0)) => ExitCode
  Program terminated for some prescribed reason.
  
  @errNo A non-zero numerical value indicating failure.
  @prf   Proof that the int value is non-zero.
exitWith : HasIO io => ExitCode -> io a
  Exit the program normally, with the specified status.

  Totality: total
  Visibility: export
exitFailure : HasIO io => io a
  Exit the program with status value 1, indicating failure.
  If you want to specify a custom status value, see `exitWith`.

  Totality: total
  Visibility: export
exitSuccess : HasIO io => io a
  Exit the program after a successful run.

  Totality: total
  Visibility: export
die : HasIO io => String -> io a
  Print the error message and call exitFailure

  Totality: total
  Visibility: export

\ No newline at end of file
+
System(source)
Reexports
import public Data.So
import public System.Escape
Definitions
sleep : HasIO io => Int -> io ()
  Sleep for the specified number of seconds or, if signals are supported,
  until an un-ignored signal arrives.
  The exact wall-clock time slept might slighly differ depending on how busy
  the system is and the resolution of the system's clock.
  
  @ sec the number of seconds to sleep for

  Totality: total
  Visibility: export
usleep : HasIO io => (usec : Int) -> So (usec >= 0) => io ()
  Sleep for the specified number of microseconds or, if signals are supported,
  until an un-ignored signal arrives.
  The exact wall-clock time slept might slighly differ depending on how busy
  the system is and the resolution of the system's clock.
  
  @ usec the number of microseconds to sleep for

  Totality: total
  Visibility: export
getArgs : HasIO io => io (List String)
  Retrieve the arguments to the program call, if there were any.

  Totality: total
  Visibility: export
enableRawMode : HasIO io => io (Either FileError ())
  `enableRawMode` enables raw mode for stdin, allowing characters
  to be read one at a time, without buffering or echoing.
  If `enableRawMode` is used, the program should call `resetRawMode` before
  exiting. Consider using `withRawMode` instead to ensure the tty is reset.
  
  This is not supported on windows.

  Totality: total
  Visibility: export
resetRawMode : HasIO io => io ()
  `resetRawMode` resets stdin raw mode to original state if
  `enableRawMode` had been previously called.

  Totality: total
  Visibility: export
withRawMode : HasIO io => (FileError -> io a) -> (() -> io a) -> io a
  `withRawMode` performs a given operation after setting stdin to raw mode
  and ensure that stdin is reset to its original state afterwards.
  
  This is not supported on windows.

  Totality: total
  Visibility: export
getEnv : HasIO io => String -> io (Maybe String)
  Retrieve the specified environment variable's value string, or `Nothing` if
  there is no such environment variable.
  
  @ var the name of the environment variable to look up

  Totality: total
  Visibility: export
getEnvironment : HasIO io => io (List (String, String))
  Retrieve all the key-value pairs of the environment variables, and return a
  list containing them.

  Visibility: export
setEnv : HasIO io => String -> String -> Bool -> io Bool
  Add the specified variable with the given value string to the environment,
  optionally overwriting any existing environment variable with the same name.
  Returns True whether the value is set, overwritten, or not overwritten because
  overwrite was False. Returns False if a system error occurred. You can `getErrno`
  to check the error.
  
  @ var       the name of the environment variable to set
  @ val       the value string to set the environment variable to
  @ overwrite whether to overwrite the existing value if an environment
              variable with the specified name already exists

  Totality: total
  Visibility: export
unsetEnv : HasIO io => String -> io Bool
  Delete the specified environment variable. Returns `True` either if the
  value was deleted or if the value was not defined/didn't exist. Returns
  `False` if a system error occurred. You can `getErrno` to check the error.

  Totality: total
  Visibility: export
system : HasIO io => String -> io Int
  Execute a shell command, returning its termination status or -1 if an error
  occurred.

  Totality: total
  Visibility: export
system : HasIO io => List String -> io Int
  Totality: total
  Visibility: export
run : HasIO io => String -> io (String, Int)
  Run a shell command, returning its stdout, and exit code.

  Visibility: export
run : HasIO io => List String -> io (String, Int)
  Visibility: export
runProcessingOutput : HasIO io => (String -> io ()) -> String -> io Int
  Run a shell command, allowing processing its stdout line by line.
  
  Notice that is the line of the command ends with a newline character,
  it will be present in the string passed to the processing function.
  
  This function returns an exit code which value should be consistent with the `run` function.

  Visibility: export
runProcessingOutput : HasIO io => (String -> io ()) -> List String -> io Int
  Visibility: export
time : HasIO io => io Integer
  Return the number of seconds since epoch.

  Totality: total
  Visibility: export
getPID : HasIO io => io Int
  Get the ID of the currently running process.

  Totality: total
  Visibility: export
data ExitCode : Type
  Programs can either terminate successfully, or end in a caught
  failure.

  Totality: total
  Visibility: public export
  Constructors:
  
ExitSuccess : ExitCode
  Terminate successfully.
  
ExitFailure : (errNo : Int) -> So (not (errNo == 0)) => ExitCode
  Program terminated for some prescribed reason.
  
  @errNo A non-zero numerical value indicating failure.
  @prf   Proof that the int value is non-zero.
exitWith : HasIO io => ExitCode -> io a
  Exit the program normally, with the specified status.

  Totality: total
  Visibility: export
exitFailure : HasIO io => io a
  Exit the program with status value 1, indicating failure.
  If you want to specify a custom status value, see `exitWith`.

  Totality: total
  Visibility: export
exitSuccess : HasIO io => io a
  Exit the program after a successful run.

  Totality: total
  Visibility: export
die : HasIO io => String -> io a
  Print the error message and call exitFailure

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/base/index.html b/base/index.html
index cb1b546445..d6402bc966 100644
--- a/base/index.html
+++ b/base/index.html
@@ -61,4 +61,4 @@
 
 
 
-
Package base - Namespaces

\ No newline at end of file
+
Package base - Namespaces

\ No newline at end of file
diff --git a/base/source/Language.Reflection.TTImp.html b/base/source/Language.Reflection.TTImp.html
index 4f48f60276..bb368a5459 100644
--- a/base/source/Language.Reflection.TTImp.html
+++ b/base/source/Language.Reflection.TTImp.html
@@ -118,999 +118,1007 @@
 
 
 
-
   0 | module Language.Reflection.TTImp

-
   1 | 

-
   2 | import Data.Maybe

-
   3 | import Data.String

-
   4 | import public Language.Reflection.TT

-
   5 | 

-
   6 | 

-
   7 | %default total

-
   8 | 

-
   9 | -- Unchecked terms and declarations in the intermediate language

-
  10 | mutual

-
  11 |   public export

-
  12 |   data BindMode = PI Count | PATTERN | COVERAGE | NONE

-
  13 |   %name BindMode bm

-
  14 | 

-
  15 |   -- For as patterns matching linear arguments, select which side is

-
  16 |   -- consumed

-
  17 |   public export

-
  18 |   data UseSide = UseLeft | UseRight

-
  19 |   %name UseSide side

-
  20 | 

-
  21 |   public export

-
  22 |   data DotReason = NonLinearVar

-
  23 |                  | VarApplied

-
  24 |                  | NotConstructor

-
  25 |                  | ErasedArg

-
  26 |                  | UserDotted

-
  27 |                  | UnknownDot

-
  28 |                  | UnderAppliedCon

-
  29 |   %name DotReason dr

-
  30 | 

-
  31 |   public export

-
  32 |   data TTImp : Type where

-
  33 |        IVar : FC -> Name -> TTImp

-
  34 |        IPi : FC -> Count -> PiInfo TTImp -> Maybe Name ->

-
  35 |              (argTy : TTImp) -> (retTy : TTImp) -> TTImp

-
  36 |        ILam : FC -> Count -> PiInfo TTImp -> Maybe Name ->

-
  37 |               (argTy : TTImp) -> (lamTy : TTImp) -> TTImp

-
  38 |        ILet : FC -> (lhsFC : FC) -> Count -> Name ->

-
  39 |               (nTy : TTImp) -> (nVal : TTImp) ->

-
  40 |               (scope : TTImp) -> TTImp

-
  41 |        ICase : FC -> List FnOpt -> TTImp -> (ty : TTImp) ->

-
  42 |                List Clause -> TTImp

-
  43 |        ILocal : FC -> List Decl -> TTImp -> TTImp

-
  44 |        IUpdate : FC -> List IFieldUpdate -> TTImp -> TTImp

-
  45 | 

-
  46 |        IApp : FC -> TTImp -> TTImp -> TTImp

-
  47 |        INamedApp : FC -> TTImp -> Name -> TTImp -> TTImp

-
  48 |        IAutoApp : FC -> TTImp -> TTImp -> TTImp

-
  49 |        IWithApp : FC -> TTImp -> TTImp -> TTImp

-
  50 | 

-
  51 |        ISearch : FC -> (depth : Nat) -> TTImp

-
  52 |        IAlternative : FC -> AltType -> List TTImp -> TTImp

-
  53 |        IRewrite : FC -> TTImp -> TTImp -> TTImp

-
  54 | 

-
  55 |        -- Any implicit bindings in the scope should be bound here, using

-
  56 |        -- the given binder

-
  57 |        IBindHere : FC -> BindMode -> TTImp -> TTImp

-
  58 |        -- A name which should be implicitly bound

-
  59 |        IBindVar : FC -> String -> TTImp

-
  60 |        -- An 'as' pattern, valid on the LHS of a clause only

-
  61 |        IAs : FC -> (nameFC : FC) -> UseSide -> Name -> TTImp -> TTImp

-
  62 |        -- A 'dot' pattern, i.e. one which must also have the given value

-
  63 |        -- by unification

-
  64 |        IMustUnify : FC -> DotReason -> TTImp -> TTImp

-
  65 | 

-
  66 |        -- Laziness annotations

-
  67 |        IDelayed : FC -> LazyReason -> TTImp -> TTImp -- the type

-
  68 |        IDelay : FC -> TTImp -> TTImp -- delay constructor

-
  69 |        IForce : FC -> TTImp -> TTImp

-
  70 | 

-
  71 |        -- Quasiquotation

-
  72 |        IQuote : FC -> TTImp -> TTImp

-
  73 |        IQuoteName : FC -> Name -> TTImp

-
  74 |        IQuoteDecl : FC -> List Decl -> TTImp

-
  75 |        IUnquote : FC -> TTImp -> TTImp

-
  76 | 

-
  77 |        IPrimVal : FC -> (c : Constant) -> TTImp

-
  78 |        IType : FC -> TTImp

-
  79 |        IHole : FC -> String -> TTImp

-
  80 | 

-
  81 |        -- An implicit value, solved by unification, but which will also be

-
  82 |        -- bound (either as a pattern variable or a type variable) if unsolved

-
  83 |        -- at the end of elaborator

-
  84 |        Implicit : FC -> (bindIfUnsolved : Bool) -> TTImp

-
  85 |        IWithUnambigNames : FC -> List (FC, Name) -> TTImp -> TTImp

-
  86 |   %name TTImp s, t, u

-
  87 | 

-
  88 |   public export

-
  89 |   data IFieldUpdate : Type where

-
  90 |        ISetField : (path : List String) -> TTImp -> IFieldUpdate

-
  91 |        ISetFieldApp : (path : List String) -> TTImp -> IFieldUpdate

-
  92 | 

-
  93 |   %name IFieldUpdate upd

-
  94 | 

-
  95 |   public export

-
  96 |   data AltType : Type where

-
  97 |        FirstSuccess : AltType

-
  98 |        Unique : AltType

-
  99 |        UniqueDefault : TTImp -> AltType

-
 100 | 

-
 101 |   public export

-
 102 |   data FnOpt : Type where

-
 103 |        Inline : FnOpt

-
 104 |        NoInline : FnOpt

-
 105 |        Deprecate : FnOpt

-
 106 |        TCInline : FnOpt

-
 107 |        -- Flag means the hint is a direct hint, not a function which might

-
 108 |        -- find the result (e.g. chasing parent interface dictionaries)

-
 109 |        Hint : Bool -> FnOpt

-
 110 |        -- Flag means to use as a default if all else fails

-
 111 |        GlobalHint : Bool -> FnOpt

-
 112 |        ExternFn : FnOpt

-
 113 |        -- Defined externally, list calling conventions

-
 114 |        ForeignFn : List TTImp -> FnOpt

-
 115 |        -- Mark for export to a foreign language, list calling conventions

-
 116 |        ForeignExport : List TTImp -> FnOpt

-
 117 |        -- assume safe to cancel arguments in unification

-
 118 |        Invertible : FnOpt

-
 119 |        Totality : TotalReq -> FnOpt

-
 120 |        Macro : FnOpt

-
 121 |        SpecArgs : List Name -> FnOpt

-
 122 | 

-
 123 |   public export

-
 124 |   data ITy : Type where

-
 125 |        MkTy : FC -> (nameFC : FC) -> (n : Name) -> (ty : TTImp) -> ITy

-
 126 | 

-
 127 |   %name ITy sig

-
 128 | 

-
 129 |   public export

-
 130 |   data DataOpt : Type where

-
 131 |        SearchBy : List Name -> DataOpt -- determining arguments

-
 132 |        NoHints : DataOpt -- Don't generate search hints for constructors

-
 133 |        UniqueSearch : DataOpt -- auto implicit search must check result is unique

-
 134 |        External : DataOpt -- implemented externally

-
 135 |        NoNewtype : DataOpt -- don't apply newtype optimisation

-
 136 | 

-
 137 |   %name DataOpt dopt

-
 138 | 

-
 139 |   public export

-
 140 |   data Data : Type where

-
 141 |        MkData : FC -> (n : Name) -> (tycon : Maybe TTImp) ->

-
 142 |                 (opts : List DataOpt) ->

-
 143 |                 (datacons : List ITy) -> Data

-
 144 |        MkLater : FC -> (n : Name) -> (tycon : TTImp) -> Data

-
 145 | 

-
 146 |   %name Data dt

-
 147 | 

-
 148 |   public export

-
 149 |   data IField : Type where

-
 150 |        MkIField : FC -> Count -> PiInfo TTImp -> Name -> TTImp ->

-
 151 |                   IField

-
 152 | 

-
 153 |   %name IField fld

-
 154 | 

-
 155 |   public export

-
 156 |   data Record : Type where

-
 157 |        MkRecord : FC -> (n : Name) ->

-
 158 |                   (params : List (Name, Count, PiInfo TTImp, TTImp)) ->

-
 159 |                   (opts : List DataOpt) ->

-
 160 |                   (conName : Name) ->

-
 161 |                   (fields : List IField) ->

-
 162 |                   Record

-
 163 |   %name Record rec

-
 164 | 

-
 165 |   public export

-
 166 |   data WithFlag = Syntactic

-
 167 | 

-
 168 |   public export

-
 169 |   data Clause : Type where

-
 170 |        PatClause : FC -> (lhs : TTImp) -> (rhs : TTImp) -> Clause

-
 171 |        WithClause : FC -> (lhs : TTImp) ->

-
 172 |                     (rig : Count) -> (wval : TTImp) -> -- with'd expression (& quantity)

-
 173 |                     (prf : Maybe Name) -> -- optional name for the proof

-
 174 |                     (flags : List WithFlag) ->

-
 175 |                     List Clause -> Clause

-
 176 |        ImpossibleClause : FC -> (lhs : TTImp) -> Clause

-
 177 | 

-
 178 |   %name Clause cl

-
 179 | 

-
 180 |   public export

-
 181 |   data WithDefault : (a : Type) -> (def : a) -> Type where

-
 182 |        DefaultedValue : WithDefault a def

-
 183 |        SpecifiedValue : a -> WithDefault a def

-
 184 | 

-
 185 |   export

-
 186 |   specified : a -> WithDefault a def

-
 187 |   specified = SpecifiedValue

-
 188 | 

-
 189 |   export

-
 190 |   defaulted : WithDefault a def

-
 191 |   defaulted = DefaultedValue

-
 192 | 

-
 193 |   export

-
 194 |   collapseDefault : {def : a} -> WithDefault a def -> a

-
 195 |   collapseDefault DefaultedValue     = def

-
 196 |   collapseDefault (SpecifiedValue a) = a

-
 197 | 

-
 198 |   export

-
 199 |   onWithDefault : (defHandler : Lazy b) -> (valHandler : a -> b) ->

-
 200 |                   WithDefault a def -> b

-
 201 |   onWithDefault defHandler _ DefaultedValue     = defHandler

-
 202 |   onWithDefault _ valHandler (SpecifiedValue v) = valHandler v

-
 203 | 

-
 204 |   public export

-
 205 |   data Decl : Type where

-
 206 |        IClaim : FC -> Count -> Visibility -> List FnOpt ->

-
 207 |                 ITy -> Decl

-
 208 |        IData : FC -> WithDefault Visibility Private -> Maybe TotalReq -> Data -> Decl

-
 209 |        IDef : FC -> Name -> (cls : List Clause) -> Decl

-
 210 |        IParameters : FC -> (params : List (Name, Count, PiInfo TTImp, TTImp)) ->

-
 211 |                      (decls : List Decl) -> Decl

-
 212 |        IRecord : FC ->

-
 213 |                  Maybe String -> -- nested namespace

-
 214 |                  WithDefault Visibility Private ->

-
 215 |                  Maybe TotalReq -> Record -> Decl

-
 216 |        INamespace : FC -> Namespace -> (decls : List Decl) -> Decl

-
 217 |        ITransform : FC -> Name -> TTImp -> TTImp -> Decl

-
 218 |        IRunElabDecl : FC -> TTImp -> Decl

-
 219 |        ILog : Maybe (List String, Nat) -> Decl

-
 220 |        IBuiltin : FC -> BuiltinType -> Name -> Decl

-
 221 | 

-
 222 |   %name Decl decl

-
 223 | 

-
 224 | public export

-
 225 | getFC : TTImp -> FC

-
 226 | getFC (IVar fc _)                = fc

-
 227 | getFC (IPi fc _ _ _ _ _)         = fc

-
 228 | getFC (ILam fc _ _ _ _ _)        = fc

-
 229 | getFC (ILet fc _ _ _ _ _ _)      = fc

-
 230 | getFC (ICase fc _ _ _ _)         = fc

-
 231 | getFC (ILocal fc _ _)            = fc

-
 232 | getFC (IUpdate fc _ _)           = fc

-
 233 | getFC (IApp fc _ _)              = fc

-
 234 | getFC (INamedApp fc _ _ _)       = fc

-
 235 | getFC (IAutoApp fc _ _)          = fc

-
 236 | getFC (IWithApp fc _ _)          = fc

-
 237 | getFC (ISearch fc _)             = fc

-
 238 | getFC (IAlternative fc _ _)      = fc

-
 239 | getFC (IRewrite fc _ _)          = fc

-
 240 | getFC (IBindHere fc _ _)         = fc

-
 241 | getFC (IBindVar fc _)            = fc

-
 242 | getFC (IAs fc _ _ _ _)           = fc

-
 243 | getFC (IMustUnify fc _ _)        = fc

-
 244 | getFC (IDelayed fc _ _)          = fc

-
 245 | getFC (IDelay fc _)              = fc

-
 246 | getFC (IForce fc _)              = fc

-
 247 | getFC (IQuote fc _)              = fc

-
 248 | getFC (IQuoteName fc _)          = fc

-
 249 | getFC (IQuoteDecl fc _)          = fc

-
 250 | getFC (IUnquote fc _)            = fc

-
 251 | getFC (IPrimVal fc _)            = fc

-
 252 | getFC (IType fc)                 = fc

-
 253 | getFC (IHole fc _)               = fc

-
 254 | getFC (Implicit fc _)            = fc

-
 255 | getFC (IWithUnambigNames fc _ _) = fc

-
 256 | 

-
 257 | public export

-
 258 | mapTopmostFC : (FC -> FC) -> TTImp -> TTImp

-
 259 | mapTopmostFC fcf $ IVar fc a                = IVar (fcf fc) a

-
 260 | mapTopmostFC fcf $ IPi fc a b c d e         = IPi (fcf fc) a b c d e

-
 261 | mapTopmostFC fcf $ ILam fc a b c d e        = ILam (fcf fc) a b c d e

-
 262 | mapTopmostFC fcf $ ILet fc a b c d e f      = ILet (fcf fc) a b c d e f

-
 263 | mapTopmostFC fcf $ ICase fc opts a b c      = ICase (fcf fc) opts a b c

-
 264 | mapTopmostFC fcf $ ILocal fc a b            = ILocal (fcf fc) a b

-
 265 | mapTopmostFC fcf $ IUpdate fc a b           = IUpdate (fcf fc) a b

-
 266 | mapTopmostFC fcf $ IApp fc a b              = IApp (fcf fc) a b

-
 267 | mapTopmostFC fcf $ INamedApp fc a b c       = INamedApp (fcf fc) a b c

-
 268 | mapTopmostFC fcf $ IAutoApp fc a b          = IAutoApp (fcf fc) a b

-
 269 | mapTopmostFC fcf $ IWithApp fc a b          = IWithApp (fcf fc) a b

-
 270 | mapTopmostFC fcf $ ISearch fc a             = ISearch (fcf fc) a

-
 271 | mapTopmostFC fcf $ IAlternative fc a b      = IAlternative (fcf fc) a b

-
 272 | mapTopmostFC fcf $ IRewrite fc a b          = IRewrite (fcf fc) a b

-
 273 | mapTopmostFC fcf $ IBindHere fc a b         = IBindHere (fcf fc) a b

-
 274 | mapTopmostFC fcf $ IBindVar fc a            = IBindVar (fcf fc) a

-
 275 | mapTopmostFC fcf $ IAs fc a b c d           = IAs (fcf fc) a b c d

-
 276 | mapTopmostFC fcf $ IMustUnify fc a b        = IMustUnify (fcf fc) a b

-
 277 | mapTopmostFC fcf $ IDelayed fc a b          = IDelayed (fcf fc) a b

-
 278 | mapTopmostFC fcf $ IDelay fc a              = IDelay (fcf fc) a

-
 279 | mapTopmostFC fcf $ IForce fc a              = IForce (fcf fc) a

-
 280 | mapTopmostFC fcf $ IQuote fc a              = IQuote (fcf fc) a

-
 281 | mapTopmostFC fcf $ IQuoteName fc a          = IQuoteName (fcf fc) a

-
 282 | mapTopmostFC fcf $ IQuoteDecl fc a          = IQuoteDecl (fcf fc) a

-
 283 | mapTopmostFC fcf $ IUnquote fc a            = IUnquote (fcf fc) a

-
 284 | mapTopmostFC fcf $ IPrimVal fc a            = IPrimVal (fcf fc) a

-
 285 | mapTopmostFC fcf $ IType fc                 = IType (fcf fc)

-
 286 | mapTopmostFC fcf $ IHole fc a               = IHole (fcf fc) a

-
 287 | mapTopmostFC fcf $ Implicit fc a            = Implicit (fcf fc) a

-
 288 | mapTopmostFC fcf $ IWithUnambigNames fc a b = IWithUnambigNames (fcf fc) a b

-
 289 | 

-
 290 | public export

-
 291 | Eq BindMode where

-
 292 |   PI c    == PI c'   = c == c'

-
 293 |   PATTERN == PATTERN = True

-
 294 |   NONE    == NONE    = True

-
 295 |   _ == _ = False

-
 296 | 

-
 297 | public export

-
 298 | Eq UseSide where

-
 299 |   UseLeft  == UseLeft  = True

-
 300 |   UseRight == UseRight = True

-
 301 |   _ == _ = False

-
 302 | 

-
 303 | public export

-
 304 | Eq DotReason where

-
 305 |   NonLinearVar    == NonLinearVar    = True

-
 306 |   VarApplied      == VarApplied      = True

-
 307 |   NotConstructor  == NotConstructor  = True

-
 308 |   ErasedArg       == ErasedArg       = True

-
 309 |   UserDotted      == UserDotted      = True

-
 310 |   UnknownDot      == UnknownDot      = True

-
 311 |   UnderAppliedCon == UnderAppliedCon = True

-
 312 |   _ == _ = False

-
 313 | 

-
 314 | public export

-
 315 | Eq WithFlag where

-
 316 |   Syntactic == Syntactic = True

-
 317 | 

-
 318 | public export

-
 319 | Eq DataOpt where

-
 320 |   SearchBy ns == SearchBy ns' = ns == ns'

-
 321 |   NoHints == NoHints = True

-
 322 |   UniqueSearch == UniqueSearch = True

-
 323 |   External == External = True

-
 324 |   NoNewtype == NoNewtype = True

-
 325 |   _ == _ = False

-
 326 | 

-
 327 | public export

-
 328 | Eq a => Eq (WithDefault a def) where

-
 329 |   DefaultedValue   == DefaultedValue   = True

-
 330 |   DefaultedValue   == SpecifiedValue _ = False

-
 331 |   SpecifiedValue _ == DefaultedValue   = False

-
 332 |   SpecifiedValue x == SpecifiedValue y = x == y

-
 333 | 

-
 334 | public export

-
 335 | Ord a => Ord (WithDefault a def) where

-
 336 |   compare DefaultedValue   DefaultedValue       = EQ

-
 337 |   compare DefaultedValue   (SpecifiedValue _)   = LT

-
 338 |   compare (SpecifiedValue _) DefaultedValue     = GT

-
 339 |   compare (SpecifiedValue x) (SpecifiedValue y) = compare x y

-
 340 | 

-
 341 | public export

-
 342 | {def : a} -> (Show a) => Show (WithDefault a def) where

-
 343 |   show (SpecifiedValue x) = show x

-
 344 |   show DefaultedValue     = show def

-
 345 | 

-
 346 | public export

-
 347 | Eq a => Eq (PiInfo a) where

-
 348 |   ImplicitArg   == ImplicitArg = True

-
 349 |   ExplicitArg   == ExplicitArg = True

-
 350 |   AutoImplicit  == AutoImplicit = True

-
 351 |   DefImplicit t == DefImplicit t' = t == t'

-
 352 |   _ == _ = False

-
 353 | 

-
 354 | parameters {auto eqTTImp : Eq TTImp}

-
 355 |   public export

-
 356 |   Eq Clause where

-
 357 |     PatClause _ lhs rhs == PatClause _ lhs' rhs' =

-
 358 |       lhs == lhs' && rhs == rhs'

-
 359 |     WithClause _ l r w p f cs == WithClause _ l' r' w' p' f' cs' =

-
 360 |       l == l' && r == r' && w == w' && p == p' && f == f' && (assert_total $ cs == cs')

-
 361 |     ImpossibleClause _ l == ImpossibleClause _ l' = l == l'

-
 362 |     _ == _ = False

-
 363 | 

-
 364 |   public export

-
 365 |   Eq IFieldUpdate where

-
 366 |     ISetField p t == ISetField p' t' =

-
 367 |       p == p' && t == t'

-
 368 |     ISetFieldApp p t == ISetFieldApp p' t' =

-
 369 |       p == p' && t == t'

-
 370 |     _ == _ = False

-
 371 | 

-
 372 |   public export

-
 373 |   Eq AltType where

-
 374 |     FirstSuccess    == FirstSuccess     = True

-
 375 |     Unique          == Unique           = True

-
 376 |     UniqueDefault t == UniqueDefault t' = t == t'

-
 377 |     _ == _ = False

-
 378 | 

-
 379 |   public export

-
 380 |   Eq FnOpt where

-
 381 |     Inline == Inline = True

-
 382 |     NoInline == NoInline = True

-
 383 |     Deprecate == Deprecate = True

-
 384 |     TCInline == TCInline = True

-
 385 |     Hint b == Hint b' = b == b'

-
 386 |     GlobalHint b == GlobalHint b' = b == b'

-
 387 |     ExternFn == ExternFn = True

-
 388 |     ForeignFn es == ForeignFn es' = es == es'

-
 389 |     ForeignExport es == ForeignExport es' = es == es'

-
 390 |     Invertible == Invertible = True

-
 391 |     Totality tr == Totality tr' = tr == tr'

-
 392 |     Macro == Macro = True

-
 393 |     SpecArgs ns == SpecArgs ns' = ns == ns'

-
 394 |     _ == _ = False

-
 395 | 

-
 396 |   public export

-
 397 |   Eq ITy where

-
 398 |     MkTy _ _ n ty == MkTy _ _ n' ty' = n == n' && ty == ty'

-
 399 | 

-
 400 |   public export

-
 401 |   Eq Data where

-
 402 |     MkData _ n tc os dc == MkData _ n' tc' os' dc' =

-
 403 |       n == n' && tc == tc' && os == os' && dc == dc'

-
 404 |     MkLater _ n tc == MkLater _ n' tc' =

-
 405 |       n == n' && tc == tc'

-
 406 |     _ == _ = False

-
 407 | 

-
 408 |   public export

-
 409 |   Eq IField where

-
 410 |     MkIField _ c pi n e == MkIField _ c' pi' n' e' =

-
 411 |       c == c' && pi == pi' && n == n' && e == e'

-
 412 | 

-
 413 |   public export

-
 414 |   Eq Record where

-
 415 |     MkRecord _ n ps opts cn fs == MkRecord _ n' ps' opts' cn' fs' =

-
 416 |       n == n' && ps == ps' && opts == opts' && cn == cn' && fs == fs'

-
 417 | 

-
 418 |   public export

-
 419 |   Eq Decl where

-
 420 |     IClaim _ c v fos t == IClaim _ c' v' fos' t' =

-
 421 |       c == c' && v == v' && fos == fos' && t == t'

-
 422 |     IData _ v t d == IData _ v' t' d' =

-
 423 |       v == v' && t == t' && d == d'

-
 424 |     IDef _ n cs == IDef _ n' cs' =

-
 425 |       n == n' && cs == cs'

-
 426 |     IParameters _ ps ds == IParameters _ ps' ds' =

-
 427 |       ps == ps' && (assert_total $ ds == ds')

-
 428 |     IRecord _ ns v tr r == IRecord _ ns' v' tr' r' =

-
 429 |       ns == ns' && v == v' && tr == tr' && r == r'

-
 430 |     INamespace _ ns ds == INamespace _ ns' ds' =

-
 431 |       ns == ns' && (assert_total $ ds == ds')

-
 432 |     ITransform _ n f t == ITransform _ n' f' t' =

-
 433 |       n == n' && f == f' && t == t'

-
 434 |     IRunElabDecl _ e == IRunElabDecl _ e' = e == e'

-
 435 |     ILog p == ILog p' = p == p'

-
 436 |     IBuiltin _ t n == IBuiltin _ t' n' =

-
 437 |       t == t' && n == n'

-
 438 |     _ == _ = False

-
 439 | 

-
 440 | public export

-
 441 | Eq TTImp where

-
 442 |   IVar _ v == IVar _ v' = v == v'

-
 443 |   IPi _ c i n a r == IPi _ c' i' n' a' r' =

-
 444 |     c == c' && (assert_total $ i == i') && n == n' && a == a' && r == r'

-
 445 |   ILam _ c i n a r == ILam _ c' i' n' a' r' =

-
 446 |     c == c' && (assert_total $ i == i') && n == n' && a == a' && r == r'

-
 447 |   ILet _ _ c n ty val s == ILet _ _ c' n' ty' val' s' =

-
 448 |     c == c' && n == n' && ty == ty' && val == val' && s == s'

-
 449 |   ICase _ _ t ty cs == ICase _ _ t' ty' cs'

-
 450 |     = t == t' && ty == ty' && (assert_total $ cs == cs')

-
 451 |   ILocal _ ds e == ILocal _ ds' e' =

-
 452 |     (assert_total $ ds == ds') && e == e'

-
 453 |   IUpdate _ fs t == IUpdate _ fs' t' =

-
 454 |     (assert_total $ fs == fs') && t == t'

-
 455 | 

-
 456 |   IApp _ f x == IApp _ f' x' = f == f' && x == x'

-
 457 |   INamedApp _ f n x == INamedApp _ f' n' x' =

-
 458 |     f == f' && n == n' && x == x'

-
 459 |   IAutoApp _ f x == IAutoApp _ f' x' = f == f' && x == x'

-
 460 |   IWithApp _ f x == IWithApp _ f' x' = f == f' && x == x'

-
 461 | 

-
 462 |   ISearch _ n == ISearch _ n' = n == n'

-
 463 |   IAlternative _ t as == IAlternative _ t' as' =

-
 464 |     (assert_total $ t == t') && (assert_total $ as == as')

-
 465 |   IRewrite _ p q == IRewrite _ p' q' =

-
 466 |     p == p' && q == q'

-
 467 | 

-
 468 |   IBindHere _ m t == IBindHere _ m' t' =

-
 469 |     m == m' && t == t'

-
 470 |   IBindVar _ s == IBindVar _ s' = s == s'

-
 471 |   IAs _ _ u n t == IAs _ _ u' n' t' =

-
 472 |     u == u' && n == n' && t == t'

-
 473 |   IMustUnify _ r t == IMustUnify _ r' t' =

-
 474 |     r == r' && t == t'

-
 475 | 

-
 476 |   IDelayed _ r t == IDelayed _ r' t' = r == r' && t == t'

-
 477 |   IDelay _ t == IDelay _ t' = t == t'

-
 478 |   IForce _ t == IForce _ t' = t == t'

-
 479 | 

-
 480 |   IQuote _ tm == IQuote _ tm' = tm == tm'

-
 481 |   IQuoteName _ n == IQuoteName _ n' = n == n'

-
 482 |   IQuoteDecl _ ds == IQuoteDecl _ ds' = assert_total $ ds == ds'

-
 483 |   IUnquote _ tm == IUnquote _ tm' = tm == tm'

-
 484 | 

-
 485 |   IPrimVal _ c == IPrimVal _ c' = c == c'

-
 486 |   IType _ == IType _ = True

-
 487 |   IHole _ s == IHole _ s' = s == s'

-
 488 | 

-
 489 |   Implicit _ b == Implicit _ b' = b == b'

-
 490 |   IWithUnambigNames _ ns t == IWithUnambigNames _ ns' t' =

-
 491 |     map snd ns == map snd ns' && t == t'

-
 492 | 

-
 493 |   _ == _ = False

-
 494 | 

-
 495 | public export

-
 496 | data Mode = InDecl | InCase

-
 497 | 

-
 498 | mutual

-
 499 | 

-
 500 |   public export

-
 501 |   Show IField where

-
 502 |     show (MkIField fc rig pinfo nm s) =

-
 503 |       showPiInfo {wrapExplicit=False} pinfo (showCount rig "\{show nm} : \{show s}")

-
 504 | 

-
 505 |   public export

-
 506 |   Show Record where

-
 507 |     show (MkRecord fc n params opts conName fields) -- TODO: print opts

-
 508 |       = unwords

-
 509 |       [ "record", show n

-
 510 |       , unwords (map (\ (nm, rig, pinfo, ty) =>

-
 511 |                        showPiInfo pinfo (showCount rig "\{show nm} : \{show ty}"))

-
 512 |                 params)

-
 513 |       , "where"

-
 514 |       , "{"

-
 515 |       , "constructor", show conName, "; "

-
 516 |       , joinBy "; " (map show fields)

-
 517 |       , "}"

-
 518 |       ]

-
 519 | 

-
 520 |   public export

-
 521 |   Show Data where

-
 522 |     show (MkData fc n tycon opts datacons) -- TODO: print opts

-
 523 |       = unwords

-
 524 |       [ "data", show n, ":", show tycon, "where"

-
 525 |       , "{", joinBy "; " (map show datacons), "}"

-
 526 |       ]

-
 527 |     show (MkLater fc n tycon) = unwords [ "data", show n, ":", show tycon ]

-
 528 | 

-
 529 |   public export

-
 530 |   Show ITy where

-
 531 |     show (MkTy fc nameFC n ty) = "\{show n} : \{show ty}"

-
 532 | 

-
 533 |   public export

-
 534 |   Show Decl where

-
 535 |     show (IClaim fc rig vis xs sig)

-
 536 |       = unwords [ show vis

-
 537 |                 , showCount rig (show sig) ]

-
 538 |     show (IData fc vis treq dt)

-
 539 |       = unwords [ show vis

-
 540 |                 , showTotalReq treq (show dt)

-
 541 |                 ]

-
 542 |     show (IDef fc nm xs) = joinBy "; " (map (showClause InDecl) xs)

-
 543 |     show (IParameters fc params decls)

-
 544 |       = unwords

-
 545 |       [ "parameters"

-
 546 |       , unwords (map (\ (nm, rig, pinfo, ty) =>

-
 547 |                        showPiInfo pinfo (showCount rig "\{show nm} : \{show ty}"))

-
 548 |                 params)

-
 549 |       , "{"

-
 550 |       , joinBy "; " (assert_total $ map show decls)

-
 551 |       , "}"

-
 552 |       ]

-
 553 |     show (IRecord fc x vis treq rec)

-
 554 |       = unwords [ show vis, showTotalReq treq (show rec) ]

-
 555 |     show (INamespace fc ns decls)

-
 556 |       = unwords

-
 557 |       [ "namespace", show ns

-
 558 |       , "{", joinBy "; " (assert_total $ map show decls), "}" ]

-
 559 |     show (ITransform fc nm s t) = #"%transform "\{show nm}" \{show s} = \{show t}"#

-
 560 |     show (IRunElabDecl fc s) = "%runElab \{show s}"

-
 561 |     show (ILog loglvl) = case loglvl of

-
 562 |       Nothing => "%logging off"

-
 563 |       Just ([], lvl) => "%logging \{show lvl}"

-
 564 |       Just (topic, lvl) => "%logging \{joinBy "." topic} \{show lvl}"

-
 565 |     show (IBuiltin fc bty nm) = "%builtin \{show bty} \{show nm}"

-
 566 | 

-
 567 |   public export

-
 568 |   Show IFieldUpdate where

-
 569 |     show (ISetField path s) = "\{joinBy "->" path} := \{show s}"

-
 570 |     show (ISetFieldApp path s) = "\{joinBy "->" path} $= \{show s}"

-
 571 | 

-
 572 |   public export

-
 573 |   showClause : Mode -> Clause -> String

-
 574 |   showClause mode (PatClause fc lhs rhs) = "\{show lhs} \{showSep mode} \{show rhs}" where

-
 575 |     showSep : Mode -> String

-
 576 |     showSep InDecl = "="

-
 577 |     showSep InCase = "=>"

-
 578 |   showClause mode (WithClause fc lhs rig wval prf flags cls) -- TODO print flags

-
 579 |       = unwords

-
 580 |       [ show lhs, "with"

-
 581 |       , showCount rig $ maybe id (\ nm => (++ " proof \{show nm}")) prf

-
 582 |                       $ showParens True (show wval)

-
 583 |       , "{", joinBy "; " (assert_total $ map (showClause mode) cls), "}"

-
 584 |       ]

-
 585 |   showClause mode (ImpossibleClause fc lhs) = "\{show lhs} impossible"

-
 586 | 

-
 587 |   collectPis : Count -> PiInfo TTImp -> SnocList Name -> TTImp -> TTImp -> (List Name, TTImp)

-
 588 |   collectPis rig pinfo xs argTy t@(IPi fc rig' pinfo' x argTy' retTy)

-
 589 |     = ifThenElse (rig == rig' && pinfo == pinfo' && argTy == argTy')

-
 590 |          (collectPis rig pinfo (xs :< fromMaybe (UN Underscore) x) argTy retTy)

-
 591 |          (xs <>> [], t)

-
 592 |   collectPis rig pinfo xs argTy t = (xs <>> [], t)

-
 593 | 

-
 594 |   showIApps : TTImp -> List String -> String

-
 595 |   showIApps (IApp _ f t) ts = showIApps f (assert_total (showPrec App t) :: ts)

-
 596 |   showIApps (IVar _ nm) [a,b] =

-
 597 |     if isOp nm then unwords [a, showPrefix False nm, b]

-
 598 |     else unwords [showPrefix True nm, a, b]

-
 599 |   showIApps f ts = unwords (show f :: ts)

-
 600 | 

-
 601 |   public export

-
 602 |   Show TTImp where

-
 603 |     showPrec d (IVar fc nm) = showPrefix True nm

-
 604 |     showPrec d (IPi fc MW ExplicitArg Nothing argTy retTy)

-
 605 |       = showParens (d > Open) $ "\{showPrec Dollar argTy} -> \{show retTy}"

-
 606 |     showPrec d (IPi fc MW AutoImplicit Nothing argTy retTy)

-
 607 |       = showParens (d > Open) $ "\{showPrec Dollar argTy} => \{show retTy}"

-
 608 |     showPrec d (IPi fc rig pinfo x argTy retTy)

-
 609 |       = showParens (d > Open) $

-
 610 |           let (xs, retTy) = collectPis rig pinfo [<fromMaybe (UN Underscore) x] argTy retTy in

-
 611 |           assert_total (showPiInfo pinfo "\{showCount rig $ joinBy ", " (show <$> xs)} : \{show argTy}")

-
 612 |           ++ " -> \{assert_total $ show retTy}"

-
 613 |     showPrec d (ILam fc rig pinfo x argTy lamTy)

-
 614 |       = showParens (d > Open) $

-
 615 |           "\\ \{showCount rig $ show (fromMaybe (UN Underscore) x)} => \{show lamTy}"

-
 616 |     showPrec d (ILet fc lhsFC rig nm nTy nVal scope)

-
 617 |       = showParens (d > Open) $

-
 618 |           "let \{showCount rig (show nm)} : \{show nTy} = \{show nVal} in \{show scope}"

-
 619 |     showPrec d (ICase fc _ s ty xs)

-
 620 |       = showParens (d > Open) $

-
 621 |           unwords $ [ "case", show s ] ++ typeFor ty ++ [ "of", "{"

-
 622 |                     , joinBy "; " (assert_total $ map (showClause InCase) xs)

-
 623 |                     , "}"

-
 624 |                     ]

-
 625 |           where

-
 626 |             typeFor : TTImp -> List String

-
 627 |             typeFor $ Implicit _ False = []

-
 628 |             typeFor ty = [ "{-", ":", show ty, "-}" ]

-
 629 |     showPrec d (ILocal fc decls s)

-
 630 |       = showParens (d > Open) $

-
 631 |           unwords [ "let", joinBy "; " (assert_total $ map show decls)

-
 632 |                   , "in", show s

-
 633 |                   ]

-
 634 |     showPrec d (IUpdate fc upds s)

-
 635 |       = showParens (d > Open) $

-
 636 |           unwords [ "{", joinBy ", " $ assert_total (map show upds), "}"

-
 637 |                   , showPrec App s ]

-
 638 |     showPrec d (IApp fc f t)

-
 639 |       = showParens (d >= App) $ assert_total $ showIApps f [showPrec App t]

-
 640 |     showPrec d (INamedApp fc f nm t)

-
 641 |       = showParens (d >= App) $ "\{show f} {\{show nm} = \{show t}}"

-
 642 |     showPrec d (IAutoApp fc f t)

-
 643 |       = showParens (d >= App) $ "\{show f} @{\{show t}}"

-
 644 |     showPrec d (IWithApp fc f t)

-
 645 |       = showParens (d >= App) $ "\{show f} | \{showPrec App t}"

-
 646 |     showPrec d (ISearch fc depth) = "%search"

-
 647 |     showPrec d (IAlternative fc x xs) = "<\{show (length xs)} alts>"

-
 648 |     showPrec d (IRewrite fc s t)

-
 649 |       = showParens (d > Open) "rewrite \{show s} in \{show t}"

-
 650 |     showPrec d (IBindHere fc bm s) = showPrec d s

-
 651 |     showPrec d (IBindVar fc x) = x

-
 652 |     showPrec d (IAs fc nameFC side nm s)

-
 653 |       = "\{show nm}@\{showPrec App s}"

-
 654 |     showPrec d (IMustUnify fc dr s) = ".(\{show s})"

-
 655 |     showPrec d (IDelayed fc LInf s) = showCon d "Inf" $ assert_total $ showArg s

-
 656 |     showPrec d (IDelayed fc LLazy s) = showCon d "Lazy" $ assert_total $ showArg s

-
 657 |     showPrec d (IDelayed fc LUnknown s) = "({- unknown lazy -} \{showPrec Open s})"

-
 658 |     showPrec d (IDelay fc s) = showCon d "Delay" $ assert_total $ showArg s

-
 659 |     showPrec d (IForce fc s) = showCon d "Force" $ assert_total $ showArg s

-
 660 |     showPrec d (IQuote fc s) = "`(\{show s})"

-
 661 |     showPrec d (IQuoteName fc nm) = "`{\{show nm}}"

-
 662 |     showPrec d (IQuoteDecl fc xs) = "`[\{joinBy "; " (assert_total $ map show xs)}]"

-
 663 |     showPrec d (IUnquote fc s) = "~(\{show s})"

-
 664 |     showPrec d (IPrimVal fc c) = show c

-
 665 |     showPrec d (IType fc) = "Type"

-
 666 |     showPrec d (IHole fc str) = "?" ++ str

-
 667 |     showPrec d (Implicit fc b) = ifThenElse b "_" "?"

-
 668 |     showPrec d (IWithUnambigNames fc ns s) = case ns of

-
 669 |       [] => show s

-
 670 |       [(_,x)] => "with \{show x} \{show s}"

-
 671 |       _   => "with [\{joinBy ", " $ map (show . snd) ns}] \{show s}"

-
 672 | 

-
 673 | public export

-
 674 | data Argument a

-
 675 |   = Arg FC a

-
 676 |   | NamedArg FC Name a

-
 677 |   | AutoArg FC a

-
 678 | 

-
 679 | public export

-
 680 | isExplicit : Argument a -> Maybe (FC, a)

-
 681 | isExplicit (Arg fc a) = pure (fc, a)

-
 682 | isExplicit _ = Nothing

-
 683 | 

-
 684 | public export

-
 685 | fromPiInfo : FC -> PiInfo t -> Maybe Name -> a -> Maybe (Argument a)

-
 686 | fromPiInfo fc ImplicitArg (Just nm) a = pure (NamedArg fc nm a)

-
 687 | fromPiInfo fc ExplicitArg _ a = pure (Arg fc a)

-
 688 | fromPiInfo fc AutoImplicit _ a = pure (AutoArg fc a)

-
 689 | fromPiInfo fc (DefImplicit _) (Just nm) a = pure (NamedArg fc nm a)

-
 690 | fromPiInfo _ _ _ _ = Nothing

-
 691 | 

-
 692 | public export

-
 693 | Functor Argument where

-
 694 |   map f (Arg fc a) = Arg fc (f a)

-
 695 |   map f (NamedArg fc nm a) = NamedArg fc nm (f a)

-
 696 |   map f (AutoArg fc a) = AutoArg fc (f a)

-
 697 | 

-
 698 | public export

-
 699 | iApp : TTImp -> Argument TTImp -> TTImp

-
 700 | iApp f (Arg fc t) = IApp fc f t

-
 701 | iApp f (NamedArg fc nm t) = INamedApp fc f nm t

-
 702 | iApp f (AutoArg fc t) = IAutoApp fc f t

-
 703 | 

-
 704 | public export

-
 705 | unArg : Argument a -> a

-
 706 | unArg (Arg _ x) = x

-
 707 | unArg (NamedArg _ _ x) = x

-
 708 | unArg (AutoArg _ x) = x

-
 709 | 

-
 710 | ||| We often apply multiple arguments, this makes things simpler

-
 711 | public export

-
 712 | apply : TTImp -> List (Argument TTImp) -> TTImp

-
 713 | apply = foldl iApp

-
 714 | 

-
 715 | public export

-
 716 | data IsAppView : (FC, Name) -> SnocList (Argument TTImp) -> TTImp -> Type where

-
 717 |   AVVar : IsAppView (fc, t) [<] (IVar fc t)

-
 718 |   AVApp : IsAppView x ts f -> IsAppView x (ts :< Arg fc t) (IApp fc f t)

-
 719 |   AVNamedApp : IsAppView x ts f -> IsAppView x (ts :< NamedArg fc n t) (INamedApp fc f n t)

-
 720 |   AVAutoApp : IsAppView x ts f -> IsAppView x (ts :< AutoArg fc t) (IAutoApp fc f a)

-
 721 | 

-
 722 | public export

-
 723 | record AppView (t : TTImp) where

-
 724 |   constructor MkAppView

-
 725 |   head : (FC, Name)

-
 726 |   args : SnocList (Argument TTImp)

-
 727 |   0 isAppView : IsAppView head args t

-
 728 | 

-
 729 | public export

-
 730 | appView : (t : TTImp) -> Maybe (AppView t)

-
 731 | appView (IVar fc f) = Just (MkAppView (fc, f) [<] AVVar)

-
 732 | appView (IApp fc f t) = do

-
 733 |   (MkAppView x ts prf) <- appView f

-
 734 |   pure (MkAppView x (ts :< Arg fc t) (AVApp prf))

-
 735 | appView (INamedApp fc f n t) = do

-
 736 |   (MkAppView x ts prf) <- appView f

-
 737 |   pure (MkAppView x (ts :< NamedArg fc n t) (AVNamedApp prf))

-
 738 | appView (IAutoApp fc f t) = do

-
 739 |   (MkAppView x ts prf) <- appView f

-
 740 |   pure (MkAppView x (ts :< AutoArg fc t) (AVAutoApp prf))

-
 741 | appView _ = Nothing

-
 742 | 

-
 743 | parameters (f : TTImp -> TTImp)

-
 744 | 

-
 745 |   public export

-
 746 |   mapTTImp : TTImp -> TTImp

-
 747 | 

-
 748 |   public export

-
 749 |   mapPiInfo : PiInfo TTImp -> PiInfo TTImp

-
 750 |   mapPiInfo ImplicitArg = ImplicitArg

-
 751 |   mapPiInfo ExplicitArg = ExplicitArg

-
 752 |   mapPiInfo AutoImplicit = AutoImplicit

-
 753 |   mapPiInfo (DefImplicit t) = DefImplicit (mapTTImp t)

-
 754 | 

-
 755 |   public export

-
 756 |   mapClause : Clause -> Clause

-
 757 |   mapClause (PatClause fc lhs rhs) = PatClause fc (mapTTImp lhs) (mapTTImp rhs)

-
 758 |   mapClause (WithClause fc lhs rig wval prf flags cls)

-
 759 |     = WithClause fc (mapTTImp lhs) rig (mapTTImp wval) prf flags (assert_total $ map mapClause cls)

-
 760 |   mapClause (ImpossibleClause fc lhs) = ImpossibleClause fc (mapTTImp lhs)

-
 761 | 

-
 762 |   public export

-
 763 |   mapITy : ITy -> ITy

-
 764 |   mapITy (MkTy fc nameFC n ty) = MkTy fc nameFC n (mapTTImp ty)

-
 765 | 

-
 766 |   public export

-
 767 |   mapFnOpt : FnOpt -> FnOpt

-
 768 |   mapFnOpt Inline = Inline

-
 769 |   mapFnOpt NoInline = NoInline

-
 770 |   mapFnOpt Deprecate = Deprecate

-
 771 |   mapFnOpt TCInline = TCInline

-
 772 |   mapFnOpt (Hint b) = Hint b

-
 773 |   mapFnOpt (GlobalHint b) = GlobalHint b

-
 774 |   mapFnOpt ExternFn = ExternFn

-
 775 |   mapFnOpt (ForeignFn ts) = ForeignFn (map mapTTImp ts)

-
 776 |   mapFnOpt (ForeignExport ts) = ForeignExport (map mapTTImp ts)

-
 777 |   mapFnOpt Invertible = Invertible

-
 778 |   mapFnOpt (Totality treq) = Totality treq

-
 779 |   mapFnOpt Macro = Macro

-
 780 |   mapFnOpt (SpecArgs ns) = SpecArgs ns

-
 781 | 

-
 782 |   public export

-
 783 |   mapData : Data -> Data

-
 784 |   mapData (MkData fc n tycon opts datacons)

-
 785 |     = MkData fc n (map mapTTImp tycon) opts (map mapITy datacons)

-
 786 |   mapData (MkLater fc n tycon) = MkLater fc n (mapTTImp tycon)

-
 787 | 

-
 788 |   public export

-
 789 |   mapIField : IField -> IField

-
 790 |   mapIField (MkIField fc rig pinfo n t) = MkIField fc rig (mapPiInfo pinfo) n (mapTTImp t)

-
 791 | 

-
 792 |   public export

-
 793 |   mapRecord : Record -> Record

-
 794 |   mapRecord (MkRecord fc n params opts conName fields)

-
 795 |     = MkRecord fc n (map (map $ map $ bimap mapPiInfo mapTTImp) params) opts conName (map mapIField fields)

-
 796 | 

-
 797 |   public export

-
 798 |   mapDecl : Decl -> Decl

-
 799 |   mapDecl (IClaim fc rig vis opts ty)

-
 800 |     = IClaim fc rig vis (map mapFnOpt opts) (mapITy ty)

-
 801 |   mapDecl (IData fc vis mtreq dat) = IData fc vis mtreq (mapData dat)

-
 802 |   mapDecl (IDef fc n cls) = IDef fc n (map mapClause cls)

-
 803 |   mapDecl (IParameters fc params xs) = IParameters fc params (assert_total $ map mapDecl xs)

-
 804 |   mapDecl (IRecord fc mstr x y rec) = IRecord fc mstr x y (mapRecord rec)

-
 805 |   mapDecl (INamespace fc mi xs) = INamespace fc mi (assert_total $ map mapDecl xs)

-
 806 |   mapDecl (ITransform fc n t u) = ITransform fc n (mapTTImp t) (mapTTImp u)

-
 807 |   mapDecl (IRunElabDecl fc t) = IRunElabDecl fc (mapTTImp t)

-
 808 |   mapDecl (ILog x) = ILog x

-
 809 |   mapDecl (IBuiltin fc x n) = IBuiltin fc x n

-
 810 | 

-
 811 |   public export

-
 812 |   mapIFieldUpdate : IFieldUpdate -> IFieldUpdate

-
 813 |   mapIFieldUpdate (ISetField path t) = ISetField path (mapTTImp t)

-
 814 |   mapIFieldUpdate (ISetFieldApp path t) = ISetFieldApp path (mapTTImp t)

-
 815 | 

-
 816 |   public export

-
 817 |   mapAltType : AltType -> AltType

-
 818 |   mapAltType FirstSuccess = FirstSuccess

-
 819 |   mapAltType Unique = Unique

-
 820 |   mapAltType (UniqueDefault t) = UniqueDefault (mapTTImp t)

-
 821 | 

-
 822 |   mapTTImp t@(IVar _ _) = f t

-
 823 |   mapTTImp (IPi fc rig pinfo x argTy retTy)

-
 824 |     = f $ IPi fc rig (mapPiInfo pinfo) x (mapTTImp argTy) (mapTTImp retTy)

-
 825 |   mapTTImp (ILam fc rig pinfo x argTy lamTy)

-
 826 |     = f $ ILam fc rig (mapPiInfo pinfo) x (mapTTImp argTy) (mapTTImp lamTy)

-
 827 |   mapTTImp (ILet fc lhsFC rig n nTy nVal scope)

-
 828 |     = f $ ILet fc lhsFC rig n (mapTTImp nTy) (mapTTImp nVal) (mapTTImp scope)

-
 829 |   mapTTImp (ICase fc opts t ty cls)

-
 830 |     = f $ ICase fc opts (mapTTImp t) (mapTTImp ty) (assert_total $ map mapClause cls)

-
 831 |   mapTTImp (ILocal fc xs t)

-
 832 |     = f $ ILocal fc (assert_total $ map mapDecl xs) (mapTTImp t)

-
 833 |   mapTTImp (IUpdate fc upds t) = f $ IUpdate fc (assert_total map mapIFieldUpdate upds) (mapTTImp t)

-
 834 |   mapTTImp (IApp fc t u) = f $ IApp fc (mapTTImp t) (mapTTImp u)

-
 835 |   mapTTImp (IAutoApp fc t u) = f $ IAutoApp fc (mapTTImp t) (mapTTImp u)

-
 836 |   mapTTImp (INamedApp fc t n u) = f $ INamedApp fc (mapTTImp t) n (mapTTImp u)

-
 837 |   mapTTImp (IWithApp fc t u) = f $ IWithApp fc (mapTTImp t) (mapTTImp u)

-
 838 |   mapTTImp (ISearch fc depth) = f $ ISearch fc depth

-
 839 |   mapTTImp (IAlternative fc alt ts) = f $ IAlternative fc (mapAltType alt) (assert_total map mapTTImp ts)

-
 840 |   mapTTImp (IRewrite fc t u) = f $ IRewrite fc (mapTTImp t) (mapTTImp u)

-
 841 |   mapTTImp (IBindHere fc bm t) = f $ IBindHere fc bm (mapTTImp t)

-
 842 |   mapTTImp (IBindVar fc str) = f $ IBindVar fc str

-
 843 |   mapTTImp (IAs fc nameFC side n t) = f $ IAs fc nameFC side n (mapTTImp t)

-
 844 |   mapTTImp (IMustUnify fc x t) = f $ IMustUnify fc x (mapTTImp t)

-
 845 |   mapTTImp (IDelayed fc lz t) = f $ IDelayed fc lz (mapTTImp t)

-
 846 |   mapTTImp (IDelay fc t) = f $ IDelay fc (mapTTImp t)

-
 847 |   mapTTImp (IForce fc t) = f $ IForce fc (mapTTImp t)

-
 848 |   mapTTImp (IQuote fc t) = f $ IQuote fc (mapTTImp t)

-
 849 |   mapTTImp (IQuoteName fc n) = f $ IQuoteName fc n

-
 850 |   mapTTImp (IQuoteDecl fc xs) = f $ IQuoteDecl fc (assert_total $ map mapDecl xs)

-
 851 |   mapTTImp (IUnquote fc t) = f $ IUnquote fc (mapTTImp t)

-
 852 |   mapTTImp (IPrimVal fc c) = f $ IPrimVal fc c

-
 853 |   mapTTImp (IType fc) = f $ IType fc

-
 854 |   mapTTImp (IHole fc str) = f $ IHole fc str

-
 855 |   mapTTImp (Implicit fc bindIfUnsolved) = f $ Implicit fc bindIfUnsolved

-
 856 |   mapTTImp (IWithUnambigNames fc xs t) = f $ IWithUnambigNames fc xs (mapTTImp t)

-
 857 | 

-
 858 | parameters {0 m : Type -> Type} {auto apl : Applicative m} (f : m TTImp -> m TTImp)

-
 859 | 

-
 860 |   public export

-
 861 |   mapATTImp : TTImp -> m TTImp

-
 862 | 

-
 863 |   public export

-
 864 |   mapMPiInfo : PiInfo TTImp -> m (PiInfo TTImp)

-
 865 |   mapMPiInfo ImplicitArg = pure ImplicitArg

-
 866 |   mapMPiInfo ExplicitArg = pure ExplicitArg

-
 867 |   mapMPiInfo AutoImplicit = pure AutoImplicit

-
 868 |   mapMPiInfo (DefImplicit t) = DefImplicit <$> mapATTImp t

-
 869 | 

-
 870 |   public export

-
 871 |   mapMClause : Clause -> m Clause

-
 872 |   mapMClause (PatClause fc lhs rhs) = PatClause fc <$> mapATTImp lhs <*> mapATTImp rhs

-
 873 |   mapMClause (WithClause fc lhs rig wval prf flags cls)

-
 874 |     = WithClause fc

-
 875 |     <$> mapATTImp lhs

-
 876 |     <*> pure rig

-
 877 |     <*> mapATTImp wval

-
 878 |     <*> pure prf

-
 879 |     <*> pure flags

-
 880 |     <*> assert_total (traverse mapMClause cls)

-
 881 |   mapMClause (ImpossibleClause fc lhs) = ImpossibleClause fc <$> mapATTImp lhs

-
 882 | 

-
 883 |   public export

-
 884 |   mapMITy : ITy -> m ITy

-
 885 |   mapMITy (MkTy fc nameFC n ty) = MkTy fc nameFC n <$> mapATTImp ty

-
 886 | 

-
 887 |   public export

-
 888 |   mapMFnOpt : FnOpt -> m FnOpt

-
 889 |   mapMFnOpt Inline = pure Inline

-
 890 |   mapMFnOpt NoInline = pure NoInline

-
 891 |   mapMFnOpt Deprecate = pure Deprecate

-
 892 |   mapMFnOpt TCInline = pure TCInline

-
 893 |   mapMFnOpt (Hint b) = pure (Hint b)

-
 894 |   mapMFnOpt (GlobalHint b) = pure (GlobalHint b)

-
 895 |   mapMFnOpt ExternFn = pure ExternFn

-
 896 |   mapMFnOpt (ForeignFn ts) = ForeignFn <$> traverse mapATTImp ts

-
 897 |   mapMFnOpt (ForeignExport ts) = ForeignExport <$> traverse mapATTImp ts

-
 898 |   mapMFnOpt Invertible = pure Invertible

-
 899 |   mapMFnOpt (Totality treq) = pure (Totality treq)

-
 900 |   mapMFnOpt Macro = pure Macro

-
 901 |   mapMFnOpt (SpecArgs ns) = pure (SpecArgs ns)

-
 902 | 

-
 903 |   public export

-
 904 |   mapMData : Data -> m Data

-
 905 |   mapMData (MkData fc n tycon opts datacons)

-
 906 |     = MkData fc n <$> traverse mapATTImp tycon <*> pure opts <*> traverse mapMITy datacons

-
 907 |   mapMData (MkLater fc n tycon) = MkLater fc n <$> mapATTImp tycon

-
 908 | 

-
 909 |   public export

-
 910 |   mapMIField : IField -> m IField

-
 911 |   mapMIField (MkIField fc rig pinfo n t)

-
 912 |    = MkIField fc rig <$> mapMPiInfo pinfo <*> pure n <*> mapATTImp t

-
 913 | 

-
 914 |   public export

-
 915 |   mapMRecord : Record -> m Record

-
 916 |   mapMRecord (MkRecord fc n params opts conName fields)

-
 917 |     = MkRecord fc n

-
 918 |     <$> traverse (bitraverse pure $ bitraverse pure $ bitraverse mapMPiInfo mapATTImp) params

-
 919 |     <*> pure opts

-
 920 |     <*> pure conName

-
 921 |     <*> traverse mapMIField fields

-
 922 | 

-
 923 |   public export

-
 924 |   mapMDecl : Decl -> m Decl

-
 925 |   mapMDecl (IClaim fc rig vis opts ty)

-
 926 |     = IClaim fc rig vis <$> traverse mapMFnOpt opts <*> mapMITy ty

-
 927 |   mapMDecl (IData fc vis mtreq dat) = IData fc vis mtreq <$> mapMData dat

-
 928 |   mapMDecl (IDef fc n cls) = IDef fc n <$> traverse mapMClause cls

-
 929 |   mapMDecl (IParameters fc params xs) = IParameters fc params <$> assert_total (traverse mapMDecl xs)

-
 930 |   mapMDecl (IRecord fc mstr x y rec) = IRecord fc mstr x y <$> mapMRecord rec

-
 931 |   mapMDecl (INamespace fc mi xs) = INamespace fc mi <$> assert_total (traverse mapMDecl xs)

-
 932 |   mapMDecl (ITransform fc n t u) = ITransform fc n <$> mapATTImp t <*> mapATTImp u

-
 933 |   mapMDecl (IRunElabDecl fc t) = IRunElabDecl fc <$> mapATTImp t

-
 934 |   mapMDecl (ILog x) = pure (ILog x)

-
 935 |   mapMDecl (IBuiltin fc x n) = pure (IBuiltin fc x n)

-
 936 | 

-
 937 |   public export

-
 938 |   mapMIFieldUpdate : IFieldUpdate -> m IFieldUpdate

-
 939 |   mapMIFieldUpdate (ISetField path t) = ISetField path <$> mapATTImp t

-
 940 |   mapMIFieldUpdate (ISetFieldApp path t) = ISetFieldApp path <$> mapATTImp t

-
 941 | 

-
 942 |   public export

-
 943 |   mapMAltType : AltType -> m AltType

-
 944 |   mapMAltType FirstSuccess = pure FirstSuccess

-
 945 |   mapMAltType Unique = pure Unique

-
 946 |   mapMAltType (UniqueDefault t) = UniqueDefault <$> mapATTImp t

-
 947 | 

-
 948 |   mapATTImp t@(IVar _ _) = f $ pure t

-
 949 |   mapATTImp (IPi fc rig pinfo x argTy retTy)

-
 950 |     = f $ IPi fc rig <$> mapMPiInfo pinfo <*> pure x <*> mapATTImp argTy <*> mapATTImp retTy

-
 951 |   mapATTImp (ILam fc rig pinfo x argTy lamTy)

-
 952 |     = f $ ILam fc rig <$> mapMPiInfo pinfo <*> pure x <*> mapATTImp argTy <*> mapATTImp lamTy

-
 953 |   mapATTImp (ILet fc lhsFC rig n nTy nVal scope)

-
 954 |     = f $ ILet fc lhsFC rig n <$> mapATTImp nTy <*> mapATTImp nVal <*> mapATTImp scope

-
 955 |   mapATTImp (ICase fc opts t ty cls)

-
 956 |     = f $ ICase fc opts <$> mapATTImp t <*> mapATTImp ty <*> assert_total (traverse mapMClause cls)

-
 957 |   mapATTImp (ILocal fc xs t)

-
 958 |     = f $ ILocal fc <$> assert_total (traverse mapMDecl xs) <*> mapATTImp t

-
 959 |   mapATTImp (IUpdate fc upds t)

-
 960 |     = f $ IUpdate fc <$> assert_total (traverse mapMIFieldUpdate upds) <*> mapATTImp t

-
 961 |   mapATTImp (IApp fc t u)

-
 962 |     = f $ IApp fc <$> mapATTImp t <*> mapATTImp u

-
 963 |   mapATTImp (IAutoApp fc t u)

-
 964 |     = f $ IAutoApp fc <$> mapATTImp t <*> mapATTImp u

-
 965 |   mapATTImp (INamedApp fc t n u)

-
 966 |     = f $ INamedApp fc <$> mapATTImp t <*> pure n <*> mapATTImp u

-
 967 |   mapATTImp (IWithApp fc t u) = f $ IWithApp fc <$> mapATTImp t <*> mapATTImp u

-
 968 |   mapATTImp (ISearch fc depth) = f $ pure $ ISearch fc depth

-
 969 |   mapATTImp (IAlternative fc alt ts)

-
 970 |     = f $ IAlternative fc <$> mapMAltType alt <*> assert_total (traverse mapATTImp ts)

-
 971 |   mapATTImp (IRewrite fc t u) = f $ IRewrite fc <$> mapATTImp t <*> mapATTImp u

-
 972 |   mapATTImp (IBindHere fc bm t) = f $ IBindHere fc bm <$> mapATTImp t

-
 973 |   mapATTImp (IBindVar fc str) = f $ pure $ IBindVar fc str

-
 974 |   mapATTImp (IAs fc nameFC side n t) = f $ IAs fc nameFC side n <$> mapATTImp t

-
 975 |   mapATTImp (IMustUnify fc x t) = f $ IMustUnify fc x <$> mapATTImp t

-
 976 |   mapATTImp (IDelayed fc lz t) = f $ IDelayed fc lz <$> mapATTImp t

-
 977 |   mapATTImp (IDelay fc t) = f $ IDelay fc <$> mapATTImp t

-
 978 |   mapATTImp (IForce fc t) = f $ IForce fc <$> mapATTImp t

-
 979 |   mapATTImp (IQuote fc t) = f $ IQuote fc <$> mapATTImp t

-
 980 |   mapATTImp (IQuoteName fc n) = f $ pure $ IQuoteName fc n

-
 981 |   mapATTImp (IQuoteDecl fc xs) = f $ IQuoteDecl fc <$> assert_total (traverse mapMDecl xs)

-
 982 |   mapATTImp (IUnquote fc t) = f $ IUnquote fc <$> mapATTImp t

-
 983 |   mapATTImp (IPrimVal fc c) = f $ pure $ IPrimVal fc c

-
 984 |   mapATTImp (IType fc) = f $ pure $ IType fc

-
 985 |   mapATTImp (IHole fc str) = f $ pure $ IHole fc str

-
 986 |   mapATTImp (Implicit fc bindIfUnsolved) = f $ pure $ Implicit fc bindIfUnsolved

-
 987 |   mapATTImp (IWithUnambigNames fc xs t) = f $ IWithUnambigNames fc xs <$> mapATTImp t

-
 988 | 

-
 989 | public export

-
 990 | mapMTTImp : Monad m => (TTImp -> m TTImp) -> TTImp -> m TTImp

-
 991 | mapMTTImp = mapATTImp . (=<<)

-
 992 | 

+
    0 | module Language.Reflection.TTImp

+
    1 | 

+
    2 | import Data.Maybe

+
    3 | import Data.String

+
    4 | import public Language.Reflection.TT

+
    5 | 

+
    6 | 

+
    7 | %default total

+
    8 | 

+
    9 | -- Unchecked terms and declarations in the intermediate language

+
   10 | mutual

+
   11 |   public export

+
   12 |   data BindMode = PI Count | PATTERN | COVERAGE | NONE

+
   13 |   %name BindMode bm

+
   14 | 

+
   15 |   -- For as patterns matching linear arguments, select which side is

+
   16 |   -- consumed

+
   17 |   public export

+
   18 |   data UseSide = UseLeft | UseRight

+
   19 |   %name UseSide side

+
   20 | 

+
   21 |   public export

+
   22 |   data DotReason = NonLinearVar

+
   23 |                  | VarApplied

+
   24 |                  | NotConstructor

+
   25 |                  | ErasedArg

+
   26 |                  | UserDotted

+
   27 |                  | UnknownDot

+
   28 |                  | UnderAppliedCon

+
   29 |   %name DotReason dr

+
   30 | 

+
   31 |   public export

+
   32 |   data TTImp : Type where

+
   33 |        IVar : FC -> Name -> TTImp

+
   34 |        IPi : FC -> Count -> PiInfo TTImp -> Maybe Name ->

+
   35 |              (argTy : TTImp) -> (retTy : TTImp) -> TTImp

+
   36 |        ILam : FC -> Count -> PiInfo TTImp -> Maybe Name ->

+
   37 |               (argTy : TTImp) -> (lamTy : TTImp) -> TTImp

+
   38 |        ILet : FC -> (lhsFC : FC) -> Count -> Name ->

+
   39 |               (nTy : TTImp) -> (nVal : TTImp) ->

+
   40 |               (scope : TTImp) -> TTImp

+
   41 |        ICase : FC -> List FnOpt -> TTImp -> (ty : TTImp) ->

+
   42 |                List Clause -> TTImp

+
   43 |        ILocal : FC -> List Decl -> TTImp -> TTImp

+
   44 |        IUpdate : FC -> List IFieldUpdate -> TTImp -> TTImp

+
   45 | 

+
   46 |        IApp : FC -> TTImp -> TTImp -> TTImp

+
   47 |        INamedApp : FC -> TTImp -> Name -> TTImp -> TTImp

+
   48 |        IAutoApp : FC -> TTImp -> TTImp -> TTImp

+
   49 |        IWithApp : FC -> TTImp -> TTImp -> TTImp

+
   50 | 

+
   51 |        ISearch : FC -> (depth : Nat) -> TTImp

+
   52 |        IAlternative : FC -> AltType -> List TTImp -> TTImp

+
   53 |        IRewrite : FC -> TTImp -> TTImp -> TTImp

+
   54 | 

+
   55 |        -- Any implicit bindings in the scope should be bound here, using

+
   56 |        -- the given binder

+
   57 |        IBindHere : FC -> BindMode -> TTImp -> TTImp

+
   58 |        -- A name which should be implicitly bound

+
   59 |        IBindVar : FC -> String -> TTImp

+
   60 |        -- An 'as' pattern, valid on the LHS of a clause only

+
   61 |        IAs : FC -> (nameFC : FC) -> UseSide -> Name -> TTImp -> TTImp

+
   62 |        -- A 'dot' pattern, i.e. one which must also have the given value

+
   63 |        -- by unification

+
   64 |        IMustUnify : FC -> DotReason -> TTImp -> TTImp

+
   65 | 

+
   66 |        -- Laziness annotations

+
   67 |        IDelayed : FC -> LazyReason -> TTImp -> TTImp -- the type

+
   68 |        IDelay : FC -> TTImp -> TTImp -- delay constructor

+
   69 |        IForce : FC -> TTImp -> TTImp

+
   70 | 

+
   71 |        -- Quasiquotation

+
   72 |        IQuote : FC -> TTImp -> TTImp

+
   73 |        IQuoteName : FC -> Name -> TTImp

+
   74 |        IQuoteDecl : FC -> List Decl -> TTImp

+
   75 |        IUnquote : FC -> TTImp -> TTImp

+
   76 | 

+
   77 |        IPrimVal : FC -> (c : Constant) -> TTImp

+
   78 |        IType : FC -> TTImp

+
   79 |        IHole : FC -> String -> TTImp

+
   80 | 

+
   81 |        -- An implicit value, solved by unification, but which will also be

+
   82 |        -- bound (either as a pattern variable or a type variable) if unsolved

+
   83 |        -- at the end of elaborator

+
   84 |        Implicit : FC -> (bindIfUnsolved : Bool) -> TTImp

+
   85 |        IWithUnambigNames : FC -> List (FC, Name) -> TTImp -> TTImp

+
   86 |   %name TTImp s, t, u

+
   87 | 

+
   88 |   public export

+
   89 |   data IFieldUpdate : Type where

+
   90 |        ISetField : (path : List String) -> TTImp -> IFieldUpdate

+
   91 |        ISetFieldApp : (path : List String) -> TTImp -> IFieldUpdate

+
   92 | 

+
   93 |   %name IFieldUpdate upd

+
   94 | 

+
   95 |   public export

+
   96 |   data AltType : Type where

+
   97 |        FirstSuccess : AltType

+
   98 |        Unique : AltType

+
   99 |        UniqueDefault : TTImp -> AltType

+
  100 | 

+
  101 |   public export

+
  102 |   data FnOpt : Type where

+
  103 |        Inline : FnOpt

+
  104 |        NoInline : FnOpt

+
  105 |        Deprecate : FnOpt

+
  106 |        TCInline : FnOpt

+
  107 |        -- Flag means the hint is a direct hint, not a function which might

+
  108 |        -- find the result (e.g. chasing parent interface dictionaries)

+
  109 |        Hint : Bool -> FnOpt

+
  110 |        -- Flag means to use as a default if all else fails

+
  111 |        GlobalHint : Bool -> FnOpt

+
  112 |        ExternFn : FnOpt

+
  113 |        -- Defined externally, list calling conventions

+
  114 |        ForeignFn : List TTImp -> FnOpt

+
  115 |        -- Mark for export to a foreign language, list calling conventions

+
  116 |        ForeignExport : List TTImp -> FnOpt

+
  117 |        -- assume safe to cancel arguments in unification

+
  118 |        Invertible : FnOpt

+
  119 |        Totality : TotalReq -> FnOpt

+
  120 |        Macro : FnOpt

+
  121 |        SpecArgs : List Name -> FnOpt

+
  122 | 

+
  123 |   public export

+
  124 |   data ITy : Type where

+
  125 |        MkTy : FC -> (nameFC : FC) -> (n : Name) -> (ty : TTImp) -> ITy

+
  126 | 

+
  127 |   %name ITy sig

+
  128 | 

+
  129 |   public export

+
  130 |   data DataOpt : Type where

+
  131 |        SearchBy : List Name -> DataOpt -- determining arguments

+
  132 |        NoHints : DataOpt -- Don't generate search hints for constructors

+
  133 |        UniqueSearch : DataOpt -- auto implicit search must check result is unique

+
  134 |        External : DataOpt -- implemented externally

+
  135 |        NoNewtype : DataOpt -- don't apply newtype optimisation

+
  136 | 

+
  137 |   %name DataOpt dopt

+
  138 | 

+
  139 |   public export

+
  140 |   data Data : Type where

+
  141 |        MkData : FC -> (n : Name) -> (tycon : Maybe TTImp) ->

+
  142 |                 (opts : List DataOpt) ->

+
  143 |                 (datacons : List ITy) -> Data

+
  144 |        MkLater : FC -> (n : Name) -> (tycon : TTImp) -> Data

+
  145 | 

+
  146 |   %name Data dt

+
  147 | 

+
  148 |   public export

+
  149 |   data IField : Type where

+
  150 |        MkIField : FC -> Count -> PiInfo TTImp -> Name -> TTImp ->

+
  151 |                   IField

+
  152 | 

+
  153 |   %name IField fld

+
  154 | 

+
  155 |   public export

+
  156 |   data Record : Type where

+
  157 |        MkRecord : FC -> (n : Name) ->

+
  158 |                   (params : List (Name, Count, PiInfo TTImp, TTImp)) ->

+
  159 |                   (opts : List DataOpt) ->

+
  160 |                   (conName : Name) ->

+
  161 |                   (fields : List IField) ->

+
  162 |                   Record

+
  163 |   %name Record rec

+
  164 | 

+
  165 |   public export

+
  166 |   data WithFlag = Syntactic

+
  167 | 

+
  168 |   public export

+
  169 |   data Clause : Type where

+
  170 |        PatClause : FC -> (lhs : TTImp) -> (rhs : TTImp) -> Clause

+
  171 |        WithClause : FC -> (lhs : TTImp) ->

+
  172 |                     (rig : Count) -> (wval : TTImp) -> -- with'd expression (& quantity)

+
  173 |                     (prf : Maybe Name) -> -- optional name for the proof

+
  174 |                     (flags : List WithFlag) ->

+
  175 |                     List Clause -> Clause

+
  176 |        ImpossibleClause : FC -> (lhs : TTImp) -> Clause

+
  177 | 

+
  178 |   %name Clause cl

+
  179 | 

+
  180 |   public export

+
  181 |   data WithDefault : (a : Type) -> (def : a) -> Type where

+
  182 |        DefaultedValue : WithDefault a def

+
  183 |        SpecifiedValue : a -> WithDefault a def

+
  184 | 

+
  185 |   export

+
  186 |   specified : a -> WithDefault a def

+
  187 |   specified = SpecifiedValue

+
  188 | 

+
  189 |   export

+
  190 |   defaulted : WithDefault a def

+
  191 |   defaulted = DefaultedValue

+
  192 | 

+
  193 |   export

+
  194 |   collapseDefault : {def : a} -> WithDefault a def -> a

+
  195 |   collapseDefault DefaultedValue     = def

+
  196 |   collapseDefault (SpecifiedValue a) = a

+
  197 | 

+
  198 |   export

+
  199 |   onWithDefault : (defHandler : Lazy b) -> (valHandler : a -> b) ->

+
  200 |                   WithDefault a def -> b

+
  201 |   onWithDefault defHandler _ DefaultedValue     = defHandler

+
  202 |   onWithDefault _ valHandler (SpecifiedValue v) = valHandler v

+
  203 | 

+
  204 |   public export

+
  205 |   data Decl : Type where

+
  206 |        IClaim : FC -> Count -> Visibility -> List FnOpt ->

+
  207 |                 ITy -> Decl

+
  208 |        IData : FC -> WithDefault Visibility Private -> Maybe TotalReq -> Data -> Decl

+
  209 |        IDef : FC -> Name -> (cls : List Clause) -> Decl

+
  210 |        IParameters : FC -> (params : List (Name, Count, PiInfo TTImp, TTImp)) ->

+
  211 |                      (decls : List Decl) -> Decl

+
  212 |        IRecord : FC ->

+
  213 |                  Maybe String -> -- nested namespace

+
  214 |                  WithDefault Visibility Private ->

+
  215 |                  Maybe TotalReq -> Record -> Decl

+
  216 |        INamespace : FC -> Namespace -> (decls : List Decl) -> Decl

+
  217 |        ITransform : FC -> Name -> TTImp -> TTImp -> Decl

+
  218 |        IRunElabDecl : FC -> TTImp -> Decl

+
  219 |        ILog : Maybe (List String, Nat) -> Decl

+
  220 |        IBuiltin : FC -> BuiltinType -> Name -> Decl

+
  221 | 

+
  222 |   %name Decl decl

+
  223 | 

+
  224 | public export

+
  225 | getFC : TTImp -> FC

+
  226 | getFC (IVar fc _)                = fc

+
  227 | getFC (IPi fc _ _ _ _ _)         = fc

+
  228 | getFC (ILam fc _ _ _ _ _)        = fc

+
  229 | getFC (ILet fc _ _ _ _ _ _)      = fc

+
  230 | getFC (ICase fc _ _ _ _)         = fc

+
  231 | getFC (ILocal fc _ _)            = fc

+
  232 | getFC (IUpdate fc _ _)           = fc

+
  233 | getFC (IApp fc _ _)              = fc

+
  234 | getFC (INamedApp fc _ _ _)       = fc

+
  235 | getFC (IAutoApp fc _ _)          = fc

+
  236 | getFC (IWithApp fc _ _)          = fc

+
  237 | getFC (ISearch fc _)             = fc

+
  238 | getFC (IAlternative fc _ _)      = fc

+
  239 | getFC (IRewrite fc _ _)          = fc

+
  240 | getFC (IBindHere fc _ _)         = fc

+
  241 | getFC (IBindVar fc _)            = fc

+
  242 | getFC (IAs fc _ _ _ _)           = fc

+
  243 | getFC (IMustUnify fc _ _)        = fc

+
  244 | getFC (IDelayed fc _ _)          = fc

+
  245 | getFC (IDelay fc _)              = fc

+
  246 | getFC (IForce fc _)              = fc

+
  247 | getFC (IQuote fc _)              = fc

+
  248 | getFC (IQuoteName fc _)          = fc

+
  249 | getFC (IQuoteDecl fc _)          = fc

+
  250 | getFC (IUnquote fc _)            = fc

+
  251 | getFC (IPrimVal fc _)            = fc

+
  252 | getFC (IType fc)                 = fc

+
  253 | getFC (IHole fc _)               = fc

+
  254 | getFC (Implicit fc _)            = fc

+
  255 | getFC (IWithUnambigNames fc _ _) = fc

+
  256 | 

+
  257 | public export

+
  258 | mapTopmostFC : (FC -> FC) -> TTImp -> TTImp

+
  259 | mapTopmostFC fcf $ IVar fc a                = IVar (fcf fc) a

+
  260 | mapTopmostFC fcf $ IPi fc a b c d e         = IPi (fcf fc) a b c d e

+
  261 | mapTopmostFC fcf $ ILam fc a b c d e        = ILam (fcf fc) a b c d e

+
  262 | mapTopmostFC fcf $ ILet fc a b c d e f      = ILet (fcf fc) a b c d e f

+
  263 | mapTopmostFC fcf $ ICase fc opts a b c      = ICase (fcf fc) opts a b c

+
  264 | mapTopmostFC fcf $ ILocal fc a b            = ILocal (fcf fc) a b

+
  265 | mapTopmostFC fcf $ IUpdate fc a b           = IUpdate (fcf fc) a b

+
  266 | mapTopmostFC fcf $ IApp fc a b              = IApp (fcf fc) a b

+
  267 | mapTopmostFC fcf $ INamedApp fc a b c       = INamedApp (fcf fc) a b c

+
  268 | mapTopmostFC fcf $ IAutoApp fc a b          = IAutoApp (fcf fc) a b

+
  269 | mapTopmostFC fcf $ IWithApp fc a b          = IWithApp (fcf fc) a b

+
  270 | mapTopmostFC fcf $ ISearch fc a             = ISearch (fcf fc) a

+
  271 | mapTopmostFC fcf $ IAlternative fc a b      = IAlternative (fcf fc) a b

+
  272 | mapTopmostFC fcf $ IRewrite fc a b          = IRewrite (fcf fc) a b

+
  273 | mapTopmostFC fcf $ IBindHere fc a b         = IBindHere (fcf fc) a b

+
  274 | mapTopmostFC fcf $ IBindVar fc a            = IBindVar (fcf fc) a

+
  275 | mapTopmostFC fcf $ IAs fc a b c d           = IAs (fcf fc) a b c d

+
  276 | mapTopmostFC fcf $ IMustUnify fc a b        = IMustUnify (fcf fc) a b

+
  277 | mapTopmostFC fcf $ IDelayed fc a b          = IDelayed (fcf fc) a b

+
  278 | mapTopmostFC fcf $ IDelay fc a              = IDelay (fcf fc) a

+
  279 | mapTopmostFC fcf $ IForce fc a              = IForce (fcf fc) a

+
  280 | mapTopmostFC fcf $ IQuote fc a              = IQuote (fcf fc) a

+
  281 | mapTopmostFC fcf $ IQuoteName fc a          = IQuoteName (fcf fc) a

+
  282 | mapTopmostFC fcf $ IQuoteDecl fc a          = IQuoteDecl (fcf fc) a

+
  283 | mapTopmostFC fcf $ IUnquote fc a            = IUnquote (fcf fc) a

+
  284 | mapTopmostFC fcf $ IPrimVal fc a            = IPrimVal (fcf fc) a

+
  285 | mapTopmostFC fcf $ IType fc                 = IType (fcf fc)

+
  286 | mapTopmostFC fcf $ IHole fc a               = IHole (fcf fc) a

+
  287 | mapTopmostFC fcf $ Implicit fc a            = Implicit (fcf fc) a

+
  288 | mapTopmostFC fcf $ IWithUnambigNames fc a b = IWithUnambigNames (fcf fc) a b

+
  289 | 

+
  290 | public export

+
  291 | Eq BindMode where

+
  292 |   PI c    == PI c'   = c == c'

+
  293 |   PATTERN == PATTERN = True

+
  294 |   NONE    == NONE    = True

+
  295 |   _ == _ = False

+
  296 | 

+
  297 | public export

+
  298 | Eq UseSide where

+
  299 |   UseLeft  == UseLeft  = True

+
  300 |   UseRight == UseRight = True

+
  301 |   _ == _ = False

+
  302 | 

+
  303 | public export

+
  304 | Eq DotReason where

+
  305 |   NonLinearVar    == NonLinearVar    = True

+
  306 |   VarApplied      == VarApplied      = True

+
  307 |   NotConstructor  == NotConstructor  = True

+
  308 |   ErasedArg       == ErasedArg       = True

+
  309 |   UserDotted      == UserDotted      = True

+
  310 |   UnknownDot      == UnknownDot      = True

+
  311 |   UnderAppliedCon == UnderAppliedCon = True

+
  312 |   _ == _ = False

+
  313 | 

+
  314 | public export

+
  315 | Eq WithFlag where

+
  316 |   Syntactic == Syntactic = True

+
  317 | 

+
  318 | public export

+
  319 | Eq DataOpt where

+
  320 |   SearchBy ns == SearchBy ns' = ns == ns'

+
  321 |   NoHints == NoHints = True

+
  322 |   UniqueSearch == UniqueSearch = True

+
  323 |   External == External = True

+
  324 |   NoNewtype == NoNewtype = True

+
  325 |   _ == _ = False

+
  326 | 

+
  327 | public export

+
  328 | Eq a => Eq (WithDefault a def) where

+
  329 |   DefaultedValue   == DefaultedValue   = True

+
  330 |   DefaultedValue   == SpecifiedValue _ = False

+
  331 |   SpecifiedValue _ == DefaultedValue   = False

+
  332 |   SpecifiedValue x == SpecifiedValue y = x == y

+
  333 | 

+
  334 | public export

+
  335 | Ord a => Ord (WithDefault a def) where

+
  336 |   compare DefaultedValue   DefaultedValue       = EQ

+
  337 |   compare DefaultedValue   (SpecifiedValue _)   = LT

+
  338 |   compare (SpecifiedValue _) DefaultedValue     = GT

+
  339 |   compare (SpecifiedValue x) (SpecifiedValue y) = compare x y

+
  340 | 

+
  341 | public export

+
  342 | {def : a} -> (Show a) => Show (WithDefault a def) where

+
  343 |   show (SpecifiedValue x) = show x

+
  344 |   show DefaultedValue     = show def

+
  345 | 

+
  346 | public export

+
  347 | Eq a => Eq (PiInfo a) where

+
  348 |   ImplicitArg   == ImplicitArg = True

+
  349 |   ExplicitArg   == ExplicitArg = True

+
  350 |   AutoImplicit  == AutoImplicit = True

+
  351 |   DefImplicit t == DefImplicit t' = t == t'

+
  352 |   _ == _ = False

+
  353 | 

+
  354 | parameters {auto eqTTImp : Eq TTImp}

+
  355 |   public export

+
  356 |   Eq Clause where

+
  357 |     PatClause _ lhs rhs == PatClause _ lhs' rhs' =

+
  358 |       lhs == lhs' && rhs == rhs'

+
  359 |     WithClause _ l r w p f cs == WithClause _ l' r' w' p' f' cs' =

+
  360 |       l == l' && r == r' && w == w' && p == p' && f == f' && (assert_total $ cs == cs')

+
  361 |     ImpossibleClause _ l == ImpossibleClause _ l' = l == l'

+
  362 |     _ == _ = False

+
  363 | 

+
  364 |   public export

+
  365 |   Eq IFieldUpdate where

+
  366 |     ISetField p t == ISetField p' t' =

+
  367 |       p == p' && t == t'

+
  368 |     ISetFieldApp p t == ISetFieldApp p' t' =

+
  369 |       p == p' && t == t'

+
  370 |     _ == _ = False

+
  371 | 

+
  372 |   public export

+
  373 |   Eq AltType where

+
  374 |     FirstSuccess    == FirstSuccess     = True

+
  375 |     Unique          == Unique           = True

+
  376 |     UniqueDefault t == UniqueDefault t' = t == t'

+
  377 |     _ == _ = False

+
  378 | 

+
  379 |   public export

+
  380 |   Eq FnOpt where

+
  381 |     Inline == Inline = True

+
  382 |     NoInline == NoInline = True

+
  383 |     Deprecate == Deprecate = True

+
  384 |     TCInline == TCInline = True

+
  385 |     Hint b == Hint b' = b == b'

+
  386 |     GlobalHint b == GlobalHint b' = b == b'

+
  387 |     ExternFn == ExternFn = True

+
  388 |     ForeignFn es == ForeignFn es' = es == es'

+
  389 |     ForeignExport es == ForeignExport es' = es == es'

+
  390 |     Invertible == Invertible = True

+
  391 |     Totality tr == Totality tr' = tr == tr'

+
  392 |     Macro == Macro = True

+
  393 |     SpecArgs ns == SpecArgs ns' = ns == ns'

+
  394 |     _ == _ = False

+
  395 | 

+
  396 |   public export

+
  397 |   Eq ITy where

+
  398 |     MkTy _ _ n ty == MkTy _ _ n' ty' = n == n' && ty == ty'

+
  399 | 

+
  400 |   public export

+
  401 |   Eq Data where

+
  402 |     MkData _ n tc os dc == MkData _ n' tc' os' dc' =

+
  403 |       n == n' && tc == tc' && os == os' && dc == dc'

+
  404 |     MkLater _ n tc == MkLater _ n' tc' =

+
  405 |       n == n' && tc == tc'

+
  406 |     _ == _ = False

+
  407 | 

+
  408 |   public export

+
  409 |   Eq IField where

+
  410 |     MkIField _ c pi n e == MkIField _ c' pi' n' e' =

+
  411 |       c == c' && pi == pi' && n == n' && e == e'

+
  412 | 

+
  413 |   public export

+
  414 |   Eq Record where

+
  415 |     MkRecord _ n ps opts cn fs == MkRecord _ n' ps' opts' cn' fs' =

+
  416 |       n == n' && ps == ps' && opts == opts' && cn == cn' && fs == fs'

+
  417 | 

+
  418 |   public export

+
  419 |   Eq Decl where

+
  420 |     IClaim _ c v fos t == IClaim _ c' v' fos' t' =

+
  421 |       c == c' && v == v' && fos == fos' && t == t'

+
  422 |     IData _ v t d == IData _ v' t' d' =

+
  423 |       v == v' && t == t' && d == d'

+
  424 |     IDef _ n cs == IDef _ n' cs' =

+
  425 |       n == n' && cs == cs'

+
  426 |     IParameters _ ps ds == IParameters _ ps' ds' =

+
  427 |       ps == ps' && (assert_total $ ds == ds')

+
  428 |     IRecord _ ns v tr r == IRecord _ ns' v' tr' r' =

+
  429 |       ns == ns' && v == v' && tr == tr' && r == r'

+
  430 |     INamespace _ ns ds == INamespace _ ns' ds' =

+
  431 |       ns == ns' && (assert_total $ ds == ds')

+
  432 |     ITransform _ n f t == ITransform _ n' f' t' =

+
  433 |       n == n' && f == f' && t == t'

+
  434 |     IRunElabDecl _ e == IRunElabDecl _ e' = e == e'

+
  435 |     ILog p == ILog p' = p == p'

+
  436 |     IBuiltin _ t n == IBuiltin _ t' n' =

+
  437 |       t == t' && n == n'

+
  438 |     _ == _ = False

+
  439 | 

+
  440 | public export

+
  441 | Eq TTImp where

+
  442 |   IVar _ v == IVar _ v' = v == v'

+
  443 |   IPi _ c i n a r == IPi _ c' i' n' a' r' =

+
  444 |     c == c' && (assert_total $ i == i') && n == n' && a == a' && r == r'

+
  445 |   ILam _ c i n a r == ILam _ c' i' n' a' r' =

+
  446 |     c == c' && (assert_total $ i == i') && n == n' && a == a' && r == r'

+
  447 |   ILet _ _ c n ty val s == ILet _ _ c' n' ty' val' s' =

+
  448 |     c == c' && n == n' && ty == ty' && val == val' && s == s'

+
  449 |   ICase _ _ t ty cs == ICase _ _ t' ty' cs'

+
  450 |     = t == t' && ty == ty' && (assert_total $ cs == cs')

+
  451 |   ILocal _ ds e == ILocal _ ds' e' =

+
  452 |     (assert_total $ ds == ds') && e == e'

+
  453 |   IUpdate _ fs t == IUpdate _ fs' t' =

+
  454 |     (assert_total $ fs == fs') && t == t'

+
  455 | 

+
  456 |   IApp _ f x == IApp _ f' x' = f == f' && x == x'

+
  457 |   INamedApp _ f n x == INamedApp _ f' n' x' =

+
  458 |     f == f' && n == n' && x == x'

+
  459 |   IAutoApp _ f x == IAutoApp _ f' x' = f == f' && x == x'

+
  460 |   IWithApp _ f x == IWithApp _ f' x' = f == f' && x == x'

+
  461 | 

+
  462 |   ISearch _ n == ISearch _ n' = n == n'

+
  463 |   IAlternative _ t as == IAlternative _ t' as' =

+
  464 |     (assert_total $ t == t') && (assert_total $ as == as')

+
  465 |   IRewrite _ p q == IRewrite _ p' q' =

+
  466 |     p == p' && q == q'

+
  467 | 

+
  468 |   IBindHere _ m t == IBindHere _ m' t' =

+
  469 |     m == m' && t == t'

+
  470 |   IBindVar _ s == IBindVar _ s' = s == s'

+
  471 |   IAs _ _ u n t == IAs _ _ u' n' t' =

+
  472 |     u == u' && n == n' && t == t'

+
  473 |   IMustUnify _ r t == IMustUnify _ r' t' =

+
  474 |     r == r' && t == t'

+
  475 | 

+
  476 |   IDelayed _ r t == IDelayed _ r' t' = r == r' && t == t'

+
  477 |   IDelay _ t == IDelay _ t' = t == t'

+
  478 |   IForce _ t == IForce _ t' = t == t'

+
  479 | 

+
  480 |   IQuote _ tm == IQuote _ tm' = tm == tm'

+
  481 |   IQuoteName _ n == IQuoteName _ n' = n == n'

+
  482 |   IQuoteDecl _ ds == IQuoteDecl _ ds' = assert_total $ ds == ds'

+
  483 |   IUnquote _ tm == IUnquote _ tm' = tm == tm'

+
  484 | 

+
  485 |   IPrimVal _ c == IPrimVal _ c' = c == c'

+
  486 |   IType _ == IType _ = True

+
  487 |   IHole _ s == IHole _ s' = s == s'

+
  488 | 

+
  489 |   Implicit _ b == Implicit _ b' = b == b'

+
  490 |   IWithUnambigNames _ ns t == IWithUnambigNames _ ns' t' =

+
  491 |     map snd ns == map snd ns' && t == t'

+
  492 | 

+
  493 |   _ == _ = False

+
  494 | 

+
  495 | public export

+
  496 | data Mode = InDecl | InCase

+
  497 | 

+
  498 | mutual

+
  499 | 

+
  500 |   public export

+
  501 |   Show IField where

+
  502 |     show (MkIField fc rig pinfo nm s) =

+
  503 |       showPiInfo {wrapExplicit=False} pinfo (showCount rig "\{show nm} : \{show s}")

+
  504 | 

+
  505 |   public export

+
  506 |   Show Record where

+
  507 |     show (MkRecord fc n params opts conName fields) -- TODO: print opts

+
  508 |       = unwords

+
  509 |       [ "record", show n

+
  510 |       , unwords (map (\ (nm, rig, pinfo, ty) =>

+
  511 |                        showPiInfo pinfo (showCount rig "\{show nm} : \{show ty}"))

+
  512 |                 params)

+
  513 |       , "where"

+
  514 |       , "{"

+
  515 |       , "constructor", show conName, "; "

+
  516 |       , joinBy "; " (map show fields)

+
  517 |       , "}"

+
  518 |       ]

+
  519 | 

+
  520 |   public export

+
  521 |   Show Data where

+
  522 |     show (MkData fc n tycon opts datacons) -- TODO: print opts

+
  523 |       = unwords

+
  524 |       [ "data", show n, ":", show tycon, "where"

+
  525 |       , "{", joinBy "; " (map show datacons), "}"

+
  526 |       ]

+
  527 |     show (MkLater fc n tycon) = unwords [ "data", show n, ":", show tycon ]

+
  528 | 

+
  529 |   public export

+
  530 |   Show ITy where

+
  531 |     show (MkTy fc nameFC n ty) = "\{show n} : \{show ty}"

+
  532 | 

+
  533 |   public export

+
  534 |   Show Decl where

+
  535 |     show (IClaim fc rig vis xs sig)

+
  536 |       = unwords [ show vis

+
  537 |                 , showCount rig (show sig) ]

+
  538 |     show (IData fc vis treq dt)

+
  539 |       = unwords [ show vis

+
  540 |                 , showTotalReq treq (show dt)

+
  541 |                 ]

+
  542 |     show (IDef fc nm xs) = joinBy "; " (map (showClause InDecl) xs)

+
  543 |     show (IParameters fc params decls)

+
  544 |       = unwords

+
  545 |       [ "parameters"

+
  546 |       , unwords (map (\ (nm, rig, pinfo, ty) =>

+
  547 |                        showPiInfo pinfo (showCount rig "\{show nm} : \{show ty}"))

+
  548 |                 params)

+
  549 |       , "{"

+
  550 |       , joinBy "; " (assert_total $ map show decls)

+
  551 |       , "}"

+
  552 |       ]

+
  553 |     show (IRecord fc x vis treq rec)

+
  554 |       = unwords [ show vis, showTotalReq treq (show rec) ]

+
  555 |     show (INamespace fc ns decls)

+
  556 |       = unwords

+
  557 |       [ "namespace", show ns

+
  558 |       , "{", joinBy "; " (assert_total $ map show decls), "}" ]

+
  559 |     show (ITransform fc nm s t) = #"%transform "\{show nm}" \{show s} = \{show t}"#

+
  560 |     show (IRunElabDecl fc s) = "%runElab \{show s}"

+
  561 |     show (ILog loglvl) = case loglvl of

+
  562 |       Nothing => "%logging off"

+
  563 |       Just ([], lvl) => "%logging \{show lvl}"

+
  564 |       Just (topic, lvl) => "%logging \{joinBy "." topic} \{show lvl}"

+
  565 |     show (IBuiltin fc bty nm) = "%builtin \{show bty} \{show nm}"

+
  566 | 

+
  567 |   public export

+
  568 |   Show IFieldUpdate where

+
  569 |     show (ISetField path s) = "\{joinBy "->" path} := \{show s}"

+
  570 |     show (ISetFieldApp path s) = "\{joinBy "->" path} $= \{show s}"

+
  571 | 

+
  572 |   public export

+
  573 |   showClause : Mode -> Clause -> String

+
  574 |   showClause mode (PatClause fc lhs rhs) = "\{show lhs} \{showSep mode} \{show rhs}" where

+
  575 |     showSep : Mode -> String

+
  576 |     showSep InDecl = "="

+
  577 |     showSep InCase = "=>"

+
  578 |   showClause mode (WithClause fc lhs rig wval prf flags cls) -- TODO print flags

+
  579 |       = unwords

+
  580 |       [ show lhs, "with"

+
  581 |       , showCount rig $ maybe id (\ nm => (++ " proof \{show nm}")) prf

+
  582 |                       $ showParens True (show wval)

+
  583 |       , "{", joinBy "; " (assert_total $ map (showClause mode) cls), "}"

+
  584 |       ]

+
  585 |   showClause mode (ImpossibleClause fc lhs) = "\{show lhs} impossible"

+
  586 | 

+
  587 |   collectPis : Count -> PiInfo TTImp -> SnocList Name -> TTImp -> TTImp -> (List Name, TTImp)

+
  588 |   collectPis rig pinfo xs argTy t@(IPi fc rig' pinfo' x argTy' retTy)

+
  589 |     = ifThenElse (rig == rig' && pinfo == pinfo' && argTy == argTy')

+
  590 |          (collectPis rig pinfo (xs :< fromMaybe (UN Underscore) x) argTy retTy)

+
  591 |          (xs <>> [], t)

+
  592 |   collectPis rig pinfo xs argTy t = (xs <>> [], t)

+
  593 | 

+
  594 |   showIApps : TTImp -> List String -> String

+
  595 |   showIApps (IApp _ f t) ts = showIApps f (assert_total (showPrec App t) :: ts)

+
  596 |   showIApps (IVar _ nm) [a,b] =

+
  597 |     if isOp nm then unwords [a, showPrefix False nm, b]

+
  598 |     else unwords [showPrefix True nm, a, b]

+
  599 |   showIApps f ts = unwords (show f :: ts)

+
  600 | 

+
  601 |   public export

+
  602 |   Show TTImp where

+
  603 |     showPrec d (IVar fc nm) = showPrefix True nm

+
  604 |     showPrec d (IPi fc MW ExplicitArg Nothing argTy retTy)

+
  605 |       = showParens (d > Open) $ "\{showPrec Dollar argTy} -> \{show retTy}"

+
  606 |     showPrec d (IPi fc MW AutoImplicit Nothing argTy retTy)

+
  607 |       = showParens (d > Open) $ "\{showPrec Dollar argTy} => \{show retTy}"

+
  608 |     showPrec d (IPi fc rig pinfo x argTy retTy)

+
  609 |       = showParens (d > Open) $

+
  610 |           let (xs, retTy) = collectPis rig pinfo [<fromMaybe (UN Underscore) x] argTy retTy in

+
  611 |           assert_total (showPiInfo pinfo "\{showCount rig $ joinBy ", " (show <$> xs)} : \{show argTy}")

+
  612 |           ++ " -> \{assert_total $ show retTy}"

+
  613 |     showPrec d (ILam fc rig pinfo x argTy lamTy)

+
  614 |       = showParens (d > Open) $

+
  615 |           "\\ \{showCount rig $ show (fromMaybe (UN Underscore) x)} => \{show lamTy}"

+
  616 |     showPrec d (ILet fc lhsFC rig nm nTy nVal scope)

+
  617 |       = showParens (d > Open) $

+
  618 |           "let \{showCount rig (show nm)} : \{show nTy} = \{show nVal} in \{show scope}"

+
  619 |     showPrec d (ICase fc _ s ty xs)

+
  620 |       = showParens (d > Open) $

+
  621 |           unwords $ [ "case", show s ] ++ typeFor ty ++ [ "of", "{"

+
  622 |                     , joinBy "; " (assert_total $ map (showClause InCase) xs)

+
  623 |                     , "}"

+
  624 |                     ]

+
  625 |           where

+
  626 |             typeFor : TTImp -> List String

+
  627 |             typeFor $ Implicit _ False = []

+
  628 |             typeFor ty = [ "{-", ":", show ty, "-}" ]

+
  629 |     showPrec d (ILocal fc decls s)

+
  630 |       = showParens (d > Open) $

+
  631 |           unwords [ "let", joinBy "; " (assert_total $ map show decls)

+
  632 |                   , "in", show s

+
  633 |                   ]

+
  634 |     showPrec d (IUpdate fc upds s)

+
  635 |       = showParens (d > Open) $

+
  636 |           unwords [ "{", joinBy ", " $ assert_total (map show upds), "}"

+
  637 |                   , showPrec App s ]

+
  638 |     showPrec d (IApp fc f t)

+
  639 |       = showParens (d >= App) $ assert_total $ showIApps f [showPrec App t]

+
  640 |     showPrec d (INamedApp fc f nm t)

+
  641 |       = showParens (d >= App) $ "\{show f} {\{show nm} = \{show t}}"

+
  642 |     showPrec d (IAutoApp fc f t)

+
  643 |       = showParens (d >= App) $ "\{show f} @{\{show t}}"

+
  644 |     showPrec d (IWithApp fc f t)

+
  645 |       = showParens (d >= App) $ "\{show f} | \{showPrec App t}"

+
  646 |     showPrec d (ISearch fc depth) = "%search"

+
  647 |     showPrec d (IAlternative fc x xs) = "<\{show (length xs)} alts>"

+
  648 |     showPrec d (IRewrite fc s t)

+
  649 |       = showParens (d > Open) "rewrite \{show s} in \{show t}"

+
  650 |     showPrec d (IBindHere fc bm s) = showPrec d s

+
  651 |     showPrec d (IBindVar fc x) = x

+
  652 |     showPrec d (IAs fc nameFC side nm s)

+
  653 |       = "\{show nm}@\{showPrec App s}"

+
  654 |     showPrec d (IMustUnify fc dr s) = ".(\{show s})"

+
  655 |     showPrec d (IDelayed fc LInf s) = showCon d "Inf" $ assert_total $ showArg s

+
  656 |     showPrec d (IDelayed fc LLazy s) = showCon d "Lazy" $ assert_total $ showArg s

+
  657 |     showPrec d (IDelayed fc LUnknown s) = "({- unknown lazy -} \{showPrec Open s})"

+
  658 |     showPrec d (IDelay fc s) = showCon d "Delay" $ assert_total $ showArg s

+
  659 |     showPrec d (IForce fc s) = showCon d "Force" $ assert_total $ showArg s

+
  660 |     showPrec d (IQuote fc s) = "`(\{show s})"

+
  661 |     showPrec d (IQuoteName fc nm) = "`{\{show nm}}"

+
  662 |     showPrec d (IQuoteDecl fc xs) = "`[\{joinBy "; " (assert_total $ map show xs)}]"

+
  663 |     showPrec d (IUnquote fc s) = "~(\{show s})"

+
  664 |     showPrec d (IPrimVal fc c) = show c

+
  665 |     showPrec d (IType fc) = "Type"

+
  666 |     showPrec d (IHole fc str) = "?" ++ str

+
  667 |     showPrec d (Implicit fc b) = ifThenElse b "_" "?"

+
  668 |     showPrec d (IWithUnambigNames fc ns s) = case ns of

+
  669 |       [] => show s

+
  670 |       [(_,x)] => "with \{show x} \{show s}"

+
  671 |       _   => "with [\{joinBy ", " $ map (show . snd) ns}] \{show s}"

+
  672 | 

+
  673 | public export

+
  674 | data Argument a

+
  675 |   = Arg FC a

+
  676 |   | NamedArg FC Name a

+
  677 |   | AutoArg FC a

+
  678 | 

+
  679 | public export

+
  680 | isExplicit : Argument a -> Maybe (FC, a)

+
  681 | isExplicit (Arg fc a) = pure (fc, a)

+
  682 | isExplicit _ = Nothing

+
  683 | 

+
  684 | public export

+
  685 | fromPiInfo : FC -> PiInfo t -> Maybe Name -> a -> Maybe (Argument a)

+
  686 | fromPiInfo fc ImplicitArg (Just nm) a = pure (NamedArg fc nm a)

+
  687 | fromPiInfo fc ExplicitArg _ a = pure (Arg fc a)

+
  688 | fromPiInfo fc AutoImplicit _ a = pure (AutoArg fc a)

+
  689 | fromPiInfo fc (DefImplicit _) (Just nm) a = pure (NamedArg fc nm a)

+
  690 | fromPiInfo _ _ _ _ = Nothing

+
  691 | 

+
  692 | public export

+
  693 | Functor Argument where

+
  694 |   map f (Arg fc a) = Arg fc (f a)

+
  695 |   map f (NamedArg fc nm a) = NamedArg fc nm (f a)

+
  696 |   map f (AutoArg fc a) = AutoArg fc (f a)

+
  697 | 

+
  698 | public export

+
  699 | iApp : TTImp -> Argument TTImp -> TTImp

+
  700 | iApp f (Arg fc t) = IApp fc f t

+
  701 | iApp f (NamedArg fc nm t) = INamedApp fc f nm t

+
  702 | iApp f (AutoArg fc t) = IAutoApp fc f t

+
  703 | 

+
  704 | public export

+
  705 | unArg : Argument a -> a

+
  706 | unArg (Arg _ x) = x

+
  707 | unArg (NamedArg _ _ x) = x

+
  708 | unArg (AutoArg _ x) = x

+
  709 | 

+
  710 | ||| We often apply multiple arguments, this makes things simpler

+
  711 | public export

+
  712 | apply : TTImp -> List (Argument TTImp) -> TTImp

+
  713 | apply = foldl iApp

+
  714 | 

+
  715 | public export

+
  716 | data IsAppView : (FC, Name) -> SnocList (Argument TTImp) -> TTImp -> Type where

+
  717 |   AVVar : IsAppView (fc, t) [<] (IVar fc t)

+
  718 |   AVApp : IsAppView x ts f -> IsAppView x (ts :< Arg fc t) (IApp fc f t)

+
  719 |   AVNamedApp : IsAppView x ts f -> IsAppView x (ts :< NamedArg fc n t) (INamedApp fc f n t)

+
  720 |   AVAutoApp : IsAppView x ts f -> IsAppView x (ts :< AutoArg fc t) (IAutoApp fc f a)

+
  721 | 

+
  722 | public export

+
  723 | record AppView (t : TTImp) where

+
  724 |   constructor MkAppView

+
  725 |   head : (FC, Name)

+
  726 |   args : SnocList (Argument TTImp)

+
  727 |   0 isAppView : IsAppView head args t

+
  728 | 

+
  729 | public export

+
  730 | appView : (t : TTImp) -> Maybe (AppView t)

+
  731 | appView (IVar fc f) = Just (MkAppView (fc, f) [<] AVVar)

+
  732 | appView (IApp fc f t) = do

+
  733 |   (MkAppView x ts prf) <- appView f

+
  734 |   pure (MkAppView x (ts :< Arg fc t) (AVApp prf))

+
  735 | appView (INamedApp fc f n t) = do

+
  736 |   (MkAppView x ts prf) <- appView f

+
  737 |   pure (MkAppView x (ts :< NamedArg fc n t) (AVNamedApp prf))

+
  738 | appView (IAutoApp fc f t) = do

+
  739 |   (MkAppView x ts prf) <- appView f

+
  740 |   pure (MkAppView x (ts :< AutoArg fc t) (AVAutoApp prf))

+
  741 | appView _ = Nothing

+
  742 | 

+
  743 | parameters (f : TTImp -> TTImp)

+
  744 | 

+
  745 |   public export

+
  746 |   mapTTImp : TTImp -> TTImp

+
  747 | 

+
  748 |   public export

+
  749 |   mapPiInfo : PiInfo TTImp -> PiInfo TTImp

+
  750 |   mapPiInfo ImplicitArg = ImplicitArg

+
  751 |   mapPiInfo ExplicitArg = ExplicitArg

+
  752 |   mapPiInfo AutoImplicit = AutoImplicit

+
  753 |   mapPiInfo (DefImplicit t) = DefImplicit (mapTTImp t)

+
  754 | 

+
  755 |   public export

+
  756 |   mapClause : Clause -> Clause

+
  757 |   mapClause (PatClause fc lhs rhs) = PatClause fc (mapTTImp lhs) (mapTTImp rhs)

+
  758 |   mapClause (WithClause fc lhs rig wval prf flags cls)

+
  759 |     = WithClause fc (mapTTImp lhs) rig (mapTTImp wval) prf flags (assert_total $ map mapClause cls)

+
  760 |   mapClause (ImpossibleClause fc lhs) = ImpossibleClause fc (mapTTImp lhs)

+
  761 | 

+
  762 |   public export

+
  763 |   mapITy : ITy -> ITy

+
  764 |   mapITy (MkTy fc nameFC n ty) = MkTy fc nameFC n (mapTTImp ty)

+
  765 | 

+
  766 |   public export

+
  767 |   mapFnOpt : FnOpt -> FnOpt

+
  768 |   mapFnOpt Inline = Inline

+
  769 |   mapFnOpt NoInline = NoInline

+
  770 |   mapFnOpt Deprecate = Deprecate

+
  771 |   mapFnOpt TCInline = TCInline

+
  772 |   mapFnOpt (Hint b) = Hint b

+
  773 |   mapFnOpt (GlobalHint b) = GlobalHint b

+
  774 |   mapFnOpt ExternFn = ExternFn

+
  775 |   mapFnOpt (ForeignFn ts) = ForeignFn (map mapTTImp ts)

+
  776 |   mapFnOpt (ForeignExport ts) = ForeignExport (map mapTTImp ts)

+
  777 |   mapFnOpt Invertible = Invertible

+
  778 |   mapFnOpt (Totality treq) = Totality treq

+
  779 |   mapFnOpt Macro = Macro

+
  780 |   mapFnOpt (SpecArgs ns) = SpecArgs ns

+
  781 | 

+
  782 |   public export

+
  783 |   mapData : Data -> Data

+
  784 |   mapData (MkData fc n tycon opts datacons)

+
  785 |     = MkData fc n (map mapTTImp tycon) opts (map mapITy datacons)

+
  786 |   mapData (MkLater fc n tycon) = MkLater fc n (mapTTImp tycon)

+
  787 | 

+
  788 |   public export

+
  789 |   mapIField : IField -> IField

+
  790 |   mapIField (MkIField fc rig pinfo n t) = MkIField fc rig (mapPiInfo pinfo) n (mapTTImp t)

+
  791 | 

+
  792 |   public export

+
  793 |   mapRecord : Record -> Record

+
  794 |   mapRecord (MkRecord fc n params opts conName fields)

+
  795 |     = MkRecord fc n (map (map $ map $ bimap mapPiInfo mapTTImp) params) opts conName (map mapIField fields)

+
  796 | 

+
  797 |   public export

+
  798 |   mapDecl : Decl -> Decl

+
  799 |   mapDecl (IClaim fc rig vis opts ty)

+
  800 |     = IClaim fc rig vis (map mapFnOpt opts) (mapITy ty)

+
  801 |   mapDecl (IData fc vis mtreq dat) = IData fc vis mtreq (mapData dat)

+
  802 |   mapDecl (IDef fc n cls) = IDef fc n (map mapClause cls)

+
  803 |   mapDecl (IParameters fc params xs) = IParameters fc params (assert_total $ map mapDecl xs)

+
  804 |   mapDecl (IRecord fc mstr x y rec) = IRecord fc mstr x y (mapRecord rec)

+
  805 |   mapDecl (INamespace fc mi xs) = INamespace fc mi (assert_total $ map mapDecl xs)

+
  806 |   mapDecl (ITransform fc n t u) = ITransform fc n (mapTTImp t) (mapTTImp u)

+
  807 |   mapDecl (IRunElabDecl fc t) = IRunElabDecl fc (mapTTImp t)

+
  808 |   mapDecl (ILog x) = ILog x

+
  809 |   mapDecl (IBuiltin fc x n) = IBuiltin fc x n

+
  810 | 

+
  811 |   public export

+
  812 |   mapIFieldUpdate : IFieldUpdate -> IFieldUpdate

+
  813 |   mapIFieldUpdate (ISetField path t) = ISetField path (mapTTImp t)

+
  814 |   mapIFieldUpdate (ISetFieldApp path t) = ISetFieldApp path (mapTTImp t)

+
  815 | 

+
  816 |   public export

+
  817 |   mapAltType : AltType -> AltType

+
  818 |   mapAltType FirstSuccess = FirstSuccess

+
  819 |   mapAltType Unique = Unique

+
  820 |   mapAltType (UniqueDefault t) = UniqueDefault (mapTTImp t)

+
  821 | 

+
  822 |   mapTTImp t@(IVar _ _) = f t

+
  823 |   mapTTImp (IPi fc rig pinfo x argTy retTy)

+
  824 |     = f $ IPi fc rig (mapPiInfo pinfo) x (mapTTImp argTy) (mapTTImp retTy)

+
  825 |   mapTTImp (ILam fc rig pinfo x argTy lamTy)

+
  826 |     = f $ ILam fc rig (mapPiInfo pinfo) x (mapTTImp argTy) (mapTTImp lamTy)

+
  827 |   mapTTImp (ILet fc lhsFC rig n nTy nVal scope)

+
  828 |     = f $ ILet fc lhsFC rig n (mapTTImp nTy) (mapTTImp nVal) (mapTTImp scope)

+
  829 |   mapTTImp (ICase fc opts t ty cls)

+
  830 |     = f $ ICase fc opts (mapTTImp t) (mapTTImp ty) (assert_total $ map mapClause cls)

+
  831 |   mapTTImp (ILocal fc xs t)

+
  832 |     = f $ ILocal fc (assert_total $ map mapDecl xs) (mapTTImp t)

+
  833 |   mapTTImp (IUpdate fc upds t) = f $ IUpdate fc (assert_total map mapIFieldUpdate upds) (mapTTImp t)

+
  834 |   mapTTImp (IApp fc t u) = f $ IApp fc (mapTTImp t) (mapTTImp u)

+
  835 |   mapTTImp (IAutoApp fc t u) = f $ IAutoApp fc (mapTTImp t) (mapTTImp u)

+
  836 |   mapTTImp (INamedApp fc t n u) = f $ INamedApp fc (mapTTImp t) n (mapTTImp u)

+
  837 |   mapTTImp (IWithApp fc t u) = f $ IWithApp fc (mapTTImp t) (mapTTImp u)

+
  838 |   mapTTImp (ISearch fc depth) = f $ ISearch fc depth

+
  839 |   mapTTImp (IAlternative fc alt ts) = f $ IAlternative fc (mapAltType alt) (assert_total map mapTTImp ts)

+
  840 |   mapTTImp (IRewrite fc t u) = f $ IRewrite fc (mapTTImp t) (mapTTImp u)

+
  841 |   mapTTImp (IBindHere fc bm t) = f $ IBindHere fc bm (mapTTImp t)

+
  842 |   mapTTImp (IBindVar fc str) = f $ IBindVar fc str

+
  843 |   mapTTImp (IAs fc nameFC side n t) = f $ IAs fc nameFC side n (mapTTImp t)

+
  844 |   mapTTImp (IMustUnify fc x t) = f $ IMustUnify fc x (mapTTImp t)

+
  845 |   mapTTImp (IDelayed fc lz t) = f $ IDelayed fc lz (mapTTImp t)

+
  846 |   mapTTImp (IDelay fc t) = f $ IDelay fc (mapTTImp t)

+
  847 |   mapTTImp (IForce fc t) = f $ IForce fc (mapTTImp t)

+
  848 |   mapTTImp (IQuote fc t) = f $ IQuote fc (mapTTImp t)

+
  849 |   mapTTImp (IQuoteName fc n) = f $ IQuoteName fc n

+
  850 |   mapTTImp (IQuoteDecl fc xs) = f $ IQuoteDecl fc (assert_total $ map mapDecl xs)

+
  851 |   mapTTImp (IUnquote fc t) = f $ IUnquote fc (mapTTImp t)

+
  852 |   mapTTImp (IPrimVal fc c) = f $ IPrimVal fc c

+
  853 |   mapTTImp (IType fc) = f $ IType fc

+
  854 |   mapTTImp (IHole fc str) = f $ IHole fc str

+
  855 |   mapTTImp (Implicit fc bindIfUnsolved) = f $ Implicit fc bindIfUnsolved

+
  856 |   mapTTImp (IWithUnambigNames fc xs t) = f $ IWithUnambigNames fc xs (mapTTImp t)

+
  857 | 

+
  858 | parameters {0 m : Type -> Type} {auto apl : Applicative m} (f : (original : TTImp) -> m TTImp -> m TTImp)

+
  859 | 

+
  860 |   public export

+
  861 |   mapATTImp' : TTImp -> m TTImp

+
  862 | 

+
  863 |   public export

+
  864 |   mapMPiInfo : PiInfo TTImp -> m (PiInfo TTImp)

+
  865 |   mapMPiInfo ImplicitArg = pure ImplicitArg

+
  866 |   mapMPiInfo ExplicitArg = pure ExplicitArg

+
  867 |   mapMPiInfo AutoImplicit = pure AutoImplicit

+
  868 |   mapMPiInfo (DefImplicit t) = DefImplicit <$> mapATTImp' t

+
  869 | 

+
  870 |   public export

+
  871 |   mapMClause : Clause -> m Clause

+
  872 |   mapMClause (PatClause fc lhs rhs) = PatClause fc <$> mapATTImp' lhs <*> mapATTImp' rhs

+
  873 |   mapMClause (WithClause fc lhs rig wval prf flags cls)

+
  874 |     = WithClause fc

+
  875 |     <$> mapATTImp' lhs

+
  876 |     <*> pure rig

+
  877 |     <*> mapATTImp' wval

+
  878 |     <*> pure prf

+
  879 |     <*> pure flags

+
  880 |     <*> assert_total (traverse mapMClause cls)

+
  881 |   mapMClause (ImpossibleClause fc lhs) = ImpossibleClause fc <$> mapATTImp' lhs

+
  882 | 

+
  883 |   public export

+
  884 |   mapMITy : ITy -> m ITy

+
  885 |   mapMITy (MkTy fc nameFC n ty) = MkTy fc nameFC n <$> mapATTImp' ty

+
  886 | 

+
  887 |   public export

+
  888 |   mapMFnOpt : FnOpt -> m FnOpt

+
  889 |   mapMFnOpt Inline = pure Inline

+
  890 |   mapMFnOpt NoInline = pure NoInline

+
  891 |   mapMFnOpt Deprecate = pure Deprecate

+
  892 |   mapMFnOpt TCInline = pure TCInline

+
  893 |   mapMFnOpt (Hint b) = pure (Hint b)

+
  894 |   mapMFnOpt (GlobalHint b) = pure (GlobalHint b)

+
  895 |   mapMFnOpt ExternFn = pure ExternFn

+
  896 |   mapMFnOpt (ForeignFn ts) = ForeignFn <$> traverse mapATTImp' ts

+
  897 |   mapMFnOpt (ForeignExport ts) = ForeignExport <$> traverse mapATTImp' ts

+
  898 |   mapMFnOpt Invertible = pure Invertible

+
  899 |   mapMFnOpt (Totality treq) = pure (Totality treq)

+
  900 |   mapMFnOpt Macro = pure Macro

+
  901 |   mapMFnOpt (SpecArgs ns) = pure (SpecArgs ns)

+
  902 | 

+
  903 |   public export

+
  904 |   mapMData : Data -> m Data

+
  905 |   mapMData (MkData fc n tycon opts datacons)

+
  906 |     = MkData fc n <$> traverse mapATTImp' tycon <*> pure opts <*> traverse mapMITy datacons

+
  907 |   mapMData (MkLater fc n tycon) = MkLater fc n <$> mapATTImp' tycon

+
  908 | 

+
  909 |   public export

+
  910 |   mapMIField : IField -> m IField

+
  911 |   mapMIField (MkIField fc rig pinfo n t)

+
  912 |    = MkIField fc rig <$> mapMPiInfo pinfo <*> pure n <*> mapATTImp' t

+
  913 | 

+
  914 |   public export

+
  915 |   mapMRecord : Record -> m Record

+
  916 |   mapMRecord (MkRecord fc n params opts conName fields)

+
  917 |     = MkRecord fc n

+
  918 |     <$> traverse (bitraverse pure $ bitraverse pure $ bitraverse mapMPiInfo mapATTImp') params

+
  919 |     <*> pure opts

+
  920 |     <*> pure conName

+
  921 |     <*> traverse mapMIField fields

+
  922 | 

+
  923 |   public export

+
  924 |   mapMDecl : Decl -> m Decl

+
  925 |   mapMDecl (IClaim fc rig vis opts ty)

+
  926 |     = IClaim fc rig vis <$> traverse mapMFnOpt opts <*> mapMITy ty

+
  927 |   mapMDecl (IData fc vis mtreq dat) = IData fc vis mtreq <$> mapMData dat

+
  928 |   mapMDecl (IDef fc n cls) = IDef fc n <$> traverse mapMClause cls

+
  929 |   mapMDecl (IParameters fc params xs) = IParameters fc params <$> assert_total (traverse mapMDecl xs)

+
  930 |   mapMDecl (IRecord fc mstr x y rec) = IRecord fc mstr x y <$> mapMRecord rec

+
  931 |   mapMDecl (INamespace fc mi xs) = INamespace fc mi <$> assert_total (traverse mapMDecl xs)

+
  932 |   mapMDecl (ITransform fc n t u) = ITransform fc n <$> mapATTImp' t <*> mapATTImp' u

+
  933 |   mapMDecl (IRunElabDecl fc t) = IRunElabDecl fc <$> mapATTImp' t

+
  934 |   mapMDecl (ILog x) = pure (ILog x)

+
  935 |   mapMDecl (IBuiltin fc x n) = pure (IBuiltin fc x n)

+
  936 | 

+
  937 |   public export

+
  938 |   mapMIFieldUpdate : IFieldUpdate -> m IFieldUpdate

+
  939 |   mapMIFieldUpdate (ISetField path t) = ISetField path <$> mapATTImp' t

+
  940 |   mapMIFieldUpdate (ISetFieldApp path t) = ISetFieldApp path <$> mapATTImp' t

+
  941 | 

+
  942 |   public export

+
  943 |   mapMAltType : AltType -> m AltType

+
  944 |   mapMAltType FirstSuccess = pure FirstSuccess

+
  945 |   mapMAltType Unique = pure Unique

+
  946 |   mapMAltType (UniqueDefault t) = UniqueDefault <$> mapATTImp' t

+
  947 | 

+
  948 |   mapATTImp' t@(IVar _ _) = f t $ pure t

+
  949 |   mapATTImp' o@(IPi fc rig pinfo x argTy retTy)

+
  950 |     = f o $ IPi fc rig <$> mapMPiInfo pinfo <*> pure x <*> mapATTImp' argTy <*> mapATTImp' retTy

+
  951 |   mapATTImp' o@(ILam fc rig pinfo x argTy lamTy)

+
  952 |     = f o $ ILam fc rig <$> mapMPiInfo pinfo <*> pure x <*> mapATTImp' argTy <*> mapATTImp' lamTy

+
  953 |   mapATTImp' o@(ILet fc lhsFC rig n nTy nVal scope)

+
  954 |     = f o $ ILet fc lhsFC rig n <$> mapATTImp' nTy <*> mapATTImp' nVal <*> mapATTImp' scope

+
  955 |   mapATTImp' o@(ICase fc opts t ty cls)

+
  956 |     = f o $ ICase fc opts <$> mapATTImp' t <*> mapATTImp' ty <*> assert_total (traverse mapMClause cls)

+
  957 |   mapATTImp' o@(ILocal fc xs t)

+
  958 |     = f o $ ILocal fc <$> assert_total (traverse mapMDecl xs) <*> mapATTImp' t

+
  959 |   mapATTImp' o@(IUpdate fc upds t)

+
  960 |     = f o $ IUpdate fc <$> assert_total (traverse mapMIFieldUpdate upds) <*> mapATTImp' t

+
  961 |   mapATTImp' o@(IApp fc t u)

+
  962 |     = f o $ IApp fc <$> mapATTImp' t <*> mapATTImp' u

+
  963 |   mapATTImp' o@(IAutoApp fc t u)

+
  964 |     = f o $ IAutoApp fc <$> mapATTImp' t <*> mapATTImp' u

+
  965 |   mapATTImp' o@(INamedApp fc t n u)

+
  966 |     = f o $ INamedApp fc <$> mapATTImp' t <*> pure n <*> mapATTImp' u

+
  967 |   mapATTImp' o@(IWithApp fc t u) = f o $ IWithApp fc <$> mapATTImp' t <*> mapATTImp' u

+
  968 |   mapATTImp' o@(ISearch fc depth) = f o $ pure $ ISearch fc depth

+
  969 |   mapATTImp' o@(IAlternative fc alt ts)

+
  970 |     = f o $ IAlternative fc <$> mapMAltType alt <*> assert_total (traverse mapATTImp' ts)

+
  971 |   mapATTImp' o@(IRewrite fc t u) = f o $ IRewrite fc <$> mapATTImp' t <*> mapATTImp' u

+
  972 |   mapATTImp' o@(IBindHere fc bm t) = f o $ IBindHere fc bm <$> mapATTImp' t

+
  973 |   mapATTImp' o@(IBindVar fc str) = f o $ pure $ IBindVar fc str

+
  974 |   mapATTImp' o@(IAs fc nameFC side n t) = f o $ IAs fc nameFC side n <$> mapATTImp' t

+
  975 |   mapATTImp' o@(IMustUnify fc x t) = f o $ IMustUnify fc x <$> mapATTImp' t

+
  976 |   mapATTImp' o@(IDelayed fc lz t) = f o $ IDelayed fc lz <$> mapATTImp' t

+
  977 |   mapATTImp' o@(IDelay fc t) = f o $ IDelay fc <$> mapATTImp' t

+
  978 |   mapATTImp' o@(IForce fc t) = f o $ IForce fc <$> mapATTImp' t

+
  979 |   mapATTImp' o@(IQuote fc t) = f o $ IQuote fc <$> mapATTImp' t

+
  980 |   mapATTImp' o@(IQuoteName fc n) = f o $ pure $ IQuoteName fc n

+
  981 |   mapATTImp' o@(IQuoteDecl fc xs) = f o $ IQuoteDecl fc <$> assert_total (traverse mapMDecl xs)

+
  982 |   mapATTImp' o@(IUnquote fc t) = f o $ IUnquote fc <$> mapATTImp' t

+
  983 |   mapATTImp' o@(IPrimVal fc c) = f o $ pure $ IPrimVal fc c

+
  984 |   mapATTImp' o@(IType fc) = f o $ pure $ IType fc

+
  985 |   mapATTImp' o@(IHole fc str) = f o $ pure $ IHole fc str

+
  986 |   mapATTImp' o@(Implicit fc bindIfUnsolved) = f o $ pure $ Implicit fc bindIfUnsolved

+
  987 |   mapATTImp' o@(IWithUnambigNames fc xs t) = f o $ IWithUnambigNames fc xs <$> mapATTImp' t

+
  988 | 

+
  989 | public export %inline

+
  990 | mapATTImp : Monad m => (m TTImp -> m TTImp) -> TTImp -> m TTImp

+
  991 | mapATTImp = mapATTImp' . const

+
  992 | 

+
  993 | public export %inline

+
  994 | mapMTTImp' : Monad m => ((original, mapped : TTImp) -> m TTImp) -> TTImp -> m TTImp

+
  995 | mapMTTImp' = mapATTImp' . (=<<) .: apply

+
  996 | 

+
  997 | public export %inline

+
  998 | mapMTTImp : Monad m => (TTImp -> m TTImp) -> TTImp -> m TTImp

+
  999 | mapMTTImp = mapATTImp . (=<<)

+
 1000 | 

 
 
 
diff --git a/contrib/docs/Control.ANSI.CSI.html b/contrib/docs/Control.ANSI.CSI.html
index 647fded603..9a70890a05 100644
--- a/contrib/docs/Control.ANSI.CSI.html
+++ b/contrib/docs/Control.ANSI.CSI.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.ANSI.CSI(source)
Definitions
cursorUp : Nat -> String
  Moves the cursor n columns up.
  If the cursor is at the edge of the screen it has no effect.

  Totality: total
  Visibility: export
cursorUp1 : String
  Totality: total
  Visibility: export
cursorDown : Nat -> String
  Moves the cursor n columns down.
  If the cursor is at the edge of the screen it has no effect.

  Totality: total
  Visibility: export
cursorDown1 : String
  Totality: total
  Visibility: export
cursorForward : Nat -> String
  Moves the cursor n columns forward.
  If the cursor is at the edge of the screen it has no effect.

  Totality: total
  Visibility: export
cursorForward1 : String
  Totality: total
  Visibility: export
cursorBack : Nat -> String
  Moves the cursor n columns back.
  If the cursor is at the edge of the screen it has no effect.

  Totality: total
  Visibility: export
cursorBack1 : String
  Totality: total
  Visibility: export
cursorNextLine : Nat -> String
  Moves the cursor at the beginning of n lines down.
  If the cursor is at the edge of the screen it has no effect.

  Totality: total
  Visibility: export
cursorNextLine1 : String
  Totality: total
  Visibility: export
cursorPrevLine : Nat -> String
  Moves the cursor at the beginning of n lines up.
  If the cursor is at the edge of the screen it has no effect.

  Totality: total
  Visibility: export
cursorPrevLine1 : String
  Totality: total
  Visibility: export
cursorMove : Nat -> Nat -> String
  Moves the cursor at an arbitrary line and column.
  Both lines and columns start at 1.

  Totality: total
  Visibility: export
data EraseDirection : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Start : EraseDirection
  
End : EraseDirection
  
All : EraseDirection

  Hint: 
Cast EraseDirection String
eraseScreen : EraseDirection -> String
  Clears part of the screen.

  Totality: total
  Visibility: export
eraseLine : EraseDirection -> String
  Clears part of the line.

  Totality: total
  Visibility: export
scrollUp : Nat -> String
  Scrolls the whole screen up by n lines.

  Totality: total
  Visibility: export
scrollUp1 : String
  Totality: total
  Visibility: export
scrollDown : Nat -> String
  Scrolls the whole screen down by n lines.

  Totality: total
  Visibility: export
scrollDown1 : String
  Totality: total
  Visibility: export

\ No newline at end of file
+
Control.ANSI.CSI(source)
Definitions
cursorUp : Nat -> String
  Moves the cursor n columns up.
  If the cursor is at the edge of the screen it has no effect.

  Totality: total
  Visibility: export
cursorUp1 : String
  Totality: total
  Visibility: export
cursorDown : Nat -> String
  Moves the cursor n columns down.
  If the cursor is at the edge of the screen it has no effect.

  Totality: total
  Visibility: export
cursorDown1 : String
  Totality: total
  Visibility: export
cursorForward : Nat -> String
  Moves the cursor n columns forward.
  If the cursor is at the edge of the screen it has no effect.

  Totality: total
  Visibility: export
cursorForward1 : String
  Totality: total
  Visibility: export
cursorBack : Nat -> String
  Moves the cursor n columns back.
  If the cursor is at the edge of the screen it has no effect.

  Totality: total
  Visibility: export
cursorBack1 : String
  Totality: total
  Visibility: export
cursorNextLine : Nat -> String
  Moves the cursor at the beginning of n lines down.
  If the cursor is at the edge of the screen it has no effect.

  Totality: total
  Visibility: export
cursorNextLine1 : String
  Totality: total
  Visibility: export
cursorPrevLine : Nat -> String
  Moves the cursor at the beginning of n lines up.
  If the cursor is at the edge of the screen it has no effect.

  Totality: total
  Visibility: export
cursorPrevLine1 : String
  Totality: total
  Visibility: export
cursorMove : Nat -> Nat -> String
  Moves the cursor at an arbitrary line and column.
  Both lines and columns start at 1.

  Totality: total
  Visibility: export
data EraseDirection : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Start : EraseDirection
  
End : EraseDirection
  
All : EraseDirection

  Hint: 
Cast EraseDirection String
eraseScreen : EraseDirection -> String
  Clears part of the screen.

  Totality: total
  Visibility: export
eraseLine : EraseDirection -> String
  Clears part of the line.

  Totality: total
  Visibility: export
scrollUp : Nat -> String
  Scrolls the whole screen up by n lines.

  Totality: total
  Visibility: export
scrollUp1 : String
  Totality: total
  Visibility: export
scrollDown : Nat -> String
  Scrolls the whole screen down by n lines.

  Totality: total
  Visibility: export
scrollDown1 : String
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Control.ANSI.SGR.html b/contrib/docs/Control.ANSI.SGR.html
index 3c9a9451ca..949049b1f9 100644
--- a/contrib/docs/Control.ANSI.SGR.html
+++ b/contrib/docs/Control.ANSI.SGR.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.ANSI.SGR(source)
Definitions
data Color : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Black : Color
  
Red : Color
  
Green : Color
  
Yellow : Color
  
Blue : Color
  
Magenta : Color
  
Cyan : Color
  
White : Color
  
BrightBlack : Color
  
BrightRed : Color
  
BrightGreen : Color
  
BrightYellow : Color
  
BrightBlue : Color
  
BrightMagenta : Color
  
BrightCyan : Color
  
BrightWhite : Color

  Hint: 
Cast Color String
data Style : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Bold : Style
  
Faint : Style
  
NotBoldOrFaint : Style
  
Italic : Style
  
SingleUnderline : Style
  
DoubleUnderline : Style
  
NoUnderline : Style
  
Striked : Style
  
NotStriked : Style

  Hint: 
Cast Style String
  Totality: total
  Visibility: public export
  Constructors:
  
Slow : Blink
  
Rapid : Blink
  

  Hint: 
Cast Blink String
data SGR : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Reset : SGR
  
SetForeground : Color -> SGR
  
SetBackground : Color -> SGR
  
SetStyle : Style -> SGR
  
escapeSGR : List SGR -> String
  Returns the ANSI escape code equivalent to the list of operations provided.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Control.ANSI.SGR(source)
Definitions
data Color : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Black : Color
  
Red : Color
  
Green : Color
  
Yellow : Color
  
Blue : Color
  
Magenta : Color
  
Cyan : Color
  
White : Color
  
BrightBlack : Color
  
BrightRed : Color
  
BrightGreen : Color
  
BrightYellow : Color
  
BrightBlue : Color
  
BrightMagenta : Color
  
BrightCyan : Color
  
BrightWhite : Color

  Hint: 
Cast Color String
data Style : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Bold : Style
  
Faint : Style
  
NotBoldOrFaint : Style
  
Italic : Style
  
SingleUnderline : Style
  
DoubleUnderline : Style
  
NoUnderline : Style
  
Striked : Style
  
NotStriked : Style

  Hint: 
Cast Style String
  Totality: total
  Visibility: public export
  Constructors:
  
Slow : Blink
  
Rapid : Blink
  

  Hint: 
Cast Blink String
data SGR : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Reset : SGR
  
SetForeground : Color -> SGR
  
SetBackground : Color -> SGR
  
SetStyle : Style -> SGR
  
escapeSGR : List SGR -> String
  Returns the ANSI escape code equivalent to the list of operations provided.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Control.ANSI.html b/contrib/docs/Control.ANSI.html
index 724853cc35..3208ccfaa3 100644
--- a/contrib/docs/Control.ANSI.html
+++ b/contrib/docs/Control.ANSI.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.ANSI(source)
Reexports
import public Control.ANSI.CSI
import public Control.ANSI.SGR
Definitions
record DecoratedString : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkDString : List SGR -> String -> DecoratedString

  Projections:
  
.sgr : DecoratedString -> List SGR
  
.str : DecoratedString -> String

  Hint: 
Show DecoratedString
.sgr : DecoratedString -> List SGR
  Totality: total
  Visibility: public export
sgr : DecoratedString -> List SGR
  Totality: total
  Visibility: public export
.str : DecoratedString -> String
  Totality: total
  Visibility: public export
str : DecoratedString -> String
  Totality: total
  Visibility: public export
colored : Color -> String -> DecoratedString
  Totality: total
  Visibility: export
background : Color -> String -> DecoratedString
  Totality: total
  Visibility: export
bolden : String -> DecoratedString
  Totality: total
  Visibility: export
italicize : String -> DecoratedString
  Totality: total
  Visibility: export
underline : String -> DecoratedString
  Totality: total
  Visibility: export

\ No newline at end of file
+
Control.ANSI(source)
Reexports
import public Control.ANSI.CSI
import public Control.ANSI.SGR
Definitions
record DecoratedString : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkDString : List SGR -> String -> DecoratedString

  Projections:
  
.sgr : DecoratedString -> List SGR
  
.str : DecoratedString -> String

  Hint: 
Show DecoratedString
.sgr : DecoratedString -> List SGR
  Totality: total
  Visibility: public export
sgr : DecoratedString -> List SGR
  Totality: total
  Visibility: public export
.str : DecoratedString -> String
  Totality: total
  Visibility: public export
str : DecoratedString -> String
  Totality: total
  Visibility: public export
colored : Color -> String -> DecoratedString
  Totality: total
  Visibility: export
background : Color -> String -> DecoratedString
  Totality: total
  Visibility: export
bolden : String -> DecoratedString
  Totality: total
  Visibility: export
italicize : String -> DecoratedString
  Totality: total
  Visibility: export
underline : String -> DecoratedString
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Control.Algebra.Implementations.html b/contrib/docs/Control.Algebra.Implementations.html
index 996df3fb11..10b3030e96 100644
--- a/contrib/docs/Control.Algebra.Implementations.html
+++ b/contrib/docs/Control.Algebra.Implementations.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Algebra.Implementations(source)
Definitions

\ No newline at end of file
+
Control.Algebra.Implementations(source)
Definitions

\ No newline at end of file
diff --git a/contrib/docs/Control.Algebra.Laws.html b/contrib/docs/Control.Algebra.Laws.html
index e3cd8d6eaf..e2c5a345b8 100644
--- a/contrib/docs/Control.Algebra.Laws.html
+++ b/contrib/docs/Control.Algebra.Laws.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Algebra.Laws(source)
Definitions
uniqueInverse : {auto {conArg:2029} : MonoidV ty} -> (x : ty) -> (y : ty) -> (z : ty) -> y <+> x = neutral -> x <+> z = neutral -> y = z
  Inverses are unique.

  Totality: total
  Visibility: public export
selfSquareId : {auto {conArg:2147} : Group ty} -> (x : ty) -> x <+> x = x -> x = neutral
  Only identity is self-squaring.

  Totality: total
  Visibility: public export
inverseCommute : {auto {conArg:2247} : Group ty} -> (x : ty) -> (y : ty) -> y <+> x = neutral -> x <+> y = neutral
  Inverse elements commute.

  Totality: total
  Visibility: public export
groupInverseIsInverseL : {auto {conArg:2417} : Group ty} -> (x : ty) -> x <+> inverse x = neutral
  Every element has a right inverse.

  Totality: total
  Visibility: public export
inverseSquaredIsIdentity : {auto {conArg:2459} : Group ty} -> (x : ty) -> inverse (inverse x) = x
  -(-x) = x

  Totality: total
  Visibility: public export
squareIdCommutative : {auto {conArg:2500} : Group ty} -> (x : ty) -> (y : ty) -> ((a : ty) -> a <+> a = neutral) -> x <+> y = y <+> x
  If every square in a group is identity, the group is commutative.

  Totality: total
  Visibility: public export
inverseNeutralIsNeutral : {auto {conArg:2701} : Group ty} -> inverse neutral = neutral
  -0 = 0

  Totality: total
  Visibility: public export
cancelLeft : {auto {conArg:2778} : Group ty} -> (x : ty) -> (y : ty) -> (z : ty) -> x <+> y = x <+> z -> y = z
  y = z if x + y = x + z

  Totality: total
  Visibility: public export
cancelRight : {auto {conArg:2923} : Group ty} -> (x : ty) -> (y : ty) -> (z : ty) -> y <+> x = z <+> x -> y = z
  y = z if y + x = z + x.

  Totality: total
  Visibility: public export
neutralProductInverseR : {auto {conArg:3068} : Group ty} -> (a : ty) -> (b : ty) -> a <+> b = neutral -> a = inverse b
  ab = 0 -> a = b^-1

  Totality: total
  Visibility: public export
neutralProductInverseL : {auto {conArg:3129} : Group ty} -> (a : ty) -> (b : ty) -> a <+> b = neutral -> inverse a = b
  ab = 0 -> a^-1 = b

  Totality: total
  Visibility: public export
latinSquareProperty : {auto {conArg:3190} : Group ty} -> (a : ty) -> (b : ty) -> ((x : ty ** a <+> x = b), (y : ty ** y <+> a = b))
  For any a and b, ax = b and ya = b have solutions.

  Totality: total
  Visibility: public export
uniqueSolutionR : {auto {conArg:3341} : Group ty} -> (a : ty) -> (b : ty) -> (x : ty) -> (y : ty) -> a <+> x = b -> a <+> y = b -> x = y
  For any a, b, x, the solution to ax = b is unique.

  Totality: total
  Visibility: public export
uniqueSolutionL : {auto {conArg:3413} : Group t} -> (a : t) -> (b : t) -> (x : t) -> (y : t) -> x <+> a = b -> y <+> a = b -> x = y
  For any a, b, y, the solution to ya = b is unique.

  Totality: total
  Visibility: public export
homoNeutral : {auto {conArg:3485} : GroupHomomorphism a b} -> to neutral = neutral
  Homomorphism preserves neutral.

  Totality: total
  Visibility: public export
homoInverse : {auto {conArg:3596} : GroupHomomorphism a b} -> (x : a) -> the b (to (inverse x)) = the b (inverse (to x))
  Homomorphism preserves inverses.

  Totality: total
  Visibility: public export
multNeutralAbsorbingL : {auto {conArg:3717} : Ring ty} -> (r : ty) -> neutral <.> r = neutral
  0x = x

  Totality: total
  Visibility: public export
multNeutralAbsorbingR : {auto {conArg:3980} : Ring ty} -> (l : ty) -> l <.> neutral = neutral
  x0 = 0

  Totality: total
  Visibility: public export
multInverseInversesL : {auto {conArg:4239} : Ring ty} -> (l : ty) -> (r : ty) -> inverse l <.> r = inverse (l <.> r)
  (-x)y = -(xy)

  Totality: total
  Visibility: public export
multInverseInversesR : {auto {conArg:4410} : Ring ty} -> (l : ty) -> (r : ty) -> l <.> inverse r = inverse (l <.> r)
  x(-y) = -(xy)

  Totality: total
  Visibility: public export
multNegativeByNegativeIsPositive : {auto {conArg:4577} : Ring ty} -> (l : ty) -> (r : ty) -> inverse l <.> inverse r = l <.> r
  (-x)(-y) = xy

  Totality: total
  Visibility: public export
inverseOfUnityR : {auto {conArg:4659} : RingWithUnity ty} -> (x : ty) -> inverse unity <.> x = inverse x
  (-1)x = -x

  Totality: total
  Visibility: public export
inverseOfUnityL : {auto {conArg:4720} : RingWithUnity ty} -> (x : ty) -> x <.> inverse unity = inverse x
  x(-1) = -x

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Control.Algebra.Laws(source)
Definitions
uniqueInverse : {auto {conArg:2029} : MonoidV ty} -> (x : ty) -> (y : ty) -> (z : ty) -> y <+> x = neutral -> x <+> z = neutral -> y = z
  Inverses are unique.

  Totality: total
  Visibility: public export
selfSquareId : {auto {conArg:2147} : Group ty} -> (x : ty) -> x <+> x = x -> x = neutral
  Only identity is self-squaring.

  Totality: total
  Visibility: public export
inverseCommute : {auto {conArg:2247} : Group ty} -> (x : ty) -> (y : ty) -> y <+> x = neutral -> x <+> y = neutral
  Inverse elements commute.

  Totality: total
  Visibility: public export
groupInverseIsInverseL : {auto {conArg:2417} : Group ty} -> (x : ty) -> x <+> inverse x = neutral
  Every element has a right inverse.

  Totality: total
  Visibility: public export
inverseSquaredIsIdentity : {auto {conArg:2459} : Group ty} -> (x : ty) -> inverse (inverse x) = x
  -(-x) = x

  Totality: total
  Visibility: public export
squareIdCommutative : {auto {conArg:2500} : Group ty} -> (x : ty) -> (y : ty) -> ((a : ty) -> a <+> a = neutral) -> x <+> y = y <+> x
  If every square in a group is identity, the group is commutative.

  Totality: total
  Visibility: public export
inverseNeutralIsNeutral : {auto {conArg:2701} : Group ty} -> inverse neutral = neutral
  -0 = 0

  Totality: total
  Visibility: public export
cancelLeft : {auto {conArg:2778} : Group ty} -> (x : ty) -> (y : ty) -> (z : ty) -> x <+> y = x <+> z -> y = z
  y = z if x + y = x + z

  Totality: total
  Visibility: public export
cancelRight : {auto {conArg:2923} : Group ty} -> (x : ty) -> (y : ty) -> (z : ty) -> y <+> x = z <+> x -> y = z
  y = z if y + x = z + x.

  Totality: total
  Visibility: public export
neutralProductInverseR : {auto {conArg:3068} : Group ty} -> (a : ty) -> (b : ty) -> a <+> b = neutral -> a = inverse b
  ab = 0 -> a = b^-1

  Totality: total
  Visibility: public export
neutralProductInverseL : {auto {conArg:3129} : Group ty} -> (a : ty) -> (b : ty) -> a <+> b = neutral -> inverse a = b
  ab = 0 -> a^-1 = b

  Totality: total
  Visibility: public export
latinSquareProperty : {auto {conArg:3190} : Group ty} -> (a : ty) -> (b : ty) -> ((x : ty ** a <+> x = b), (y : ty ** y <+> a = b))
  For any a and b, ax = b and ya = b have solutions.

  Totality: total
  Visibility: public export
uniqueSolutionR : {auto {conArg:3341} : Group ty} -> (a : ty) -> (b : ty) -> (x : ty) -> (y : ty) -> a <+> x = b -> a <+> y = b -> x = y
  For any a, b, x, the solution to ax = b is unique.

  Totality: total
  Visibility: public export
uniqueSolutionL : {auto {conArg:3413} : Group t} -> (a : t) -> (b : t) -> (x : t) -> (y : t) -> x <+> a = b -> y <+> a = b -> x = y
  For any a, b, y, the solution to ya = b is unique.

  Totality: total
  Visibility: public export
homoNeutral : {auto {conArg:3485} : GroupHomomorphism a b} -> to neutral = neutral
  Homomorphism preserves neutral.

  Totality: total
  Visibility: public export
homoInverse : {auto {conArg:3596} : GroupHomomorphism a b} -> (x : a) -> the b (to (inverse x)) = the b (inverse (to x))
  Homomorphism preserves inverses.

  Totality: total
  Visibility: public export
multNeutralAbsorbingL : {auto {conArg:3717} : Ring ty} -> (r : ty) -> neutral <.> r = neutral
  0x = x

  Totality: total
  Visibility: public export
multNeutralAbsorbingR : {auto {conArg:3980} : Ring ty} -> (l : ty) -> l <.> neutral = neutral
  x0 = 0

  Totality: total
  Visibility: public export
multInverseInversesL : {auto {conArg:4239} : Ring ty} -> (l : ty) -> (r : ty) -> inverse l <.> r = inverse (l <.> r)
  (-x)y = -(xy)

  Totality: total
  Visibility: public export
multInverseInversesR : {auto {conArg:4410} : Ring ty} -> (l : ty) -> (r : ty) -> l <.> inverse r = inverse (l <.> r)
  x(-y) = -(xy)

  Totality: total
  Visibility: public export
multNegativeByNegativeIsPositive : {auto {conArg:4577} : Ring ty} -> (l : ty) -> (r : ty) -> inverse l <.> inverse r = l <.> r
  (-x)(-y) = xy

  Totality: total
  Visibility: public export
inverseOfUnityR : {auto {conArg:4659} : RingWithUnity ty} -> (x : ty) -> inverse unity <.> x = inverse x
  (-1)x = -x

  Totality: total
  Visibility: public export
inverseOfUnityL : {auto {conArg:4720} : RingWithUnity ty} -> (x : ty) -> x <.> inverse unity = inverse x
  x(-1) = -x

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Control.Algebra.html b/contrib/docs/Control.Algebra.html
index 4d256c8e5b..40035a6834 100644
--- a/contrib/docs/Control.Algebra.html
+++ b/contrib/docs/Control.Algebra.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Algebra(source)
Definitions
interface SemigroupV : Type -> Type
  Parameters: ty
Constraints: Semigroup ty
Methods:
  
semigroupOpIsAssociative : (l : ty) -> (c : ty) -> (r : ty) -> l <+> (c <+> r) = (l <+> c) <+> r

Implementation: 
SemigroupV ty => SemigroupV (Identity ty)
semigroupOpIsAssociative : {auto __con : SemigroupV ty} -> (l : ty) -> (c : ty) -> (r : ty) -> l <+> (c <+> r) = (l <+> c) <+> r
  Visibility: public export
interface MonoidV : Type -> Type
  Parameters: ty
Constraints: Monoid ty, SemigroupV ty
Methods:
  
monoidNeutralIsNeutralL : (l : ty) -> l <+> neutral = l
  
monoidNeutralIsNeutralR : (r : ty) -> neutral <+> r = r

Implementation: 
MonoidV ty => MonoidV (Identity ty)
monoidNeutralIsNeutralL : {auto __con : MonoidV ty} -> (l : ty) -> l <+> neutral = l
  Visibility: public export
monoidNeutralIsNeutralR : {auto __con : MonoidV ty} -> (r : ty) -> neutral <+> r = r
  Visibility: public export
interface Group : Type -> Type
  Sets equipped with a single binary operation that is associative,
  along with a neutral element for that binary operation and
  inverses for all elements. Satisfies the following laws:
  
  + Associativity of `<+>`:
      forall a b c, a <+> (b <+> c) == (a <+> b) <+> c
  + Neutral for `<+>`:
      forall a,     a <+> neutral   == a
      forall a,     neutral <+> a   == a
  + Inverse for `<+>`:
      forall a,     a <+> inverse a == neutral
      forall a,     inverse a <+> a == neutral

  Parameters: ty
Constraints: MonoidV ty
Methods:
  
inverse : ty -> ty
  
groupInverseIsInverseR : (r : ty) -> inverse r <+> r = neutral

Implementations:
  
AbelianGroup ty -> Group ty
  
GroupHomomorphism a b -> Group a
  
GroupHomomorphism a b -> Group b
  
Ring ty -> Group ty
inverse : Group ty => ty -> ty
  Visibility: public export
groupInverseIsInverseR : {auto __con : Group ty} -> (r : ty) -> inverse r <+> r = neutral
  Visibility: public export
interface AbelianGroup : Type -> Type
  Sets equipped with a single binary operation that is associative
  and commutative, along with a neutral element for that binary
  operation and inverses for all elements. Satisfies the following
  laws:
  
  + Associativity of `<+>`:
      forall a b c, a <+> (b <+> c) == (a <+> b) <+> c
  + Commutativity of `<+>`:
      forall a b,   a <+> b         == b <+> a
  + Neutral for `<+>`:
      forall a,     a <+> neutral   == a
      forall a,     neutral <+> a   == a
  + Inverse for `<+>`:
      forall a,     a <+> inverse a == neutral
      forall a,     inverse a <+> a == neutral

  Parameters: ty
Constraints: Group ty
Methods:
  
groupOpIsCommutative : (l : ty) -> (r : ty) -> l <+> r = r <+> l
groupOpIsCommutative : {auto __con : AbelianGroup ty} -> (l : ty) -> (r : ty) -> l <+> r = r <+> l
  Visibility: public export
interface GroupHomomorphism : Type -> Type -> Type
  A homomorphism is a mapping that preserves group structure.

  Parameters: a, b
Constraints: Group a, Group b
Methods:
  
to : a -> b
  
toGroup : (x : a) -> (y : a) -> to (x <+> y) = to x <+> to y
to : GroupHomomorphism a b => a -> b
  Visibility: public export
toGroup : {auto __con : GroupHomomorphism a b} -> (x : a) -> (y : a) -> to (x <+> y) = to x <+> to y
  Visibility: public export
interface Ring : Type -> Type
  Sets equipped with two binary operations, one associative and
  commutative supplied with a neutral element, and the other
  associative, with distributivity laws relating the two operations.
  Satisfies the following laws:
  
  + Associativity of `<+>`:
      forall a b c, a <+> (b <+> c) == (a <+> b) <+> c
  + Commutativity of `<+>`:
      forall a b,   a <+> b         == b <+> a
  + Neutral for `<+>`:
      forall a,     a <+> neutral   == a
      forall a,     neutral <+> a   == a
  + Inverse for `<+>`:
      forall a,     a <+> inverse a == neutral
      forall a,     inverse a <+> a == neutral
  + Associativity of `<.>`:
      forall a b c, a <.> (b <.> c) == (a <.> b) <.> c
  + Distributivity of `<.>` and `<+>`:
      forall a b c, a <.> (b <+> c) == (a <.> b) <+> (a <.> c)
      forall a b c, (a <+> b) <.> c == (a <.> c) <+> (b <.> c)

  Parameters: ty
Constraints: Group ty
Methods:
  
(<.>) : ty -> ty -> ty
  Fixity Declaration: infixl operator, level 7
  
ringOpIsAssociative : (l : ty) -> (c : ty) -> (r : ty) -> l <.> (c <.> r) = (l <.> c) <.> r
  
ringOpIsDistributiveL : (l : ty) -> (c : ty) -> (r : ty) -> l <.> (c <+> r) = (l <.> c) <+> (l <.> r)
  
ringOpIsDistributiveR : (l : ty) -> (c : ty) -> (r : ty) -> (l <+> c) <.> r = (l <.> r) <+> (c <.> r)

Implementation: 
RingWithUnity ty -> Ring ty
(<.>) : Ring ty => ty -> ty -> ty
  Visibility: public export
  Fixity Declaration: infixl operator, level 7
ringOpIsAssociative : {auto __con : Ring ty} -> (l : ty) -> (c : ty) -> (r : ty) -> l <.> (c <.> r) = (l <.> c) <.> r
  Visibility: public export
ringOpIsDistributiveL : {auto __con : Ring ty} -> (l : ty) -> (c : ty) -> (r : ty) -> l <.> (c <+> r) = (l <.> c) <+> (l <.> r)
  Visibility: public export
ringOpIsDistributiveR : {auto __con : Ring ty} -> (l : ty) -> (c : ty) -> (r : ty) -> (l <+> c) <.> r = (l <.> r) <+> (c <.> r)
  Visibility: public export
interface RingWithUnity : Type -> Type
  Sets equipped with two binary operations, one associative and
  commutative supplied with a neutral element, and the other
  associative supplied with a neutral element, with distributivity
  laws relating the two operations. Satisfies the following laws:
  
  +  Associativity of `<+>`:
      forall a b c, a <+> (b <+> c) == (a <+> b) <+> c
  + Commutativity of `<+>`:
      forall a b,   a <+> b         == b <+> a
  + Neutral for `<+>`:
      forall a,     a <+> neutral   == a
      forall a,     neutral <+> a   == a
  + Inverse for `<+>`:
      forall a,     a <+> inverse a == neutral
      forall a,     inverse a <+> a == neutral
  + Associativity of `<.>`:
      forall a b c, a <.> (b <.> c) == (a <.> b) <.> c
  + Neutral for `<.>`:
      forall a,     a <.> unity     == a
      forall a,     unity <.> a     == a
  + Distributivity of `<.>` and `<+>`:
      forall a b c, a <.> (b <+> c) == (a <.> b) <+> (a <.> c)
      forall a b c, (a <+> b) <.> c == (a <.> c) <+> (b <.> c)

  Parameters: ty
Constraints: Ring ty
Methods:
  
unity : ty
  
unityIsRingIdL : (l : ty) -> l <.> unity = l
  
unityIsRingIdR : (r : ty) -> unity <.> r = r

Implementation: 
Field ty -> RingWithUnity ty
unity : RingWithUnity ty => ty
  Visibility: public export
unityIsRingIdL : {auto __con : RingWithUnity ty} -> (l : ty) -> l <.> unity = l
  Visibility: public export
unityIsRingIdR : {auto __con : RingWithUnity ty} -> (r : ty) -> unity <.> r = r
  Visibility: public export
interface Field : Type -> Type
  Sets equipped with two binary operations – both associative,
  commutative and possessing a neutral element – and distributivity
  laws relating the two operations. All elements except the additive
  identity should have a multiplicative inverse. Should (but may
  not) satisfy the following laws:
  
  + Associativity of `<+>`:
      forall a b c, a <+> (b <+> c) == (a <+> b) <+> c
  + Commutativity of `<+>`:
      forall a b,   a <+> b         == b <+> a
  + Neutral for `<+>`:
      forall a,     a <+> neutral   == a
      forall a,     neutral <+> a   == a
  + Inverse for `<+>`:
      forall a,     a <+> inverse a == neutral
      forall a,     inverse a <+> a == neutral
  + Associativity of `<.>`:
      forall a b c, a <.> (b <.> c) == (a <.> b) <.> c
  + Unity for `<.>`:
      forall a,     a <.> unity     == a
      forall a,     unity <.> a     == a
  + InverseM of `<.>`, except for neutral
      forall a /= neutral,  a <.> inverseM a == unity
      forall a /= neutral,  inverseM a <.> a == unity
  + Distributivity of `<.>` and `<+>`:
      forall a b c, a <.> (b <+> c) == (a <.> b) <+> (a <.> c)
      forall a b c, (a <+> b) <.> c == (a <.> c) <+> (b <.> c)

  Parameters: ty
Constraints: RingWithUnity ty
Methods:
  
inverseM : (x : ty) -> Not (x = neutral) -> ty
inverseM : {auto __con : Field ty} -> (x : ty) -> Not (x = neutral) -> ty
  Visibility: public export

\ No newline at end of file
+
Control.Algebra(source)
Definitions
interface SemigroupV : Type -> Type
  Parameters: ty
Constraints: Semigroup ty
Methods:
  
semigroupOpIsAssociative : (l : ty) -> (c : ty) -> (r : ty) -> l <+> (c <+> r) = (l <+> c) <+> r

Implementation: 
SemigroupV ty => SemigroupV (Identity ty)
semigroupOpIsAssociative : {auto __con : SemigroupV ty} -> (l : ty) -> (c : ty) -> (r : ty) -> l <+> (c <+> r) = (l <+> c) <+> r
  Visibility: public export
interface MonoidV : Type -> Type
  Parameters: ty
Constraints: Monoid ty, SemigroupV ty
Methods:
  
monoidNeutralIsNeutralL : (l : ty) -> l <+> neutral = l
  
monoidNeutralIsNeutralR : (r : ty) -> neutral <+> r = r

Implementation: 
MonoidV ty => MonoidV (Identity ty)
monoidNeutralIsNeutralL : {auto __con : MonoidV ty} -> (l : ty) -> l <+> neutral = l
  Visibility: public export
monoidNeutralIsNeutralR : {auto __con : MonoidV ty} -> (r : ty) -> neutral <+> r = r
  Visibility: public export
interface Group : Type -> Type
  Sets equipped with a single binary operation that is associative,
  along with a neutral element for that binary operation and
  inverses for all elements. Satisfies the following laws:
  
  + Associativity of `<+>`:
      forall a b c, a <+> (b <+> c) == (a <+> b) <+> c
  + Neutral for `<+>`:
      forall a,     a <+> neutral   == a
      forall a,     neutral <+> a   == a
  + Inverse for `<+>`:
      forall a,     a <+> inverse a == neutral
      forall a,     inverse a <+> a == neutral

  Parameters: ty
Constraints: MonoidV ty
Methods:
  
inverse : ty -> ty
  
groupInverseIsInverseR : (r : ty) -> inverse r <+> r = neutral

Implementations:
  
AbelianGroup ty -> Group ty
  
GroupHomomorphism a b -> Group a
  
GroupHomomorphism a b -> Group b
  
Ring ty -> Group ty
inverse : Group ty => ty -> ty
  Visibility: public export
groupInverseIsInverseR : {auto __con : Group ty} -> (r : ty) -> inverse r <+> r = neutral
  Visibility: public export
interface AbelianGroup : Type -> Type
  Sets equipped with a single binary operation that is associative
  and commutative, along with a neutral element for that binary
  operation and inverses for all elements. Satisfies the following
  laws:
  
  + Associativity of `<+>`:
      forall a b c, a <+> (b <+> c) == (a <+> b) <+> c
  + Commutativity of `<+>`:
      forall a b,   a <+> b         == b <+> a
  + Neutral for `<+>`:
      forall a,     a <+> neutral   == a
      forall a,     neutral <+> a   == a
  + Inverse for `<+>`:
      forall a,     a <+> inverse a == neutral
      forall a,     inverse a <+> a == neutral

  Parameters: ty
Constraints: Group ty
Methods:
  
groupOpIsCommutative : (l : ty) -> (r : ty) -> l <+> r = r <+> l
groupOpIsCommutative : {auto __con : AbelianGroup ty} -> (l : ty) -> (r : ty) -> l <+> r = r <+> l
  Visibility: public export
interface GroupHomomorphism : Type -> Type -> Type
  A homomorphism is a mapping that preserves group structure.

  Parameters: a, b
Constraints: Group a, Group b
Methods:
  
to : a -> b
  
toGroup : (x : a) -> (y : a) -> to (x <+> y) = to x <+> to y
to : GroupHomomorphism a b => a -> b
  Visibility: public export
toGroup : {auto __con : GroupHomomorphism a b} -> (x : a) -> (y : a) -> to (x <+> y) = to x <+> to y
  Visibility: public export
interface Ring : Type -> Type
  Sets equipped with two binary operations, one associative and
  commutative supplied with a neutral element, and the other
  associative, with distributivity laws relating the two operations.
  Satisfies the following laws:
  
  + Associativity of `<+>`:
      forall a b c, a <+> (b <+> c) == (a <+> b) <+> c
  + Commutativity of `<+>`:
      forall a b,   a <+> b         == b <+> a
  + Neutral for `<+>`:
      forall a,     a <+> neutral   == a
      forall a,     neutral <+> a   == a
  + Inverse for `<+>`:
      forall a,     a <+> inverse a == neutral
      forall a,     inverse a <+> a == neutral
  + Associativity of `<.>`:
      forall a b c, a <.> (b <.> c) == (a <.> b) <.> c
  + Distributivity of `<.>` and `<+>`:
      forall a b c, a <.> (b <+> c) == (a <.> b) <+> (a <.> c)
      forall a b c, (a <+> b) <.> c == (a <.> c) <+> (b <.> c)

  Parameters: ty
Constraints: Group ty
Methods:
  
(<.>) : ty -> ty -> ty
  Fixity Declaration: infixl operator, level 7
  
ringOpIsAssociative : (l : ty) -> (c : ty) -> (r : ty) -> l <.> (c <.> r) = (l <.> c) <.> r
  
ringOpIsDistributiveL : (l : ty) -> (c : ty) -> (r : ty) -> l <.> (c <+> r) = (l <.> c) <+> (l <.> r)
  
ringOpIsDistributiveR : (l : ty) -> (c : ty) -> (r : ty) -> (l <+> c) <.> r = (l <.> r) <+> (c <.> r)

Implementation: 
RingWithUnity ty -> Ring ty
(<.>) : Ring ty => ty -> ty -> ty
  Visibility: public export
  Fixity Declaration: infixl operator, level 7
ringOpIsAssociative : {auto __con : Ring ty} -> (l : ty) -> (c : ty) -> (r : ty) -> l <.> (c <.> r) = (l <.> c) <.> r
  Visibility: public export
ringOpIsDistributiveL : {auto __con : Ring ty} -> (l : ty) -> (c : ty) -> (r : ty) -> l <.> (c <+> r) = (l <.> c) <+> (l <.> r)
  Visibility: public export
ringOpIsDistributiveR : {auto __con : Ring ty} -> (l : ty) -> (c : ty) -> (r : ty) -> (l <+> c) <.> r = (l <.> r) <+> (c <.> r)
  Visibility: public export
interface RingWithUnity : Type -> Type
  Sets equipped with two binary operations, one associative and
  commutative supplied with a neutral element, and the other
  associative supplied with a neutral element, with distributivity
  laws relating the two operations. Satisfies the following laws:
  
  +  Associativity of `<+>`:
      forall a b c, a <+> (b <+> c) == (a <+> b) <+> c
  + Commutativity of `<+>`:
      forall a b,   a <+> b         == b <+> a
  + Neutral for `<+>`:
      forall a,     a <+> neutral   == a
      forall a,     neutral <+> a   == a
  + Inverse for `<+>`:
      forall a,     a <+> inverse a == neutral
      forall a,     inverse a <+> a == neutral
  + Associativity of `<.>`:
      forall a b c, a <.> (b <.> c) == (a <.> b) <.> c
  + Neutral for `<.>`:
      forall a,     a <.> unity     == a
      forall a,     unity <.> a     == a
  + Distributivity of `<.>` and `<+>`:
      forall a b c, a <.> (b <+> c) == (a <.> b) <+> (a <.> c)
      forall a b c, (a <+> b) <.> c == (a <.> c) <+> (b <.> c)

  Parameters: ty
Constraints: Ring ty
Methods:
  
unity : ty
  
unityIsRingIdL : (l : ty) -> l <.> unity = l
  
unityIsRingIdR : (r : ty) -> unity <.> r = r

Implementation: 
Field ty -> RingWithUnity ty
unity : RingWithUnity ty => ty
  Visibility: public export
unityIsRingIdL : {auto __con : RingWithUnity ty} -> (l : ty) -> l <.> unity = l
  Visibility: public export
unityIsRingIdR : {auto __con : RingWithUnity ty} -> (r : ty) -> unity <.> r = r
  Visibility: public export
interface Field : Type -> Type
  Sets equipped with two binary operations – both associative,
  commutative and possessing a neutral element – and distributivity
  laws relating the two operations. All elements except the additive
  identity should have a multiplicative inverse. Should (but may
  not) satisfy the following laws:
  
  + Associativity of `<+>`:
      forall a b c, a <+> (b <+> c) == (a <+> b) <+> c
  + Commutativity of `<+>`:
      forall a b,   a <+> b         == b <+> a
  + Neutral for `<+>`:
      forall a,     a <+> neutral   == a
      forall a,     neutral <+> a   == a
  + Inverse for `<+>`:
      forall a,     a <+> inverse a == neutral
      forall a,     inverse a <+> a == neutral
  + Associativity of `<.>`:
      forall a b c, a <.> (b <.> c) == (a <.> b) <.> c
  + Unity for `<.>`:
      forall a,     a <.> unity     == a
      forall a,     unity <.> a     == a
  + InverseM of `<.>`, except for neutral
      forall a /= neutral,  a <.> inverseM a == unity
      forall a /= neutral,  inverseM a <.> a == unity
  + Distributivity of `<.>` and `<+>`:
      forall a b c, a <.> (b <+> c) == (a <.> b) <+> (a <.> c)
      forall a b c, (a <+> b) <.> c == (a <.> c) <+> (b <.> c)

  Parameters: ty
Constraints: RingWithUnity ty
Methods:
  
inverseM : (x : ty) -> Not (x = neutral) -> ty
inverseM : {auto __con : Field ty} -> (x : ty) -> Not (x = neutral) -> ty
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Control.Arrow.html b/contrib/docs/Control.Arrow.html
index f213ef6205..3c40279157 100644
--- a/contrib/docs/Control.Arrow.html
+++ b/contrib/docs/Control.Arrow.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Arrow(source)
Definitions
interface Arrow : (Type -> Type -> Type) -> Type
  Parameters: arr
Constraints: Category arr
Methods:
  
arrow : (a -> b) -> arr a b
  Converts a function from input to output into a arrow computation.
  
first : arr a b -> arr (a, c) (b, c)
  Converts an arrow from `a` to `b` into an arrow on pairs, that applies
  its argument to the first component and leaves the second component
  untouched, thus saving its value across a computation.
  
second : arr a b -> arr (c, a) (c, b)
  Converts an arrow from `a` to `b` into an arrow on pairs, that applies
  its argument to the second component and leaves the first component
  untouched, thus saving its value across a computation.
  
(***) : arr a b -> arr a' b' -> arr (a, a') (b, b')
  A combinator which processes both components of a pair.

  Fixity Declaration: infixr operator, level 3
  
(&&&) : arr a b -> arr a b' -> arr a (b, b')
  A combinator which builds a pair from the results of two arrows.

  Fixity Declaration: infixr operator, level 3

Implementations:
  
Arrow Morphism
  
Monad m => Arrow (Kleislimorphism m)
arrow : Arrow arr => (a -> b) -> arr a b
  Converts a function from input to output into a arrow computation.

  Visibility: public export
first : Arrow arr => arr a b -> arr (a, c) (b, c)
  Converts an arrow from `a` to `b` into an arrow on pairs, that applies
  its argument to the first component and leaves the second component
  untouched, thus saving its value across a computation.

  Visibility: public export
second : Arrow arr => arr a b -> arr (c, a) (c, b)
  Converts an arrow from `a` to `b` into an arrow on pairs, that applies
  its argument to the second component and leaves the first component
  untouched, thus saving its value across a computation.

  Visibility: public export
(***) : Arrow arr => arr a b -> arr a' b' -> arr (a, a') (b, b')
  A combinator which processes both components of a pair.

  Visibility: public export
  Fixity Declaration: infixr operator, level 3
(&&&) : Arrow arr => arr a b -> arr a b' -> arr a (b, b')
  A combinator which builds a pair from the results of two arrows.

  Visibility: public export
  Fixity Declaration: infixr operator, level 3
interface ArrowZero : (Type -> Type -> Type) -> Type
  Parameters: arr
Constraints: Arrow arr
Methods:
  
zeroArrow : arr a b

Implementation: 
ArrowPlus arr -> ArrowZero arr
zeroArrow : ArrowZero arr => arr a b
  Visibility: public export
interface ArrowPlus : (Type -> Type -> Type) -> Type
  Parameters: arr
Constraints: ArrowZero arr
Methods:
  
(<++>) : arr a b -> arr a b -> arr a b
  Fixity Declaration: infixr operator, level 5
(<++>) : ArrowPlus arr => arr a b -> arr a b -> arr a b
  Visibility: public export
  Fixity Declaration: infixr operator, level 5
interface ArrowChoice : (Type -> Type -> Type) -> Type
  Parameters: arr
Constraints: Arrow arr
Methods:
  
left : arr a b -> arr (Either a c) (Either b c)
  
right : arr a b -> arr (Either c a) (Either c b)
  
(+++) : arr a b -> arr c d -> arr (Either a c) (Either b d)
  Fixity Declaration: infixr operator, level 2
  
(\|/) : arr a b -> arr c b -> arr (Either a c) b
  Fixity Declaration: infixr operator, level 2

Implementation: 
Monad m => ArrowChoice (Kleislimorphism m)
left : ArrowChoice arr => arr a b -> arr (Either a c) (Either b c)
  Visibility: public export
right : ArrowChoice arr => arr a b -> arr (Either c a) (Either c b)
  Visibility: public export
(+++) : ArrowChoice arr => arr a b -> arr c d -> arr (Either a c) (Either b d)
  Visibility: public export
  Fixity Declaration: infixr operator, level 2
(\|/) : ArrowChoice arr => arr a b -> arr c b -> arr (Either a c) b
  Visibility: public export
  Fixity Declaration: infixr operator, level 2
interface ArrowApply : (Type -> Type -> Type) -> Type
  Parameters: arr
Constraints: Arrow arr
Methods:
  
app : arr (arr a b, a) b

Implementation: 
Monad m => ArrowApply (Kleislimorphism m)
app : ArrowApply arr => arr (arr a b, a) b
  Visibility: public export
data ArrowMonad : (Type -> Type -> Type) -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkArrowMonad : arr () a -> ArrowMonad arr a

  Hints:
  
Arrow a => Applicative (ArrowMonad a)
  
Arrow a => Functor (ArrowMonad a)
  
ArrowApply a => Monad (ArrowMonad a)
runArrowMonad : ArrowMonad arr a -> arr () a
  Visibility: public export
interface ArrowLoop : (Type -> Type -> Type) -> Type
  Parameters: arr
Constraints: Arrow arr
Methods:
  
loop : arr (a, c) (b, c) -> arr a b
loop : ArrowLoop arr => arr (a, c) (b, c) -> arr a b
  Visibility: public export
liftA2 : Arrow arr => (a -> b -> c) -> arr d a -> arr d b -> arr d c
  Applying a binary operator to the results of two arrow computations.

  Visibility: public export

\ No newline at end of file
+
Control.Arrow(source)
Definitions
interface Arrow : (Type -> Type -> Type) -> Type
  Parameters: arr
Constraints: Category arr
Methods:
  
arrow : (a -> b) -> arr a b
  Converts a function from input to output into a arrow computation.
  
first : arr a b -> arr (a, c) (b, c)
  Converts an arrow from `a` to `b` into an arrow on pairs, that applies
  its argument to the first component and leaves the second component
  untouched, thus saving its value across a computation.
  
second : arr a b -> arr (c, a) (c, b)
  Converts an arrow from `a` to `b` into an arrow on pairs, that applies
  its argument to the second component and leaves the first component
  untouched, thus saving its value across a computation.
  
(***) : arr a b -> arr a' b' -> arr (a, a') (b, b')
  A combinator which processes both components of a pair.

  Fixity Declaration: infixr operator, level 3
  
(&&&) : arr a b -> arr a b' -> arr a (b, b')
  A combinator which builds a pair from the results of two arrows.

  Fixity Declaration: infixr operator, level 3

Implementations:
  
Arrow Morphism
  
Monad m => Arrow (Kleislimorphism m)
arrow : Arrow arr => (a -> b) -> arr a b
  Converts a function from input to output into a arrow computation.

  Visibility: public export
first : Arrow arr => arr a b -> arr (a, c) (b, c)
  Converts an arrow from `a` to `b` into an arrow on pairs, that applies
  its argument to the first component and leaves the second component
  untouched, thus saving its value across a computation.

  Visibility: public export
second : Arrow arr => arr a b -> arr (c, a) (c, b)
  Converts an arrow from `a` to `b` into an arrow on pairs, that applies
  its argument to the second component and leaves the first component
  untouched, thus saving its value across a computation.

  Visibility: public export
(***) : Arrow arr => arr a b -> arr a' b' -> arr (a, a') (b, b')
  A combinator which processes both components of a pair.

  Visibility: public export
  Fixity Declaration: infixr operator, level 3
(&&&) : Arrow arr => arr a b -> arr a b' -> arr a (b, b')
  A combinator which builds a pair from the results of two arrows.

  Visibility: public export
  Fixity Declaration: infixr operator, level 3
interface ArrowZero : (Type -> Type -> Type) -> Type
  Parameters: arr
Constraints: Arrow arr
Methods:
  
zeroArrow : arr a b

Implementation: 
ArrowPlus arr -> ArrowZero arr
zeroArrow : ArrowZero arr => arr a b
  Visibility: public export
interface ArrowPlus : (Type -> Type -> Type) -> Type
  Parameters: arr
Constraints: ArrowZero arr
Methods:
  
(<++>) : arr a b -> arr a b -> arr a b
  Fixity Declaration: infixr operator, level 5
(<++>) : ArrowPlus arr => arr a b -> arr a b -> arr a b
  Visibility: public export
  Fixity Declaration: infixr operator, level 5
interface ArrowChoice : (Type -> Type -> Type) -> Type
  Parameters: arr
Constraints: Arrow arr
Methods:
  
left : arr a b -> arr (Either a c) (Either b c)
  
right : arr a b -> arr (Either c a) (Either c b)
  
(+++) : arr a b -> arr c d -> arr (Either a c) (Either b d)
  Fixity Declaration: infixr operator, level 2
  
(\|/) : arr a b -> arr c b -> arr (Either a c) b
  Fixity Declaration: infixr operator, level 2

Implementation: 
Monad m => ArrowChoice (Kleislimorphism m)
left : ArrowChoice arr => arr a b -> arr (Either a c) (Either b c)
  Visibility: public export
right : ArrowChoice arr => arr a b -> arr (Either c a) (Either c b)
  Visibility: public export
(+++) : ArrowChoice arr => arr a b -> arr c d -> arr (Either a c) (Either b d)
  Visibility: public export
  Fixity Declaration: infixr operator, level 2
(\|/) : ArrowChoice arr => arr a b -> arr c b -> arr (Either a c) b
  Visibility: public export
  Fixity Declaration: infixr operator, level 2
interface ArrowApply : (Type -> Type -> Type) -> Type
  Parameters: arr
Constraints: Arrow arr
Methods:
  
app : arr (arr a b, a) b

Implementation: 
Monad m => ArrowApply (Kleislimorphism m)
app : ArrowApply arr => arr (arr a b, a) b
  Visibility: public export
data ArrowMonad : (Type -> Type -> Type) -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkArrowMonad : arr () a -> ArrowMonad arr a

  Hints:
  
Arrow a => Applicative (ArrowMonad a)
  
Arrow a => Functor (ArrowMonad a)
  
ArrowApply a => Monad (ArrowMonad a)
runArrowMonad : ArrowMonad arr a -> arr () a
  Visibility: public export
interface ArrowLoop : (Type -> Type -> Type) -> Type
  Parameters: arr
Constraints: Arrow arr
Methods:
  
loop : arr (a, c) (b, c) -> arr a b
loop : ArrowLoop arr => arr (a, c) (b, c) -> arr a b
  Visibility: public export
liftA2 : Arrow arr => (a -> b -> c) -> arr d a -> arr d b -> arr d c
  Applying a binary operator to the results of two arrow computations.

  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Control.Category.html b/contrib/docs/Control.Category.html
index f1b21cad82..2e8f738960 100644
--- a/contrib/docs/Control.Category.html
+++ b/contrib/docs/Control.Category.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Category(source)
Definitions
interface Category : (obj -> obj -> Type) -> Type
  Parameters: cat
Methods:
  
id : cat a a
  
(.) : cat b c -> cat a b -> cat a c
  Fixity Declaration: infixr operator, level 9

Implementations:
  
Category Morphism
  
Monad m => Category (Kleislimorphism m)
id : Category cat => cat a a
  Visibility: public export
(.) : Category cat => cat b c -> cat a b -> cat a c
  Visibility: public export
  Fixity Declaration: infixr operator, level 9
(>>>) : Category cat => cat a b -> cat b c -> cat a c
  Visibility: public export
  Fixity Declaration: infixr operator, level 1

\ No newline at end of file
+
Control.Category(source)
Definitions
interface Category : (obj -> obj -> Type) -> Type
  Parameters: cat
Methods:
  
id : cat a a
  
(.) : cat b c -> cat a b -> cat a c
  Fixity Declaration: infixr operator, level 9

Implementations:
  
Category Morphism
  
Monad m => Category (Kleislimorphism m)
id : Category cat => cat a a
  Visibility: public export
(.) : Category cat => cat b c -> cat a b -> cat a c
  Visibility: public export
  Fixity Declaration: infixr operator, level 9
(>>>) : Category cat => cat a b -> cat b c -> cat a c
  Visibility: public export
  Fixity Declaration: infixr operator, level 1

\ No newline at end of file
diff --git a/contrib/docs/Control.Delayed.html b/contrib/docs/Control.Delayed.html
index c2ab090125..779e46f2ee 100644
--- a/contrib/docs/Control.Delayed.html
+++ b/contrib/docs/Control.Delayed.html
@@ -62,4 +62,4 @@
 
 
 
Control.Delayed(source)
Utilities functions for conditionally delaying values.
-
Definitions
inf : Bool -> Type -> Type
  Type-level function for a conditionally infinite type.

  Visibility: public export
lazy : Bool -> Type -> Type
  Type-level function for a conditionally lazy type.

  Visibility: public export

\ No newline at end of file
+
Definitions
inf : Bool -> Type -> Type
  Type-level function for a conditionally infinite type.

  Visibility: public export
lazy : Bool -> Type -> Type
  Type-level function for a conditionally lazy type.

  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Control.Monad.Algebra.html b/contrib/docs/Control.Monad.Algebra.html
index 91d3d34be0..f9efc6331e 100644
--- a/contrib/docs/Control.Monad.Algebra.html
+++ b/contrib/docs/Control.Monad.Algebra.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Monad.Algebra(source)
Definitions

\ No newline at end of file
+
Control.Monad.Algebra(source)
Definitions

\ No newline at end of file
diff --git a/contrib/docs/Control.Validation.html b/contrib/docs/Control.Validation.html
index dc562100b2..e84a2f9146 100644
--- a/contrib/docs/Control.Validation.html
+++ b/contrib/docs/Control.Validation.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Validation(source)
Definitions
Result : (Type -> Type) -> Type -> Type
  Totality: total
  Visibility: public export
data ValidatorT : (Type -> Type) -> Type -> Type -> Type
  Validators in this module come in two flavours: Structural Validators and
  Property Validators. They are both wrappers around functions which take
  some input and confirm that it's valid (returning some witness of its
  validity) or fail with an error described by a string.

  Totality: total
  Visibility: export
  Constructor: 
MkValidator : (a -> Result m b) -> ValidatorT m a b

  Hints:
  
Monad m => Alternative (ValidatorT m a)
  
Monad m => Applicative (ValidatorT m a)
  
Functor m => Functor (ValidatorT m a)
  
Monad m => Monad (ValidatorT m a)
Validator : Type -> Type -> Type
  Totality: total
  Visibility: public export
validateT : ValidatorT m a b -> a -> Result m b
  Run validation on given input, returning (Right refinedInput) if everything
  is all right or (Left errorMessage) if it's not.

  Totality: total
  Visibility: export
validate : Validator a b -> a -> Either String b
  Run validation within the Identity monad and unwrap result immediately.

  Totality: total
  Visibility: export
validator : (a -> Result m b) -> ValidatorT m a b
  Given a function from input to Either String output, make a validator.

  Totality: total
  Visibility: export
withError : Monad m => String -> ValidatorT m a b -> ValidatorT m a b
  Replace validator's default error message.

  Totality: total
  Visibility: export
fail : Applicative m => String -> ValidatorT m a b
  A validator which always fails with a given message.

  Totality: total
  Visibility: export
(>>>) : Monad m => ValidatorT m a b -> ValidatorT m b c -> ValidatorT m a c
  Compose two validators so that the second validates the output of the first.

  Totality: total
  Visibility: export
  Fixity Declarations:
  infixl operator, level 2
infixr operator, level 1
contramap : (a -> b) -> ValidatorT m b c -> ValidatorT m a c
  Alter the input before validation using given function.

  Totality: total
  Visibility: export
decide : Monad m => (t -> String) -> ((x : t) -> Dec (p x)) -> PropValidator m t p
  Given a value x and a decision procedure for property p, validateT if p x
  holds, returning a proof if it does. The procedure also has access to the
  raw input in case it was helpful.

  Totality: total
  Visibility: export
fromMaybe : Monad m => (a -> String) -> (a -> Maybe b) -> ValidatorT m a b
  Given a function converting a into Maybe b, build a Validator of a
  converting it into b.

  Totality: total
  Visibility: export
natural : Monad m => ValidatorT m String Nat
  Verify whether a String represents a natural number.

  Totality: total
  Visibility: export
integral : Num a => Neg a => Monad m => ValidatorT m String a
  Verify whether a String represents an Integer

  Totality: total
  Visibility: export
double : Monad m => ValidatorT m String Double
  Verify that a string represents a decimal fraction.

  Totality: total
  Visibility: export
length : Monad m => (l : Nat) -> ValidatorT m (List a) (Vect l a)
  Verify whether a list has a desired length.

  Totality: total
  Visibility: export
equal : Monad m => DecEq t => (a : t) -> PropValidator m t (\b => a = b)
  Verify that certain values are equal.

  Totality: total
  Visibility: export
lteNat : Monad m => (bound : Nat) -> PropValidator m Nat (flip LTE bound)
  Verify that a Nat is less than or equal to  certain bound.

  Totality: total
  Visibility: export
gteNat : Monad m => (bound : Nat) -> PropValidator m Nat (flip GTE bound)
  Verify that a Nat is greater than or equal to certain bound.

  Totality: total
  Visibility: export
ltNat : Monad m => (bound : Nat) -> PropValidator m Nat (flip LT bound)
  Verify that a Nat is strictly less than a certain bound.

  Totality: total
  Visibility: export
gtNat : Monad m => (bound : Nat) -> PropValidator m Nat (flip GT bound)
  Verify that a Nat is strictly greate than a certain bound.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Control.Validation(source)
Definitions
Result : (Type -> Type) -> Type -> Type
  Totality: total
  Visibility: public export
data ValidatorT : (Type -> Type) -> Type -> Type -> Type
  Validators in this module come in two flavours: Structural Validators and
  Property Validators. They are both wrappers around functions which take
  some input and confirm that it's valid (returning some witness of its
  validity) or fail with an error described by a string.

  Totality: total
  Visibility: export
  Constructor: 
MkValidator : (a -> Result m b) -> ValidatorT m a b

  Hints:
  
Monad m => Alternative (ValidatorT m a)
  
Monad m => Applicative (ValidatorT m a)
  
Functor m => Functor (ValidatorT m a)
  
Monad m => Monad (ValidatorT m a)
Validator : Type -> Type -> Type
  Totality: total
  Visibility: public export
validateT : ValidatorT m a b -> a -> Result m b
  Run validation on given input, returning (Right refinedInput) if everything
  is all right or (Left errorMessage) if it's not.

  Totality: total
  Visibility: export
validate : Validator a b -> a -> Either String b
  Run validation within the Identity monad and unwrap result immediately.

  Totality: total
  Visibility: export
validator : (a -> Result m b) -> ValidatorT m a b
  Given a function from input to Either String output, make a validator.

  Totality: total
  Visibility: export
withError : Monad m => String -> ValidatorT m a b -> ValidatorT m a b
  Replace validator's default error message.

  Totality: total
  Visibility: export
fail : Applicative m => String -> ValidatorT m a b
  A validator which always fails with a given message.

  Totality: total
  Visibility: export
(>>>) : Monad m => ValidatorT m a b -> ValidatorT m b c -> ValidatorT m a c
  Compose two validators so that the second validates the output of the first.

  Totality: total
  Visibility: export
  Fixity Declarations:
  infixl operator, level 2
infixr operator, level 1
contramap : (a -> b) -> ValidatorT m b c -> ValidatorT m a c
  Alter the input before validation using given function.

  Totality: total
  Visibility: export
decide : Monad m => (t -> String) -> ((x : t) -> Dec (p x)) -> PropValidator m t p
  Given a value x and a decision procedure for property p, validateT if p x
  holds, returning a proof if it does. The procedure also has access to the
  raw input in case it was helpful.

  Totality: total
  Visibility: export
fromMaybe : Monad m => (a -> String) -> (a -> Maybe b) -> ValidatorT m a b
  Given a function converting a into Maybe b, build a Validator of a
  converting it into b.

  Totality: total
  Visibility: export
natural : Monad m => ValidatorT m String Nat
  Verify whether a String represents a natural number.

  Totality: total
  Visibility: export
integral : Num a => Neg a => Monad m => ValidatorT m String a
  Verify whether a String represents an Integer

  Totality: total
  Visibility: export
double : Monad m => ValidatorT m String Double
  Verify that a string represents a decimal fraction.

  Totality: total
  Visibility: export
length : Monad m => (l : Nat) -> ValidatorT m (List a) (Vect l a)
  Verify whether a list has a desired length.

  Totality: total
  Visibility: export
equal : Monad m => DecEq t => (a : t) -> PropValidator m t (\b => a = b)
  Verify that certain values are equal.

  Totality: total
  Visibility: export
lteNat : Monad m => (bound : Nat) -> PropValidator m Nat (flip LTE bound)
  Verify that a Nat is less than or equal to  certain bound.

  Totality: total
  Visibility: export
gteNat : Monad m => (bound : Nat) -> PropValidator m Nat (flip GTE bound)
  Verify that a Nat is greater than or equal to certain bound.

  Totality: total
  Visibility: export
ltNat : Monad m => (bound : Nat) -> PropValidator m Nat (flip LT bound)
  Verify that a Nat is strictly less than a certain bound.

  Totality: total
  Visibility: export
gtNat : Monad m => (bound : Nat) -> PropValidator m Nat (flip GT bound)
  Verify that a Nat is strictly greate than a certain bound.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Binary.Digit.html b/contrib/docs/Data.Binary.Digit.html
index 1778edf4a3..2924576ae8 100644
--- a/contrib/docs/Data.Binary.Digit.html
+++ b/contrib/docs/Data.Binary.Digit.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Binary.Digit(source)
Definitions
data Digit : Type
  This is essentially Bool but with names that are easier
  to understand

  Totality: total
  Visibility: public export
  Constructors:
  
O : Digit
  
I : Digit
isI : Digit -> Bool
  Translation to Bool

  Totality: total
  Visibility: public export
toNat : Digit -> Nat
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Binary.Digit(source)
Definitions
data Digit : Type
  This is essentially Bool but with names that are easier
  to understand

  Totality: total
  Visibility: public export
  Constructors:
  
O : Digit
  
I : Digit
isI : Digit -> Bool
  Translation to Bool

  Totality: total
  Visibility: public export
toNat : Digit -> Nat
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.Binary.html b/contrib/docs/Data.Binary.html
index ef3a69511b..346349a423 100644
--- a/contrib/docs/Data.Binary.html
+++ b/contrib/docs/Data.Binary.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Binary(source)
Definitions
Bin : Type
  Bin represents binary numbers right-to-left.
  For instance `4` can be represented as `OOI`.
  Note that representations are not unique: one may append arbitrarily
  many Os to the right of the representation without changing the meaning.

  Totality: total
  Visibility: public export
toNat : Bin -> Nat
  Conversion from lists of bits to natural number.

  Totality: total
  Visibility: public export
suc : Bin -> Bin
  Successor function on binary numbers.
  Amortised constant time.

  Totality: total
  Visibility: public export
sucCorrect : toNat (suc bs) = S (toNat bs)
  Correctness proof of `suc` with respect to the semantics in terms of Nat

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Binary(source)
Definitions
Bin : Type
  Bin represents binary numbers right-to-left.
  For instance `4` can be represented as `OOI`.
  Note that representations are not unique: one may append arbitrarily
  many Os to the right of the representation without changing the meaning.

  Totality: total
  Visibility: public export
toNat : Bin -> Nat
  Conversion from lists of bits to natural number.

  Totality: total
  Visibility: public export
suc : Bin -> Bin
  Successor function on binary numbers.
  Amortised constant time.

  Totality: total
  Visibility: public export
sucCorrect : toNat (suc bs) = S (toNat bs)
  Correctness proof of `suc` with respect to the semantics in terms of Nat

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Bool.Algebra.html b/contrib/docs/Data.Bool.Algebra.html
index 949c9059b6..2aad4bdf83 100644
--- a/contrib/docs/Data.Bool.Algebra.html
+++ b/contrib/docs/Data.Bool.Algebra.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Bool.Algebra(source)

\ No newline at end of file
+
Data.Bool.Algebra(source)

\ No newline at end of file
diff --git a/contrib/docs/Data.Bool.Decidable.html b/contrib/docs/Data.Bool.Decidable.html
index 1bfa9d23d1..d9e021e334 100644
--- a/contrib/docs/Data.Bool.Decidable.html
+++ b/contrib/docs/Data.Bool.Decidable.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Bool.Decidable(source)
Definitions
data Reflects : Type -> Bool -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
RTrue : p -> Reflects p True
  
RFalse : Not p -> Reflects p False
recompute : Dec a -> (0 _ : a) -> a
  Visibility: public export
invert : ({arg:910} : Reflects p b) -> (if b then p else Not p)
  Visibility: public export
remember : (if b then p else Not p) -> Reflects p b
  Visibility: public export
reflect : ({arg:989} : Reflects p b) -> (if c then p else Not p) -> b = c
  Visibility: public export

\ No newline at end of file
+
Data.Bool.Decidable(source)
Definitions
data Reflects : Type -> Bool -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
RTrue : p -> Reflects p True
  
RFalse : Not p -> Reflects p False
recompute : Dec a -> (0 _ : a) -> a
  Visibility: public export
invert : ({arg:910} : Reflects p b) -> (if b then p else Not p)
  Visibility: public export
remember : (if b then p else Not p) -> Reflects p b
  Visibility: public export
reflect : ({arg:989} : Reflects p b) -> (if c then p else Not p) -> b = c
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.Fin.Extra.html b/contrib/docs/Data.Fin.Extra.html
index 8c8e6d82ce..bbce305f8f 100644
--- a/contrib/docs/Data.Fin.Extra.html
+++ b/contrib/docs/Data.Fin.Extra.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Fin.Extra(source)
Definitions
elemSmallerThanBound : (n : Fin m) -> LT (finToNat n) m
  A Fin's underlying natural number is smaller than the bound

  Totality: total
  Visibility: export
finToNatLastIsBound : finToNat last = n
  Last's underlying natural number is the bound's predecessor

  Totality: total
  Visibility: export
finToNatWeakenNeutral : finToNat (weaken n) = finToNat n
  Weaken does not modify the underlying natural number

  Totality: total
  Visibility: export
finToNatWeakenNNeutral : (0 m : Nat) -> (k : Fin n) -> finToNat (weakenN m k) = finToNat k
  WeakenN does not modify the underlying natural number

  Totality: total
  Visibility: export
finToNatShift : (k : Nat) -> (a : Fin n) -> finToNat (shift k a) = k + finToNat a
  `Shift k` shifts the underlying natural number by `k`.

  Totality: total
  Visibility: export
invFin : Fin n -> Fin n
  Compute the Fin such that `k + invFin k = n - 1`

  Totality: total
  Visibility: public export
invFinSpec : (i : Fin n) -> (1 + finToNat i) + finToNat (invFin i) = n
  Totality: total
  Visibility: export
invFinWeakenIsFS : (m : Fin n) -> invFin (weaken m) = FS (invFin m)
  The inverse of a weakened element is the successor of its inverse

  Totality: total
  Visibility: export
invFinLastIsFZ : invFin last = FZ
  Totality: total
  Visibility: export
invFinInvolutive : (m : Fin n) -> invFin (invFin m) = m
  `invFin` is involutive (i.e. applied twice it is the identity)

  Totality: total
  Visibility: export
strengthenWeakenIsRight : (n : Fin m) -> strengthen (weaken n) = Just n
  It's possible to strengthen a weakened element of Fin **m**.

  Totality: total
  Visibility: export
strengthenLastIsLeft : strengthen last = Nothing
  It's not possible to strengthen the last element of Fin **n**.

  Totality: total
  Visibility: export
strengthenNotLastIsRight : (m : Fin n) -> strengthen (invFin (FS m)) = Just (invFin m)
  It's possible to strengthen the inverse of a succesor

  Totality: total
  Visibility: export
strengthen' : (m : Fin (S n)) -> Either (m = last) (m' : Fin n ** finToNat m = finToNat m')
  Either tightens the bound on a Fin or proves that it's the last.

  Totality: total
  Visibility: export
strengthenMod : Fin n -> (m : Nat) -> NonZero m => Fin m
  Tighten the bound on a Fin by taking its current bound modulo the given
  non-zero number.

  Totality: total
  Visibility: export
weakenNZeroIdentity : (k : Fin n) -> weakenN 0 k ~~~ k
  Totality: total
  Visibility: export
shiftFSLinear : (m : Nat) -> (f : Fin n) -> shift m (FS f) ~~~ FS (shift m f)
  Totality: total
  Visibility: export
shiftLastIsLast : (m : Nat) -> shift m last ~~~ last
  Totality: total
  Visibility: export
data FractionView : Nat -> Nat -> Type
  A view of Nat as a quotient of some number and a finite remainder.

  Totality: total
  Visibility: public export
  Constructor: 
Fraction : (n : Nat) -> (d : Nat) -> GT d 0 => (q : Nat) -> (r : Fin d) -> (q * d) + finToNat r = n -> FractionView n d
divMod : (n : Nat) -> (d : Nat) -> GT d 0 => FractionView n d
  Converts Nat to the fractional view with a non-zero divisor.

  Totality: total
  Visibility: export
modFin : Nat -> (m : Nat) -> NonZero m => Fin m
  Compute n % m as a Fin with upper bound m.
  
  Useful, for example, when iterating through a large index, computing
  subindices as a function of the larger index (e.g. a flattened 2D-array)

  Totality: total
  Visibility: export
natToFinLTE : (n : Nat) -> (0 _ : LT n m) -> Fin m
  Total function to convert a nat to a Fin, given a proof
  that it is less than the bound.

  Totality: total
  Visibility: public export
natToFinToNat : (n : Nat) -> (lte : LT n m) -> finToNat (natToFinLTE n lte) = n
  Converting from a Nat to a Fin and back is the identity.

  Totality: total
  Visibility: public export
(+) : Fin m -> Fin (S n) -> Fin (m + n)
  Addition of `Fin`s as bounded naturals.
  The resulting type has the smallest possible bound
  as illustated by the relations with the `last` function.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 8
(*) : Fin (S m) -> Fin (S n) -> Fin (S (m * n))
  Multiplication of `Fin`s as bounded naturals.
  The resulting type has the smallest possible bound
  as illustated by the relations with the `last` function.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 9
finToNatPlusHomo : (x : Fin m) -> (y : Fin (S n)) -> finToNat (x + y) = finToNat x + finToNat y
  Totality: total
  Visibility: export
finToNatMultHomo : (x : Fin (S m)) -> (y : Fin (S n)) -> finToNat (x * y) = finToNat x * finToNat y
  Totality: total
  Visibility: export
plusPreservesLast : (m : Nat) -> (n : Nat) -> last + last = last
  Totality: total
  Visibility: export
multPreservesLast : (m : Nat) -> (n : Nat) -> last * last = last
  Totality: total
  Visibility: export
plusSuccRightSucc : (left : Fin m) -> (right : Fin (S n)) -> FS (left + right) ~~~ (left + FS right)
  Totality: total
  Visibility: export
shiftAsPlus : (k : Fin (S m)) -> shift n k ~~~ (last + k)
  Totality: total
  Visibility: export
weakenNAsPlusFZ : (k : Fin n) -> weakenN m k = k + the (Fin (S m)) FZ
  Totality: total
  Visibility: export
weakenNPlusHomo : (k : Fin p) -> weakenN n (weakenN m k) ~~~ weakenN (m + n) k
  Totality: total
  Visibility: export
weakenNOfPlus : (k : Fin m) -> (l : Fin (S n)) -> weakenN w (k + l) ~~~ (weakenN w k + l)
  Totality: total
  Visibility: export
plusZeroLeftNeutral : (k : Fin (S n)) -> (FZ + k) ~~~ k
  Totality: total
  Visibility: export
congPlusLeft : (c : Fin (S p)) -> k ~~~ l -> (k + c) ~~~ (l + c)
  Totality: total
  Visibility: export
plusZeroRightNeutral : (k : Fin m) -> (k + FZ) ~~~ k
  Totality: total
  Visibility: export
congPlusRight : (c : Fin m) -> k ~~~ l -> (c + k) ~~~ (c + l)
  Totality: total
  Visibility: export
plusCommutative : (left : Fin (S m)) -> (right : Fin (S n)) -> (left + right) ~~~ (right + left)
  Totality: total
  Visibility: export
plusAssociative : (left : Fin m) -> (centre : Fin (S n)) -> (right : Fin (S p)) -> (left + (centre + right)) ~~~ ((left + centre) + right)
  Totality: total
  Visibility: export
indexSum : Either (Fin m) (Fin n) -> Fin (m + n)
  Converts `Fin`s that are used as indexes of parts to an index of a sum.
  
  For example, if you have a `Vect` that is a concatenation of two `Vect`s and
  you have an index either in the first or the second of the original `Vect`s,
  using this function you can get an index in the concatenated one.

  Totality: total
  Visibility: public export
splitSum : Fin (m + n) -> Either (Fin m) (Fin n)
  Extracts an index of the first or the second part from the index of a sum.
  
  For example, if you have a `Vect` that is a concatenation of the `Vect`s and
  you have an index of this `Vect`, you have get an index of either left or right
  original `Vect` using this function.

  Totality: total
  Visibility: public export
indexProd : Fin m -> Fin n -> Fin (m * n)
  Calculates the index of a square matrix of size `a * b` by indices of each side.

  Totality: total
  Visibility: public export
splitProd : Fin (m * n) -> (Fin m, Fin n)
  Splits the index of a square matrix of size `a * b` to indices of each side.

  Totality: total
  Visibility: public export
indexSumPreservesLast : (m : Nat) -> (n : Nat) -> indexSum (Right last) ~~~ last
  Totality: total
  Visibility: export
indexProdPreservesLast : (m : Nat) -> (n : Nat) -> indexProd last last = last
  Totality: total
  Visibility: export
splitSumOfWeakenN : (k : Fin m) -> splitSum (weakenN n k) = Left k
  Totality: total
  Visibility: export
splitSumOfShift : (k : Fin n) -> splitSum (shift m k) = Right k
  Totality: total
  Visibility: export
splitOfIndexSumInverse : (e : Either (Fin m) (Fin n)) -> splitSum (indexSum e) = e
  Totality: total
  Visibility: export
indexOfSplitSumInverse : (f : Fin (m + n)) -> indexSum (splitSum f) = f
  Totality: total
  Visibility: export
splitOfIndexProdInverse : (k : Fin m) -> (l : Fin n) -> splitProd (indexProd k l) = (k, l)
  Totality: total
  Visibility: export
indexOfSplitProdInverse : (f : Fin (m * n)) -> uncurry indexProd (splitProd f) = f
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Fin.Extra(source)
Definitions
elemSmallerThanBound : (n : Fin m) -> LT (finToNat n) m
  A Fin's underlying natural number is smaller than the bound

  Totality: total
  Visibility: export
finToNatLastIsBound : finToNat last = n
  Last's underlying natural number is the bound's predecessor

  Totality: total
  Visibility: export
finToNatWeakenNeutral : finToNat (weaken n) = finToNat n
  Weaken does not modify the underlying natural number

  Totality: total
  Visibility: export
finToNatWeakenNNeutral : (0 m : Nat) -> (k : Fin n) -> finToNat (weakenN m k) = finToNat k
  WeakenN does not modify the underlying natural number

  Totality: total
  Visibility: export
finToNatShift : (k : Nat) -> (a : Fin n) -> finToNat (shift k a) = k + finToNat a
  `Shift k` shifts the underlying natural number by `k`.

  Totality: total
  Visibility: export
invFin : Fin n -> Fin n
  Compute the Fin such that `k + invFin k = n - 1`

  Totality: total
  Visibility: public export
invFinSpec : (i : Fin n) -> (1 + finToNat i) + finToNat (invFin i) = n
  Totality: total
  Visibility: export
invFinWeakenIsFS : (m : Fin n) -> invFin (weaken m) = FS (invFin m)
  The inverse of a weakened element is the successor of its inverse

  Totality: total
  Visibility: export
invFinLastIsFZ : invFin last = FZ
  Totality: total
  Visibility: export
invFinInvolutive : (m : Fin n) -> invFin (invFin m) = m
  `invFin` is involutive (i.e. applied twice it is the identity)

  Totality: total
  Visibility: export
strengthenWeakenIsRight : (n : Fin m) -> strengthen (weaken n) = Just n
  It's possible to strengthen a weakened element of Fin **m**.

  Totality: total
  Visibility: export
strengthenLastIsLeft : strengthen last = Nothing
  It's not possible to strengthen the last element of Fin **n**.

  Totality: total
  Visibility: export
strengthenNotLastIsRight : (m : Fin n) -> strengthen (invFin (FS m)) = Just (invFin m)
  It's possible to strengthen the inverse of a succesor

  Totality: total
  Visibility: export
strengthen' : (m : Fin (S n)) -> Either (m = last) (m' : Fin n ** finToNat m = finToNat m')
  Either tightens the bound on a Fin or proves that it's the last.

  Totality: total
  Visibility: export
strengthenMod : Fin n -> (m : Nat) -> NonZero m => Fin m
  Tighten the bound on a Fin by taking its current bound modulo the given
  non-zero number.

  Totality: total
  Visibility: export
weakenNZeroIdentity : (k : Fin n) -> weakenN 0 k ~~~ k
  Totality: total
  Visibility: export
shiftFSLinear : (m : Nat) -> (f : Fin n) -> shift m (FS f) ~~~ FS (shift m f)
  Totality: total
  Visibility: export
shiftLastIsLast : (m : Nat) -> shift m last ~~~ last
  Totality: total
  Visibility: export
data FractionView : Nat -> Nat -> Type
  A view of Nat as a quotient of some number and a finite remainder.

  Totality: total
  Visibility: public export
  Constructor: 
Fraction : (n : Nat) -> (d : Nat) -> GT d 0 => (q : Nat) -> (r : Fin d) -> (q * d) + finToNat r = n -> FractionView n d
divMod : (n : Nat) -> (d : Nat) -> GT d 0 => FractionView n d
  Converts Nat to the fractional view with a non-zero divisor.

  Totality: total
  Visibility: export
modFin : Nat -> (m : Nat) -> NonZero m => Fin m
  Compute n % m as a Fin with upper bound m.
  
  Useful, for example, when iterating through a large index, computing
  subindices as a function of the larger index (e.g. a flattened 2D-array)

  Totality: total
  Visibility: export
natToFinLTE : (n : Nat) -> (0 _ : LT n m) -> Fin m
  Total function to convert a nat to a Fin, given a proof
  that it is less than the bound.

  Totality: total
  Visibility: public export
natToFinToNat : (n : Nat) -> (lte : LT n m) -> finToNat (natToFinLTE n lte) = n
  Converting from a Nat to a Fin and back is the identity.

  Totality: total
  Visibility: public export
(+) : Fin m -> Fin (S n) -> Fin (m + n)
  Addition of `Fin`s as bounded naturals.
  The resulting type has the smallest possible bound
  as illustated by the relations with the `last` function.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 8
(*) : Fin (S m) -> Fin (S n) -> Fin (S (m * n))
  Multiplication of `Fin`s as bounded naturals.
  The resulting type has the smallest possible bound
  as illustated by the relations with the `last` function.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 9
finToNatPlusHomo : (x : Fin m) -> (y : Fin (S n)) -> finToNat (x + y) = finToNat x + finToNat y
  Totality: total
  Visibility: export
finToNatMultHomo : (x : Fin (S m)) -> (y : Fin (S n)) -> finToNat (x * y) = finToNat x * finToNat y
  Totality: total
  Visibility: export
plusPreservesLast : (m : Nat) -> (n : Nat) -> last + last = last
  Totality: total
  Visibility: export
multPreservesLast : (m : Nat) -> (n : Nat) -> last * last = last
  Totality: total
  Visibility: export
plusSuccRightSucc : (left : Fin m) -> (right : Fin (S n)) -> FS (left + right) ~~~ (left + FS right)
  Totality: total
  Visibility: export
shiftAsPlus : (k : Fin (S m)) -> shift n k ~~~ (last + k)
  Totality: total
  Visibility: export
weakenNAsPlusFZ : (k : Fin n) -> weakenN m k = k + the (Fin (S m)) FZ
  Totality: total
  Visibility: export
weakenNPlusHomo : (k : Fin p) -> weakenN n (weakenN m k) ~~~ weakenN (m + n) k
  Totality: total
  Visibility: export
weakenNOfPlus : (k : Fin m) -> (l : Fin (S n)) -> weakenN w (k + l) ~~~ (weakenN w k + l)
  Totality: total
  Visibility: export
plusZeroLeftNeutral : (k : Fin (S n)) -> (FZ + k) ~~~ k
  Totality: total
  Visibility: export
congPlusLeft : (c : Fin (S p)) -> k ~~~ l -> (k + c) ~~~ (l + c)
  Totality: total
  Visibility: export
plusZeroRightNeutral : (k : Fin m) -> (k + FZ) ~~~ k
  Totality: total
  Visibility: export
congPlusRight : (c : Fin m) -> k ~~~ l -> (c + k) ~~~ (c + l)
  Totality: total
  Visibility: export
plusCommutative : (left : Fin (S m)) -> (right : Fin (S n)) -> (left + right) ~~~ (right + left)
  Totality: total
  Visibility: export
plusAssociative : (left : Fin m) -> (centre : Fin (S n)) -> (right : Fin (S p)) -> (left + (centre + right)) ~~~ ((left + centre) + right)
  Totality: total
  Visibility: export
indexSum : Either (Fin m) (Fin n) -> Fin (m + n)
  Converts `Fin`s that are used as indexes of parts to an index of a sum.
  
  For example, if you have a `Vect` that is a concatenation of two `Vect`s and
  you have an index either in the first or the second of the original `Vect`s,
  using this function you can get an index in the concatenated one.

  Totality: total
  Visibility: public export
splitSum : Fin (m + n) -> Either (Fin m) (Fin n)
  Extracts an index of the first or the second part from the index of a sum.
  
  For example, if you have a `Vect` that is a concatenation of the `Vect`s and
  you have an index of this `Vect`, you have get an index of either left or right
  original `Vect` using this function.

  Totality: total
  Visibility: public export
indexProd : Fin m -> Fin n -> Fin (m * n)
  Calculates the index of a square matrix of size `a * b` by indices of each side.

  Totality: total
  Visibility: public export
splitProd : Fin (m * n) -> (Fin m, Fin n)
  Splits the index of a square matrix of size `a * b` to indices of each side.

  Totality: total
  Visibility: public export
indexSumPreservesLast : (m : Nat) -> (n : Nat) -> indexSum (Right last) ~~~ last
  Totality: total
  Visibility: export
indexProdPreservesLast : (m : Nat) -> (n : Nat) -> indexProd last last = last
  Totality: total
  Visibility: export
splitSumOfWeakenN : (k : Fin m) -> splitSum (weakenN n k) = Left k
  Totality: total
  Visibility: export
splitSumOfShift : (k : Fin n) -> splitSum (shift m k) = Right k
  Totality: total
  Visibility: export
splitOfIndexSumInverse : (e : Either (Fin m) (Fin n)) -> splitSum (indexSum e) = e
  Totality: total
  Visibility: export
indexOfSplitSumInverse : (f : Fin (m + n)) -> indexSum (splitSum f) = f
  Totality: total
  Visibility: export
splitOfIndexProdInverse : (k : Fin m) -> (l : Fin n) -> splitProd (indexProd k l) = (k, l)
  Totality: total
  Visibility: export
indexOfSplitProdInverse : (f : Fin (m * n)) -> uncurry indexProd (splitProd f) = f
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Fun.Extra.html b/contrib/docs/Data.Fun.Extra.html
index 5d4f1d315b..066473aeb2 100644
--- a/contrib/docs/Data.Fun.Extra.html
+++ b/contrib/docs/Data.Fun.Extra.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Fun.Extra(source)
Definitions
uncurry : Fun ts cod -> HVect ts -> cod
  Apply an n-ary function to an n-ary tuple of inputs

  Totality: total
  Visibility: public export
curry : (HVect ts -> cod) -> Fun ts cod
  Apply an n-ary function to an n-ary tuple of inputs

  Totality: total
  Visibility: public export
homoFunNeut_ext : Fun [] cod -> id cod
  Totality: total
  Visibility: public export
homoFunMult_ext : Fun (rs ++ ss) cod -> (.) (Fun rs) (Fun ss) cod
  Totality: total
  Visibility: public export
homoFunNeut_inv : id cod -> Fun [] cod
  Totality: total
  Visibility: public export
homoFunMult_inv : (.) (Fun rs) (Fun ss) cod -> Fun (rs ++ ss) cod
  Totality: total
  Visibility: public export
applyPartially : Fun (ts ++ ss) cod -> HVect ts -> Fun ss cod
  Apply an n-ary function to an n-ary tuple of inputs

  Totality: total
  Visibility: public export
uncurryAll : All ts cod -> (xs : HVect ts) -> uncurry cod xs
  Apply an n-ary dependent function to its tuple of inputs (given by an HVect)

  Totality: total
  Visibility: public export
curryAll : ((xs : HVect ts) -> uncurry cod xs) -> All ts cod
  Totality: total
  Visibility: public export
homoAllNeut_ext : Fun [] cod -> id cod
  Totality: total
  Visibility: public export
extractWitness : Ex ts r -> HVect ts
  Totality: total
  Visibility: public export
extractWitnessCorrect : (f : Ex ts r) -> uncurry r (extractWitness f)
  Totality: total
  Visibility: public export
introduceWitness : (witness : HVect ts) -> uncurry r witness -> Ex ts r
  Totality: total
  Visibility: public export
data Pointwise : (a -> b -> Type) -> Vect n a -> Vect n b -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Pointwise r [] []
  
(::) : r t s -> Pointwise r ts ss -> Pointwise r (t :: ts) (s :: ss)
precompose : Pointwise (\a, b => a -> b) ts ss -> Fun ss cod -> Fun ts cod
  Totality: total
  Visibility: public export
chainUncurry : (g : Fun ts r) -> (f : (r -> r')) -> (elems : HVect ts) -> f (uncurry g elems) = uncurry (chain f g) elems
  Uncurrying a Fun and then composing with a normal function
  is extensionally equal to
  composing functions using `chain`, then uncurrying.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Fun.Extra(source)
Definitions
uncurry : Fun ts cod -> HVect ts -> cod
  Apply an n-ary function to an n-ary tuple of inputs

  Totality: total
  Visibility: public export
curry : (HVect ts -> cod) -> Fun ts cod
  Apply an n-ary function to an n-ary tuple of inputs

  Totality: total
  Visibility: public export
homoFunNeut_ext : Fun [] cod -> id cod
  Totality: total
  Visibility: public export
homoFunMult_ext : Fun (rs ++ ss) cod -> (.) (Fun rs) (Fun ss) cod
  Totality: total
  Visibility: public export
homoFunNeut_inv : id cod -> Fun [] cod
  Totality: total
  Visibility: public export
homoFunMult_inv : (.) (Fun rs) (Fun ss) cod -> Fun (rs ++ ss) cod
  Totality: total
  Visibility: public export
applyPartially : Fun (ts ++ ss) cod -> HVect ts -> Fun ss cod
  Apply an n-ary function to an n-ary tuple of inputs

  Totality: total
  Visibility: public export
uncurryAll : All ts cod -> (xs : HVect ts) -> uncurry cod xs
  Apply an n-ary dependent function to its tuple of inputs (given by an HVect)

  Totality: total
  Visibility: public export
curryAll : ((xs : HVect ts) -> uncurry cod xs) -> All ts cod
  Totality: total
  Visibility: public export
homoAllNeut_ext : Fun [] cod -> id cod
  Totality: total
  Visibility: public export
extractWitness : Ex ts r -> HVect ts
  Totality: total
  Visibility: public export
extractWitnessCorrect : (f : Ex ts r) -> uncurry r (extractWitness f)
  Totality: total
  Visibility: public export
introduceWitness : (witness : HVect ts) -> uncurry r witness -> Ex ts r
  Totality: total
  Visibility: public export
data Pointwise : (a -> b -> Type) -> Vect n a -> Vect n b -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Pointwise r [] []
  
(::) : r t s -> Pointwise r ts ss -> Pointwise r (t :: ts) (s :: ss)
precompose : Pointwise (\a, b => a -> b) ts ss -> Fun ss cod -> Fun ts cod
  Totality: total
  Visibility: public export
chainUncurry : (g : Fun ts r) -> (f : (r -> r')) -> (elems : HVect ts) -> f (uncurry g elems) = uncurry (chain f g) elems
  Uncurrying a Fun and then composing with a normal function
  is extensionally equal to
  composing functions using `chain`, then uncurrying.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.Fun.Graph.html b/contrib/docs/Data.Fun.Graph.html
index e778dcd779..0019ad4e0f 100644
--- a/contrib/docs/Data.Fun.Graph.html
+++ b/contrib/docs/Data.Fun.Graph.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Fun.Graph(source)
Definitions
record Graph : {0 b : a -> Type} -> ((x : a) -> b x) -> (x : a) -> b x -> Type
  A relation corresponding to the graph of `f`.

  Totality: total
  Visibility: public export
  Constructor: 
MkGraph : f x = y -> Graph f x y

  Projection: 
.equality : Graph f x y -> f x = y
.equality : Graph f x y -> f x = y
  Visibility: public export
equality : Graph f x y -> f x = y
  Visibility: public export
remember : {0 b : a -> Type} -> (f : ((x : a) -> b x)) -> (x : a) -> Graph f x (f x)
  An alternative for 'Syntax.WithProof' that allows to keep the
  proof certificate in non-reduced form after nested matching.
  Inspired by https://agda.github.io/agda-stdlib/README.Inspect.html

  Visibility: public export

\ No newline at end of file
+
Data.Fun.Graph(source)
Definitions
record Graph : {0 b : a -> Type} -> ((x : a) -> b x) -> (x : a) -> b x -> Type
  A relation corresponding to the graph of `f`.

  Totality: total
  Visibility: public export
  Constructor: 
MkGraph : f x = y -> Graph f x y

  Projection: 
.equality : Graph f x y -> f x = y
.equality : Graph f x y -> f x = y
  Visibility: public export
equality : Graph f x y -> f x = y
  Visibility: public export
remember : {0 b : a -> Type} -> (f : ((x : a) -> b x)) -> (x : a) -> Graph f x (f x)
  An alternative for 'Syntax.WithProof' that allows to keep the
  proof certificate in non-reduced form after nested matching.
  Inspired by https://agda.github.io/agda-stdlib/README.Inspect.html

  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.HVect.html b/contrib/docs/Data.HVect.html
index 567c7a8243..a4df2f325d 100644
--- a/contrib/docs/Data.HVect.html
+++ b/contrib/docs/Data.HVect.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.HVect(source)
Reexports
import public Data.Vect
Definitions
data HVect : Vect k Type -> Type
  Heterogeneous vectors where the type index gives, element-wise,
  the types of the contents.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : HVect []
  
(::) : t -> HVect ts -> HVect (t :: ts)

  Hints:
  
DecEq (HVect [])
  
(DecEq t, DecEq (HVect ts)) => DecEq (HVect (t :: ts))
  
Eq (HVect [])
  
(Eq t, Eq (HVect ts)) => Eq (HVect (t :: ts))
  
Shows len ts => Show (HVect ts)
index : (i : Fin k) -> HVect ts -> index i ts
  Extract an element from an HVect.
  
  ```idris example
  > index 0 (the (HVect _) [1, "string"])
  1
  ```

  Totality: total
  Visibility: public export
deleteAt : (i : Fin (S l)) -> HVect ts -> HVect (deleteAt i ts)
  Delete an element from an HVect.
  
  ```idris example
  > deleteAt 0 (the (HVect _) [1, "string"])
  ["string"]
  ```

  Totality: total
  Visibility: public export
replaceAt : (i : Fin k) -> t -> HVect ts -> HVect (replaceAt i t ts)
  Replace an element in an HVect.
  
  ```idris example
  > replaceAt 0 "firstString" (the (HVect _) [1, "string"])
  ["firstString", "string"]
  ```

  Totality: total
  Visibility: public export
updateAt : (i : Fin k) -> (index i ts -> t) -> HVect ts -> HVect (replaceAt i t ts)
  Update an element in an HVect.
  
  ```idris example
  > updateAt 0 (const True) (the (HVect _) [1, "string"])
  [True, "string"]
  ```

  Totality: total
  Visibility: public export
(++) : HVect ts -> HVect us -> HVect (ts ++ us)
  Append two `HVect`s.
  
  ```idris example
  > (the (HVect _) [1]) ++ (the (HVect _) ["string"])
  [1, "string"]
  ```

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
consInjective1 : x :: xs = y :: ys -> x = y
  Totality: total
  Visibility: public export
consInjective2 : x :: xs = y :: ys -> xs = ys
  Totality: total
  Visibility: public export
interface Shows : (k : Nat) -> Vect k Type -> Type
  Parameters: k, ts
Methods:
  
shows : HVect ts -> Vect k String

Implementations:
  
Shows 0 []
  
(Show t, Shows len ts) => Shows (S len) (t :: ts)
shows : Shows k ts => HVect ts -> Vect k String
  Totality: total
  Visibility: public export
get : (1 _ : HVect ts) -> {auto 1 _ : Elem t ts} -> t
  Extract an arbitrary element of the correct type.
  
  ```idris example
  > get [1, "string"] {p = Here}
  1
  ```

  Totality: total
  Visibility: public export
put : t -> (1 _ : HVect ts) -> {auto 1 _ : Elem t ts} -> HVect ts
  Replace an element with the correct type. (Homogeneous)
  
  ```idris example
  > put 2 [1, "string"]
  [2, "string"]
  ```

  Totality: total
  Visibility: public export
htPut : u -> (1 _ : HVect ts) -> {auto 1 p : Elem t ts} -> HVect (replaceByElem ts p u)
  Replace an element with the correct type. (Heterogeneous)
  
  ```idris example
  > htPut True [1, "string"] {p = Here}
  [True, "string"]
  ```

  Totality: total
  Visibility: public export
update : (t -> t) -> (1 _ : HVect ts) -> {auto 1 _ : Elem t ts} -> HVect ts
  Update an element with the correct type. (Homogeneous)
  
  ```idris example
  > update (const "hello world!") [1, "string"]
  [1, "hello world!"]
  ```

  Totality: total
  Visibility: public export
htUpdate : (t -> u) -> (1 _ : HVect ts) -> {auto 1 p : Elem t ts} -> HVect (replaceByElem ts p u)
  Update an element with the correct type. (Heterogeneous)
  
  ```idris example
  > htUpdate (\_ : String => 2) [1, "string"]
  [1, 2]
  ```

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.HVect(source)
Reexports
import public Data.Vect
Definitions
data HVect : Vect k Type -> Type
  Heterogeneous vectors where the type index gives, element-wise,
  the types of the contents.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : HVect []
  
(::) : t -> HVect ts -> HVect (t :: ts)

  Hints:
  
DecEq (HVect [])
  
(DecEq t, DecEq (HVect ts)) => DecEq (HVect (t :: ts))
  
Eq (HVect [])
  
(Eq t, Eq (HVect ts)) => Eq (HVect (t :: ts))
  
Shows len ts => Show (HVect ts)
index : (i : Fin k) -> HVect ts -> index i ts
  Extract an element from an HVect.
  
  ```idris example
  > index 0 (the (HVect _) [1, "string"])
  1
  ```

  Totality: total
  Visibility: public export
deleteAt : (i : Fin (S l)) -> HVect ts -> HVect (deleteAt i ts)
  Delete an element from an HVect.
  
  ```idris example
  > deleteAt 0 (the (HVect _) [1, "string"])
  ["string"]
  ```

  Totality: total
  Visibility: public export
replaceAt : (i : Fin k) -> t -> HVect ts -> HVect (replaceAt i t ts)
  Replace an element in an HVect.
  
  ```idris example
  > replaceAt 0 "firstString" (the (HVect _) [1, "string"])
  ["firstString", "string"]
  ```

  Totality: total
  Visibility: public export
updateAt : (i : Fin k) -> (index i ts -> t) -> HVect ts -> HVect (replaceAt i t ts)
  Update an element in an HVect.
  
  ```idris example
  > updateAt 0 (const True) (the (HVect _) [1, "string"])
  [True, "string"]
  ```

  Totality: total
  Visibility: public export
(++) : HVect ts -> HVect us -> HVect (ts ++ us)
  Append two `HVect`s.
  
  ```idris example
  > (the (HVect _) [1]) ++ (the (HVect _) ["string"])
  [1, "string"]
  ```

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
consInjective1 : x :: xs = y :: ys -> x = y
  Totality: total
  Visibility: public export
consInjective2 : x :: xs = y :: ys -> xs = ys
  Totality: total
  Visibility: public export
interface Shows : (k : Nat) -> Vect k Type -> Type
  Parameters: k, ts
Methods:
  
shows : HVect ts -> Vect k String

Implementations:
  
Shows 0 []
  
(Show t, Shows len ts) => Shows (S len) (t :: ts)
shows : Shows k ts => HVect ts -> Vect k String
  Totality: total
  Visibility: public export
get : (1 _ : HVect ts) -> {auto 1 _ : Elem t ts} -> t
  Extract an arbitrary element of the correct type.
  
  ```idris example
  > get [1, "string"] {p = Here}
  1
  ```

  Totality: total
  Visibility: public export
put : t -> (1 _ : HVect ts) -> {auto 1 _ : Elem t ts} -> HVect ts
  Replace an element with the correct type. (Homogeneous)
  
  ```idris example
  > put 2 [1, "string"]
  [2, "string"]
  ```

  Totality: total
  Visibility: public export
htPut : u -> (1 _ : HVect ts) -> {auto 1 p : Elem t ts} -> HVect (replaceByElem ts p u)
  Replace an element with the correct type. (Heterogeneous)
  
  ```idris example
  > htPut True [1, "string"] {p = Here}
  [True, "string"]
  ```

  Totality: total
  Visibility: public export
update : (t -> t) -> (1 _ : HVect ts) -> {auto 1 _ : Elem t ts} -> HVect ts
  Update an element with the correct type. (Homogeneous)
  
  ```idris example
  > update (const "hello world!") [1, "string"]
  [1, "hello world!"]
  ```

  Totality: total
  Visibility: public export
htUpdate : (t -> u) -> (1 _ : HVect ts) -> {auto 1 p : Elem t ts} -> HVect (replaceByElem ts p u)
  Update an element with the correct type. (Heterogeneous)
  
  ```idris example
  > htUpdate (\_ : String => 2) [1, "string"]
  [1, 2]
  ```

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.IMaybe.html b/contrib/docs/Data.IMaybe.html
index e94fb45935..91e5a270d9 100644
--- a/contrib/docs/Data.IMaybe.html
+++ b/contrib/docs/Data.IMaybe.html
@@ -62,4 +62,4 @@
 
 
 
Data.IMaybe(source)
Version of Maybe indexed by an `isJust' boolean
-
Definitions
data IMaybe : Bool -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Just : a -> IMaybe True a
  
Nothing : IMaybe False a

  Hints:
  
Applicative (IMaybe True)
  
Functor (IMaybe b)
  
Zippable (IMaybe b)
fromJust : IMaybe True a -> a
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
data IMaybe : Bool -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Just : a -> IMaybe True a
  
Nothing : IMaybe False a

  Hints:
  
Applicative (IMaybe True)
  
Functor (IMaybe b)
  
Zippable (IMaybe b)
fromJust : IMaybe True a -> a
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.IOMatrix.html b/contrib/docs/Data.IOMatrix.html
index 1bc93e454b..cc85667890 100644
--- a/contrib/docs/Data.IOMatrix.html
+++ b/contrib/docs/Data.IOMatrix.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.IOMatrix(source)
Definitions
record IOMatrix : Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkIOMatrix : Int -> Int -> ArrayData (Maybe a) -> IOMatrix a

  Projections:
  
.content : IOMatrix a -> ArrayData (Maybe a)
  
.maxHeight : IOMatrix a -> Int
  
.maxWidth : IOMatrix a -> Int
width : IOMatrix a -> Int
  Totality: total
  Visibility: export
height : IOMatrix a -> Int
  Totality: total
  Visibility: export
new : HasIO io => Int -> Int -> io (IOMatrix a)
  Totality: total
  Visibility: export
write : HasIO io => IOMatrix a -> Int -> Int -> a -> io Bool
  Totality: total
  Visibility: export
read : HasIO io => IOMatrix a -> Int -> Int -> io (Maybe a)
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.IOMatrix(source)
Definitions
record IOMatrix : Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkIOMatrix : Int -> Int -> ArrayData (Maybe a) -> IOMatrix a

  Projections:
  
.content : IOMatrix a -> ArrayData (Maybe a)
  
.maxHeight : IOMatrix a -> Int
  
.maxWidth : IOMatrix a -> Int
width : IOMatrix a -> Int
  Totality: total
  Visibility: export
height : IOMatrix a -> Int
  Totality: total
  Visibility: export
new : HasIO io => Int -> Int -> io (IOMatrix a)
  Totality: total
  Visibility: export
write : HasIO io => IOMatrix a -> Int -> Int -> a -> io Bool
  Totality: total
  Visibility: export
read : HasIO io => IOMatrix a -> Int -> Int -> io (Maybe a)
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Int.Order.html b/contrib/docs/Data.Int.Order.html
index 9e5012dd09..e1f735fbfe 100644
--- a/contrib/docs/Data.Int.Order.html
+++ b/contrib/docs/Data.Int.Order.html
@@ -65,4 +65,4 @@
 This is full of tricks as `Int` is a primitive type that can only
 be interacted with using either literals or built-in functions.
 The exported interface should however be safe.
-
Definitions
strictRefl : a = b -> Lazy c -> c
  Pattern-match on an equality proof so that the second argument to
  strictRefl is only returned once the first is canonical.

  Totality: total
  Visibility: export
data LT : Int -> Int -> Type
  `LT a b` is a proof that `a` is less than `b` which is to say that
  the function call `a < b` returns `True`.
  
  NB: we do not re-export the constructor so that users cannot force
  our magic functions to blow up in absurd contexts by bypassing the
  safety measures introduced by the `strictX` functions.
  We do provide functions corresponding to the wrapping and unwrapping
  of `LT` but, crucially, they do not let people force `LT` proofs to
  be in canonical form.

  Totality: total
  Visibility: export
  Constructor: 
MkLT : a < b = True -> LT a b
mkLT : a < b = True -> LT a b
  We may prove `LT a b` by using a proof that `a < b` returns `True`.

  Totality: total
  Visibility: export
runLT : LT a b -> a < b = True
  From a proof that `LT a b`, we may concluded that `a < b` returns `True`.

  Totality: total
  Visibility: export
strictLT : LT a b -> Lazy c -> c
  Do not trust arbitrary `LT` proofs when manufacturing magic ones:
  be strict!

  Totality: total
  Visibility: export
decide : (a : Int) -> (b : Int) -> Dec (LT a b)
  LT is decidable, by virtue of being the reflection of a boolean function

  Totality: total
  Visibility: export
trans : LT a b -> LT b c -> LT a (the Int c)
  LT is a transitive relation. This cannot be proven so we use a magic trick.

  Totality: total
  Visibility: export
irrefl : Not (LT a a)
  LT is an irreflexive relation.
  The crash will never happen because the `LT a a` argument will never reduce
  to a canonical form (unless the built-in function (<) is buggy).

  Totality: total
  Visibility: export
GT : Int -> Int -> Type
  GT is defined in terms of LT to avoid code duplication

  Totality: total
  Visibility: public export
LT_not_GT : LT a b -> Not (GT a b)
  Totality: total
  Visibility: export
GT_not_LT : GT a b -> Not (LT a b)
  Totality: total
  Visibility: export
data EQ : Int -> Int -> Type
  `EQ a b` is a proof that `a` is equal to `b` which is to say that
  the function call `a == b` returns `True`.
  
  NB: we do not re-export the constructor so that users cannot force
  our magic functions to blow up in absurd contexts by bypassing the
  safety measures introduced by the `strictX` functions.
  We do provide functions corresponding to the wrapping and unwrapping
  of `EQ` but, crucially, they do not let people force `EQ` proofs to
  be in canonical form.

  Totality: total
  Visibility: export
  Constructor: 
MkEQ : a == b = True -> EQ a b
mkEQ : a == b = True -> EQ a b
  We may prove `EQ a b` by using a proof that `a == b` returns `True`.

  Totality: total
  Visibility: export
runEQ : EQ a b -> a == b = True
  From a proof that `EQ a b`, we may concluded that `a == b` returns `True`.

  Totality: total
  Visibility: export
strictEQ : EQ a b -> Lazy c -> c
  Do not trust arbitrary `EQ` proofs when manufacturing magic ones:
  be strict!

  Totality: total
  Visibility: export
decide : (a : Int) -> (b : Int) -> Dec (EQ a b)
  EQ is decidable, by virtue of being the reflection of a boolean function

  Totality: total
  Visibility: export
refl : EQ a a
  EQ is a reflexive relation

  Totality: total
  Visibility: export
elimEQ : (0 p : (Int -> Type)) -> EQ a b -> p a -> p b
  EQ is substitutive

  Totality: total
  Visibility: export
reflect : EQ a b -> a = b
  EQ implies propositional equality

  Totality: total
  Visibility: export
sym : EQ a b -> EQ b a
  EQ is a symmetric relation

  Totality: total
  Visibility: export
trans : EQ a b -> EQ b c -> EQ a c
  EQ is a transitive relation

  Totality: total
  Visibility: export
trans_LT_EQ : LT a b -> EQ b c -> LT a c
  Totality: total
  Visibility: export
trans_EQ_LT : EQ a b -> LT b c -> LT a c
  Totality: total
  Visibility: export
LT_not_EQ : LT a b -> Not (EQ a b)
  Totality: total
  Visibility: export
EQ_not_LT : EQ a b -> Not (LT a b)
  Totality: total
  Visibility: export
EQ_not_GT : EQ a b -> Not (GT a b)
  Totality: total
  Visibility: export
GT_not_EQ : GT a b -> Not (EQ a b)
  Totality: total
  Visibility: export
data LTE : Int -> Int -> Type
  `LTE a b` is a proof that `a` is less or equal to `b` which is to say that
  the function call `a < b` or `a == b` returns `True`.
  
  NB: we do not re-export the constructor so that users cannot force
  our magic functions to blow up in absurd contexts by bypassing the
  safety measures introduced by the `strictX` functions.

  Totality: total
  Visibility: export
  Constructors:
  
MkLT : a < b = True -> LTE a b
  
MkEQ : a == b = True -> LTE a b
runLTE : LTE a b -> Either (LT a b) (EQ a b)
  Unwrap an LTE proof to get either an LT or an EQ one

  Totality: total
  Visibility: export
strictLTE : LTE a b -> Lazy c -> c
  Do not trust arbitrary `LTE` proofs when manufacturing magic ones:
  be strict!

  Totality: total
  Visibility: export
decide : (a : Int) -> (b : Int) -> Dec (LTE a b)
  LTE is decidable by virture of both LT and EQ being decidable

  Totality: total
  Visibility: export
refl : LTE a a
  LTE is a reflexive relation

  Totality: total
  Visibility: export
trans_LT_LTE : LT a b -> LTE b c -> LT a c
  Totality: total
  Visibility: export
trans_LTE_LT : LTE a b -> LT b c -> LT a c
  Totality: total
  Visibility: export
inject_LT_LTE : LT a b -> LTE a b
  Totality: total
  Visibility: export
inject_EQ_LTE : EQ a b -> LTE a b
  Totality: total
  Visibility: export
trans : LTE a b -> LTE b c -> LTE a c
  LTE is a transitive relation

  Totality: total
  Visibility: export
antisym : LTE a b -> LTE b a -> EQ a b
  LTE is an antisymmetric relation

  Totality: total
  Visibility: export
GTE : Int -> Int -> Type
  GTE is defined in terms of LTE to avoid code duplication

  Totality: total
  Visibility: public export
trichotomous : (a : Int) -> (b : Int) -> Trichotomous LT EQ GT a b
  Any pair of Ints is related either via LT, EQ, or GT

  Totality: total
  Visibility: export
decide_LT_GTE : (a : Int) -> (b : Int) -> Either (LT a b) (GTE a b)
  Any pair of Ints is related either via LT or GTE

  Totality: total
  Visibility: export
decide_LTE_GT : (a : Int) -> (b : Int) -> Either (LTE a b) (GT a b)
  Any pair of Ints is related either via LTE or GT

  Totality: total
  Visibility: export
suc_LT_LTE : LT a b -> LTE (a + 1) b
  Adding one to a strictly smaller Int, yields a smaller Int

  Totality: total
  Visibility: export
pred_LT_LTE : LT a b -> LTE a (b - 1)
  Subtracting one to a strictly larger Int, yields a larger Int

  Totality: total
  Visibility: export
sucBounded : LT a b -> LT a (a + 1)
  Adding one to an Int yields a strictly larger one,
  provided there is no overflow

  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
strictRefl : a = b -> Lazy c -> c
  Pattern-match on an equality proof so that the second argument to
  strictRefl is only returned once the first is canonical.

  Totality: total
  Visibility: export
data LT : Int -> Int -> Type
  `LT a b` is a proof that `a` is less than `b` which is to say that
  the function call `a < b` returns `True`.
  
  NB: we do not re-export the constructor so that users cannot force
  our magic functions to blow up in absurd contexts by bypassing the
  safety measures introduced by the `strictX` functions.
  We do provide functions corresponding to the wrapping and unwrapping
  of `LT` but, crucially, they do not let people force `LT` proofs to
  be in canonical form.

  Totality: total
  Visibility: export
  Constructor: 
MkLT : a < b = True -> LT a b
mkLT : a < b = True -> LT a b
  We may prove `LT a b` by using a proof that `a < b` returns `True`.

  Totality: total
  Visibility: export
runLT : LT a b -> a < b = True
  From a proof that `LT a b`, we may concluded that `a < b` returns `True`.

  Totality: total
  Visibility: export
strictLT : LT a b -> Lazy c -> c
  Do not trust arbitrary `LT` proofs when manufacturing magic ones:
  be strict!

  Totality: total
  Visibility: export
decide : (a : Int) -> (b : Int) -> Dec (LT a b)
  LT is decidable, by virtue of being the reflection of a boolean function

  Totality: total
  Visibility: export
trans : LT a b -> LT b c -> LT a (the Int c)
  LT is a transitive relation. This cannot be proven so we use a magic trick.

  Totality: total
  Visibility: export
irrefl : Not (LT a a)
  LT is an irreflexive relation.
  The crash will never happen because the `LT a a` argument will never reduce
  to a canonical form (unless the built-in function (<) is buggy).

  Totality: total
  Visibility: export
GT : Int -> Int -> Type
  GT is defined in terms of LT to avoid code duplication

  Totality: total
  Visibility: public export
LT_not_GT : LT a b -> Not (GT a b)
  Totality: total
  Visibility: export
GT_not_LT : GT a b -> Not (LT a b)
  Totality: total
  Visibility: export
data EQ : Int -> Int -> Type
  `EQ a b` is a proof that `a` is equal to `b` which is to say that
  the function call `a == b` returns `True`.
  
  NB: we do not re-export the constructor so that users cannot force
  our magic functions to blow up in absurd contexts by bypassing the
  safety measures introduced by the `strictX` functions.
  We do provide functions corresponding to the wrapping and unwrapping
  of `EQ` but, crucially, they do not let people force `EQ` proofs to
  be in canonical form.

  Totality: total
  Visibility: export
  Constructor: 
MkEQ : a == b = True -> EQ a b
mkEQ : a == b = True -> EQ a b
  We may prove `EQ a b` by using a proof that `a == b` returns `True`.

  Totality: total
  Visibility: export
runEQ : EQ a b -> a == b = True
  From a proof that `EQ a b`, we may concluded that `a == b` returns `True`.

  Totality: total
  Visibility: export
strictEQ : EQ a b -> Lazy c -> c
  Do not trust arbitrary `EQ` proofs when manufacturing magic ones:
  be strict!

  Totality: total
  Visibility: export
decide : (a : Int) -> (b : Int) -> Dec (EQ a b)
  EQ is decidable, by virtue of being the reflection of a boolean function

  Totality: total
  Visibility: export
refl : EQ a a
  EQ is a reflexive relation

  Totality: total
  Visibility: export
elimEQ : (0 p : (Int -> Type)) -> EQ a b -> p a -> p b
  EQ is substitutive

  Totality: total
  Visibility: export
reflect : EQ a b -> a = b
  EQ implies propositional equality

  Totality: total
  Visibility: export
sym : EQ a b -> EQ b a
  EQ is a symmetric relation

  Totality: total
  Visibility: export
trans : EQ a b -> EQ b c -> EQ a c
  EQ is a transitive relation

  Totality: total
  Visibility: export
trans_LT_EQ : LT a b -> EQ b c -> LT a c
  Totality: total
  Visibility: export
trans_EQ_LT : EQ a b -> LT b c -> LT a c
  Totality: total
  Visibility: export
LT_not_EQ : LT a b -> Not (EQ a b)
  Totality: total
  Visibility: export
EQ_not_LT : EQ a b -> Not (LT a b)
  Totality: total
  Visibility: export
EQ_not_GT : EQ a b -> Not (GT a b)
  Totality: total
  Visibility: export
GT_not_EQ : GT a b -> Not (EQ a b)
  Totality: total
  Visibility: export
data LTE : Int -> Int -> Type
  `LTE a b` is a proof that `a` is less or equal to `b` which is to say that
  the function call `a < b` or `a == b` returns `True`.
  
  NB: we do not re-export the constructor so that users cannot force
  our magic functions to blow up in absurd contexts by bypassing the
  safety measures introduced by the `strictX` functions.

  Totality: total
  Visibility: export
  Constructors:
  
MkLT : a < b = True -> LTE a b
  
MkEQ : a == b = True -> LTE a b
runLTE : LTE a b -> Either (LT a b) (EQ a b)
  Unwrap an LTE proof to get either an LT or an EQ one

  Totality: total
  Visibility: export
strictLTE : LTE a b -> Lazy c -> c
  Do not trust arbitrary `LTE` proofs when manufacturing magic ones:
  be strict!

  Totality: total
  Visibility: export
decide : (a : Int) -> (b : Int) -> Dec (LTE a b)
  LTE is decidable by virture of both LT and EQ being decidable

  Totality: total
  Visibility: export
refl : LTE a a
  LTE is a reflexive relation

  Totality: total
  Visibility: export
trans_LT_LTE : LT a b -> LTE b c -> LT a c
  Totality: total
  Visibility: export
trans_LTE_LT : LTE a b -> LT b c -> LT a c
  Totality: total
  Visibility: export
inject_LT_LTE : LT a b -> LTE a b
  Totality: total
  Visibility: export
inject_EQ_LTE : EQ a b -> LTE a b
  Totality: total
  Visibility: export
trans : LTE a b -> LTE b c -> LTE a c
  LTE is a transitive relation

  Totality: total
  Visibility: export
antisym : LTE a b -> LTE b a -> EQ a b
  LTE is an antisymmetric relation

  Totality: total
  Visibility: export
GTE : Int -> Int -> Type
  GTE is defined in terms of LTE to avoid code duplication

  Totality: total
  Visibility: public export
trichotomous : (a : Int) -> (b : Int) -> Trichotomous LT EQ GT a b
  Any pair of Ints is related either via LT, EQ, or GT

  Totality: total
  Visibility: export
decide_LT_GTE : (a : Int) -> (b : Int) -> Either (LT a b) (GTE a b)
  Any pair of Ints is related either via LT or GTE

  Totality: total
  Visibility: export
decide_LTE_GT : (a : Int) -> (b : Int) -> Either (LTE a b) (GT a b)
  Any pair of Ints is related either via LTE or GT

  Totality: total
  Visibility: export
suc_LT_LTE : LT a b -> LTE (a + 1) b
  Adding one to a strictly smaller Int, yields a smaller Int

  Totality: total
  Visibility: export
pred_LT_LTE : LT a b -> LTE a (b - 1)
  Subtracting one to a strictly larger Int, yields a larger Int

  Totality: total
  Visibility: export
sucBounded : LT a b -> LT a (a + 1)
  Adding one to an Int yields a strictly larger one,
  provided there is no overflow

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Late.html b/contrib/docs/Data.Late.html
index 131e6ebfd3..4ee8ea5e3a 100644
--- a/contrib/docs/Data.Late.html
+++ b/contrib/docs/Data.Late.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Late(source)
Definitions
data Late : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Now : a -> Late a
  
Later : Inf (Late a) -> Late a

  Hints:
  
Applicative Late
  
Functor Late
  
Monad Late
never : Late a
  Never return

  Totality: total
  Visibility: public export
unfold : (seed -> Either seed value) -> seed -> Late value
  Run a small state machine until it reaches a final state and yields a value.

  Totality: total
  Visibility: public export
bind : Late a -> (a -> Late b) -> Late b
  It's easier to define map and (<*>) in terms of bind so let's start
  by defining it.

  Totality: total
  Visibility: public export
isNow : Late a -> Maybe a
  Check whether we already have a value.

  Totality: total
  Visibility: public export
wait : Late a -> Late a
  Wait for one tick, hoping to get a value.

  Totality: total
  Visibility: public export
engine : Nat -> Late a -> Late a
  Wait for a set number of ticks.

  Totality: total
  Visibility: public export
petrol : Nat -> Late a -> Maybe a
  Wait for a set number of ticks, hoping to get a value.

  Totality: total
  Visibility: public export
accelerate : Late a -> Late a
  Accelerate makes things happen twice as fast.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Late(source)
Definitions
data Late : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Now : a -> Late a
  
Later : Inf (Late a) -> Late a

  Hints:
  
Applicative Late
  
Functor Late
  
Monad Late
never : Late a
  Never return

  Totality: total
  Visibility: public export
unfold : (seed -> Either seed value) -> seed -> Late value
  Run a small state machine until it reaches a final state and yields a value.

  Totality: total
  Visibility: public export
bind : Late a -> (a -> Late b) -> Late b
  It's easier to define map and (<*>) in terms of bind so let's start
  by defining it.

  Totality: total
  Visibility: public export
isNow : Late a -> Maybe a
  Check whether we already have a value.

  Totality: total
  Visibility: public export
wait : Late a -> Late a
  Wait for one tick, hoping to get a value.

  Totality: total
  Visibility: public export
engine : Nat -> Late a -> Late a
  Wait for a set number of ticks.

  Totality: total
  Visibility: public export
petrol : Nat -> Late a -> Maybe a
  Wait for a set number of ticks, hoping to get a value.

  Totality: total
  Visibility: public export
accelerate : Late a -> Late a
  Accelerate makes things happen twice as fast.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.Linear.Array.html b/contrib/docs/Data.Linear.Array.html
index cb22c136ae..8cc22ac5cd 100644
--- a/contrib/docs/Data.Linear.Array.html
+++ b/contrib/docs/Data.Linear.Array.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Linear.Array(source)
Definitions
interface Array : (Type -> Type) -> Type
  Parameters: arr
Methods:
  
read : (1 _ : arr t) -> Int -> Maybe t
  
size : (1 _ : arr t) -> Int

Implementations:
  
Array LinArray
  
Array IArray
read : Array arr => (1 _ : arr t) -> Int -> Maybe t
  Visibility: public export
size : Array arr => (1 _ : arr t) -> Int
  Visibility: public export
interface MArray : (Type -> Type) -> Type
  Parameters: arr
Constraints: Array arr
Methods:
  
newArray : Int -> (1 _ : ((1 _ : arr t) -> a)) -> a
  
write : (1 _ : arr t) -> Int -> t -> Res Bool (const (arr t))
  
mread : (1 _ : arr t) -> Int -> Res (Maybe t) (const (arr t))
  
msize : (1 _ : arr t) -> Res Int (const (arr t))

Implementation: 
MArray LinArray
newArray : MArray arr => Int -> (1 _ : ((1 _ : arr t) -> a)) -> a
  Visibility: public export
write : MArray arr => (1 _ : arr t) -> Int -> t -> Res Bool (const (arr t))
  Visibility: public export
mread : MArray arr => (1 _ : arr t) -> Int -> Res (Maybe t) (const (arr t))
  Visibility: public export
msize : MArray arr => (1 _ : arr t) -> Res Int (const (arr t))
  Visibility: public export
data IArray : Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkIArray : IOArray t -> IArray t

  Hint: 
Array IArray
data LinArray : Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkLinArray : IOArray t -> LinArray t

  Hints:
  
Array LinArray
  
MArray LinArray
toIArray : (1 _ : LinArray t) -> (IArray t -> a) -> a
  Visibility: export
copyArray : MArray arr => Int -> (1 _ : arr t) -> LPair (arr t) (arr t)
  Visibility: export

\ No newline at end of file
+
Data.Linear.Array(source)
Definitions
interface Array : (Type -> Type) -> Type
  Parameters: arr
Methods:
  
read : (1 _ : arr t) -> Int -> Maybe t
  
size : (1 _ : arr t) -> Int

Implementations:
  
Array LinArray
  
Array IArray
read : Array arr => (1 _ : arr t) -> Int -> Maybe t
  Visibility: public export
size : Array arr => (1 _ : arr t) -> Int
  Visibility: public export
interface MArray : (Type -> Type) -> Type
  Parameters: arr
Constraints: Array arr
Methods:
  
newArray : Int -> (1 _ : ((1 _ : arr t) -> a)) -> a
  
write : (1 _ : arr t) -> Int -> t -> Res Bool (const (arr t))
  
mread : (1 _ : arr t) -> Int -> Res (Maybe t) (const (arr t))
  
msize : (1 _ : arr t) -> Res Int (const (arr t))

Implementation: 
MArray LinArray
newArray : MArray arr => Int -> (1 _ : ((1 _ : arr t) -> a)) -> a
  Visibility: public export
write : MArray arr => (1 _ : arr t) -> Int -> t -> Res Bool (const (arr t))
  Visibility: public export
mread : MArray arr => (1 _ : arr t) -> Int -> Res (Maybe t) (const (arr t))
  Visibility: public export
msize : MArray arr => (1 _ : arr t) -> Res Int (const (arr t))
  Visibility: public export
data IArray : Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkIArray : IOArray t -> IArray t

  Hint: 
Array IArray
data LinArray : Type -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkLinArray : IOArray t -> LinArray t

  Hints:
  
Array LinArray
  
MArray LinArray
toIArray : (1 _ : LinArray t) -> (IArray t -> a) -> a
  Visibility: export
copyArray : MArray arr => Int -> (1 _ : arr t) -> LPair (arr t) (arr t)
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.List.Algebra.html b/contrib/docs/Data.List.Algebra.html
index ff7651158c..a145c28d36 100644
--- a/contrib/docs/Data.List.Algebra.html
+++ b/contrib/docs/Data.List.Algebra.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List.Algebra(source)
Definitions

\ No newline at end of file
+
Data.List.Algebra(source)
Definitions

\ No newline at end of file
diff --git a/contrib/docs/Data.List.Alternating.html b/contrib/docs/Data.List.Alternating.html
index f7b39b97c8..49bccd9069 100644
--- a/contrib/docs/Data.List.Alternating.html
+++ b/contrib/docs/Data.List.Alternating.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List.Alternating(source)
Definitions
data Odd : Type -> Type -> Type
  Non-empty list, starting and ending with an a, where adjacent elements alternate
  between types a and b.
  We can think of this type as:
  - A fence, with the `a`s as fence-posts, and the `b`s as panels.
  - A non-empty list of `a`s, separated by `b`s
  - A list of `b`s, separated by, and surrounded by, `a`s
  - The free extension of a monoid `a`, with variables in `b`

  Totality: total
  Visibility: public export
  Constructor: 
(::) : a -> Even b a -> Odd a b

  Hints:
  
Monoid a => Alternative (Odd a)
  
Monoid a => Applicative (Odd a)
  
Bifoldable Odd
  
Bifunctor Odd
  
Bitraversable Odd
  
Eq a => Eq b => Eq (Odd a b)
  
Foldable (Odd a)
  
Functor (Odd a)
  
Monoid a => Monoid (Odd a b)
  
Ord a => Ord b => Ord (Odd a b)
  
Semigroup a => Semigroup (Odd a b)
  
Show a => Show b => Show (Odd a b)
  
Traversable (Odd a)
data Even : Type -> Type -> Type
  A list, starting with an a, and ending with a b; where adjacent elements
  alternate between types a and b.
  Equivalent to List (a, b)

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Even a b
  
(::) : a -> Odd b a -> Even a b

  Hints:
  
Bifoldable Even
  
Bifunctor Even
  
Bitraversable Even
  
Eq a => Eq b => Eq (Even a b)
  
Monoid (Even a b)
  
Ord a => Ord b => Ord (Even a b)
  
Semigroup (Even a b)
  
Show a => Show b => Show (Even a b)
(++) : Odd a b -> Odd b a -> Even a b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
(++) : Even a b -> Odd a b -> Odd a b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
(++) : Even a b -> Even a b -> Even a b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
(++) : Odd a b -> Even b a -> Odd a b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
(+>) : Semigroup a => Odd a b -> a -> Odd a b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 5
(<+) : Semigroup a => a -> Odd a b -> Odd a b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 5
singleton : a -> Odd a b
  Totality: total
  Visibility: public export
flatten : Odd (Odd a b) b -> Odd a b
  Totality: total
  Visibility: public export
(>>=) : Monoid a => Odd a b -> (b -> Odd a c) -> Odd a c
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
(>>=) : Odd a c -> (a -> Odd b c) -> Odd b c
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
odds : Odd a b -> List a
  Totality: total
  Visibility: public export
evens : Even a b -> List b
  Totality: total
  Visibility: public export
evens : Odd a b -> List b
  Totality: total
  Visibility: public export
odds : Even a b -> List a
  Totality: total
  Visibility: public export
forget : Odd a a -> List a
  Totality: total
  Visibility: public export
forget : Even a a -> List a
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.List.Alternating(source)
Definitions
data Odd : Type -> Type -> Type
  Non-empty list, starting and ending with an a, where adjacent elements alternate
  between types a and b.
  We can think of this type as:
  - A fence, with the `a`s as fence-posts, and the `b`s as panels.
  - A non-empty list of `a`s, separated by `b`s
  - A list of `b`s, separated by, and surrounded by, `a`s
  - The free extension of a monoid `a`, with variables in `b`

  Totality: total
  Visibility: public export
  Constructor: 
(::) : a -> Even b a -> Odd a b

  Hints:
  
Monoid a => Alternative (Odd a)
  
Monoid a => Applicative (Odd a)
  
Bifoldable Odd
  
Bifunctor Odd
  
Bitraversable Odd
  
Eq a => Eq b => Eq (Odd a b)
  
Foldable (Odd a)
  
Functor (Odd a)
  
Monoid a => Monoid (Odd a b)
  
Ord a => Ord b => Ord (Odd a b)
  
Semigroup a => Semigroup (Odd a b)
  
Show a => Show b => Show (Odd a b)
  
Traversable (Odd a)
data Even : Type -> Type -> Type
  A list, starting with an a, and ending with a b; where adjacent elements
  alternate between types a and b.
  Equivalent to List (a, b)

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Even a b
  
(::) : a -> Odd b a -> Even a b

  Hints:
  
Bifoldable Even
  
Bifunctor Even
  
Bitraversable Even
  
Eq a => Eq b => Eq (Even a b)
  
Monoid (Even a b)
  
Ord a => Ord b => Ord (Even a b)
  
Semigroup (Even a b)
  
Show a => Show b => Show (Even a b)
(++) : Odd a b -> Odd b a -> Even a b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
(++) : Even a b -> Odd a b -> Odd a b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
(++) : Even a b -> Even a b -> Even a b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
(++) : Odd a b -> Even b a -> Odd a b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
(+>) : Semigroup a => Odd a b -> a -> Odd a b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 5
(<+) : Semigroup a => a -> Odd a b -> Odd a b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 5
singleton : a -> Odd a b
  Totality: total
  Visibility: public export
flatten : Odd (Odd a b) b -> Odd a b
  Totality: total
  Visibility: public export
(>>=) : Monoid a => Odd a b -> (b -> Odd a c) -> Odd a c
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
(>>=) : Odd a c -> (a -> Odd b c) -> Odd b c
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
odds : Odd a b -> List a
  Totality: total
  Visibility: public export
evens : Even a b -> List b
  Totality: total
  Visibility: public export
evens : Odd a b -> List b
  Totality: total
  Visibility: public export
odds : Even a b -> List a
  Totality: total
  Visibility: public export
forget : Odd a a -> List a
  Totality: total
  Visibility: public export
forget : Even a a -> List a
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.List.AtIndex.html b/contrib/docs/Data.List.AtIndex.html
index db5ba5effe..224fe94b19 100644
--- a/contrib/docs/Data.List.AtIndex.html
+++ b/contrib/docs/Data.List.AtIndex.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List.AtIndex(source)
Definitions
data AtIndex : a -> List a -> Nat -> Type
  @AtIndex witnesses the fact that a natural number encodes a membership proof.
  It is meant to be used as a runtime-irrelevant gadget to guarantee that the
  natural number is indeed a valid index.

  Totality: total
  Visibility: public export
  Constructors:
  
Z : AtIndex a (a :: as) 0
  
S : AtIndex a as n -> AtIndex a (b :: as) (S n)

  Hint: 
Uninhabited (AtIndex a [] n)
inverseZ : AtIndex x (y :: xs) 0 -> x = y
  Inversion principle for Z constructor

  Totality: total
  Visibility: export
inverseS : AtIndex x (y :: xs) (S n) -> AtIndex x xs n
  inversion principle for S constructor

  Totality: total
  Visibility: export
atIndexUnique : AtIndex a as n -> AtIndex b as n -> a = b
  For a given list and a given index, there is only one possible value
  stored at that index in that list

  Totality: total
  Visibility: export
find : DecEq a => (x : a) -> (xs : List a) -> Dec (Subset Nat (AtIndex x xs))
  Provided that equality is decidable, we can look for the first occurence
  of a value inside of a list

  Totality: total
  Visibility: public export
interface Member : a -> List a -> Type
  If the equality is not decidable, we may instead rely on interface resolution

  Parameters: t, ts
Methods:
  
isMember' : Subset Nat (AtIndex t ts)

Implementations:
  
Member t (t :: ts)
  
Member t ts => Member t (u :: ts)
isMember' : Member t ts => Subset Nat (AtIndex t ts)
  Totality: total
  Visibility: public export
isMember : (0 t : a) -> (0 ts : List a) -> Member t ts => Subset Nat (AtIndex t ts)
  Totality: total
  Visibility: public export
lookup : (n : Nat) -> (xs : List a) -> Dec (Subset a (\x => AtIndex x xs n))
  Given an index, we can decide whether there is a value corresponding to it

  Totality: total
  Visibility: public export
inRange : (n : Nat) -> (xs : List a) -> (0 _ : AtIndex x xs n) -> LTE n (length xs)
  An AtIndex proof implies that n is less than the length of the list indexed into

  Totality: total
  Visibility: public export
weakenR : AtIndex x xs n -> AtIndex x (xs ++ ys) n
  

  Totality: total
  Visibility: export
weakenL : (p : Subset Nat (flip HasLength ws)) -> AtIndex x xs n -> AtIndex x (ws ++ xs) (fst p + n)
  Totality: total
  Visibility: export
strengthenL : (p : Subset Nat (flip HasLength xs)) -> lt n (fst p) = True -> AtIndex x (xs ++ ys) n -> AtIndex x xs n
  Totality: total
  Visibility: export
strengthenR : (p : Subset Nat (flip HasLength ws)) -> lte (fst p) n = True -> AtIndex x (ws ++ xs) n -> AtIndex x xs (minus n (fst p))
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.List.AtIndex(source)
Definitions
data AtIndex : a -> List a -> Nat -> Type
  @AtIndex witnesses the fact that a natural number encodes a membership proof.
  It is meant to be used as a runtime-irrelevant gadget to guarantee that the
  natural number is indeed a valid index.

  Totality: total
  Visibility: public export
  Constructors:
  
Z : AtIndex a (a :: as) 0
  
S : AtIndex a as n -> AtIndex a (b :: as) (S n)

  Hint: 
Uninhabited (AtIndex a [] n)
inverseZ : AtIndex x (y :: xs) 0 -> x = y
  Inversion principle for Z constructor

  Totality: total
  Visibility: export
inverseS : AtIndex x (y :: xs) (S n) -> AtIndex x xs n
  inversion principle for S constructor

  Totality: total
  Visibility: export
atIndexUnique : AtIndex a as n -> AtIndex b as n -> a = b
  For a given list and a given index, there is only one possible value
  stored at that index in that list

  Totality: total
  Visibility: export
find : DecEq a => (x : a) -> (xs : List a) -> Dec (Subset Nat (AtIndex x xs))
  Provided that equality is decidable, we can look for the first occurence
  of a value inside of a list

  Totality: total
  Visibility: public export
interface Member : a -> List a -> Type
  If the equality is not decidable, we may instead rely on interface resolution

  Parameters: t, ts
Methods:
  
isMember' : Subset Nat (AtIndex t ts)

Implementations:
  
Member t (t :: ts)
  
Member t ts => Member t (u :: ts)
isMember' : Member t ts => Subset Nat (AtIndex t ts)
  Totality: total
  Visibility: public export
isMember : (0 t : a) -> (0 ts : List a) -> Member t ts => Subset Nat (AtIndex t ts)
  Totality: total
  Visibility: public export
lookup : (n : Nat) -> (xs : List a) -> Dec (Subset a (\x => AtIndex x xs n))
  Given an index, we can decide whether there is a value corresponding to it

  Totality: total
  Visibility: public export
inRange : (n : Nat) -> (xs : List a) -> (0 _ : AtIndex x xs n) -> LTE n (length xs)
  An AtIndex proof implies that n is less than the length of the list indexed into

  Totality: total
  Visibility: public export
weakenR : AtIndex x xs n -> AtIndex x (xs ++ ys) n
  

  Totality: total
  Visibility: export
weakenL : (p : Subset Nat (flip HasLength ws)) -> AtIndex x xs n -> AtIndex x (ws ++ xs) (fst p + n)
  Totality: total
  Visibility: export
strengthenL : (p : Subset Nat (flip HasLength xs)) -> lt n (fst p) = True -> AtIndex x (xs ++ ys) n -> AtIndex x xs n
  Totality: total
  Visibility: export
strengthenR : (p : Subset Nat (flip HasLength ws)) -> lte (fst p) n = True -> AtIndex x (ws ++ xs) n -> AtIndex x xs (minus n (fst p))
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.List.Elem.Extra.html b/contrib/docs/Data.List.Elem.Extra.html
index c957e33619..ee54c94a10 100644
--- a/contrib/docs/Data.List.Elem.Extra.html
+++ b/contrib/docs/Data.List.Elem.Extra.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List.Elem.Extra(source)
Definitions
elemAppLeft : (xs : List a) -> (ys : List a) -> Elem x xs -> Elem x (xs ++ ys)
  Proof that an element is still inside a list if we append to it.

  Totality: total
  Visibility: public export
elemAppRight : (ys : List a) -> (xs : List a) -> Elem x xs -> Elem x (ys ++ xs)
  Proof that an element is still inside a list if we prepend to it.

  Totality: total
  Visibility: public export
elemAppLorR : (xs : List a) -> (ys : List a) -> Elem k (xs ++ ys) -> Either (Elem k xs) (Elem k ys)
  Proof that membership on append implies membership in left or right sublist.

  Totality: total
  Visibility: public export
notElemAppLeft : (xs : List a) -> (ys : List a) -> Not (Elem x (xs ++ ys)) -> Not (Elem x xs)
  Proof that x is not in (xs ++ ys) implies proof that x is not in xs.

  Totality: total
  Visibility: public export
notElemAppRight : (ys : List a) -> (xs : List a) -> Not (Elem x (xs ++ ys)) -> Not (Elem x ys)
  Proof that x is not in (xs ++ ys) implies proof that x is not in ys.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.List.Elem.Extra(source)
Definitions
elemAppLeft : (xs : List a) -> (ys : List a) -> Elem x xs -> Elem x (xs ++ ys)
  Proof that an element is still inside a list if we append to it.

  Totality: total
  Visibility: public export
elemAppRight : (ys : List a) -> (xs : List a) -> Elem x xs -> Elem x (ys ++ xs)
  Proof that an element is still inside a list if we prepend to it.

  Totality: total
  Visibility: public export
elemAppLorR : (xs : List a) -> (ys : List a) -> Elem k (xs ++ ys) -> Either (Elem k xs) (Elem k ys)
  Proof that membership on append implies membership in left or right sublist.

  Totality: total
  Visibility: public export
notElemAppLeft : (xs : List a) -> (ys : List a) -> Not (Elem x (xs ++ ys)) -> Not (Elem x xs)
  Proof that x is not in (xs ++ ys) implies proof that x is not in xs.

  Totality: total
  Visibility: public export
notElemAppRight : (ys : List a) -> (xs : List a) -> Not (Elem x (xs ++ ys)) -> Not (Elem x ys)
  Proof that x is not in (xs ++ ys) implies proof that x is not in ys.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.List.Equalities.html b/contrib/docs/Data.List.Equalities.html
index 797ea31b12..3d73059435 100644
--- a/contrib/docs/Data.List.Equalities.html
+++ b/contrib/docs/Data.List.Equalities.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List.Equalities(source)
Definitions
snocNonEmpty : Not (xs ++ [x] = [])
  A list constructued using snoc cannot be empty.

  Totality: total
  Visibility: export
SnocNonEmpty : (xs : List a) -> (x : a) -> NonEmpty (snoc xs x)
  Proof that snoc'ed list is not empty in terms of `NonEmpty`.

  Totality: total
  Visibility: export
consCong2 : x = y -> xs = ys -> x :: xs = y :: ys
  Two lists are equal, if their heads are equal and their tails are equal.

  Totality: total
  Visibility: export
snocInjective : snoc xs x = snoc ys y -> (xs = ys, x = y)
  Equal non-empty lists should result in equal components after destructuring 'snoc'.

  Totality: total
  Visibility: export
appendCong2 : x1 = y1 -> x2 = y2 -> x1 ++ x2 = y1 ++ y2
  Appending pairwise equal lists gives equal lists

  Totality: total
  Visibility: export
mapDistributesOverAppend : (f : (a -> b)) -> (xs : List a) -> (ys : List a) -> map f (xs ++ ys) = map f xs ++ map f ys
  List.map is distributive over appending.

  Totality: total
  Visibility: export
lengthDistributesOverAppend : (xs : List a) -> (ys : List a) -> length (xs ++ ys) = length xs + length ys
  List.length is distributive over appending.

  Totality: total
  Visibility: export
lengthSnoc : (x : a) -> (xs : List a) -> length (snoc xs x) = S (length xs)
  Length of a snoc'd list is the same as Succ of length list.

  Totality: total
  Visibility: export
appendSameLeftInjective : (xs : List a) -> (ys : List a) -> (zs : List a) -> zs ++ xs = zs ++ ys -> xs = ys
  Appending the same list at left is injective.

  Totality: total
  Visibility: export
appendSameRightInjective : (xs : List a) -> (ys : List a) -> (zs : List a) -> xs ++ zs = ys ++ zs -> xs = ys
  Appending the same list at right is injective.

  Totality: total
  Visibility: export
appendNonEmptyLeftNotEq : (zs : List a) -> (xs : List a) -> NonEmpty xs => Not (zs = xs ++ zs)
  List cannot be equal to itself prepended with some non-empty list.

  Totality: total
  Visibility: export
appendNonEmptyRightNotEq : (zs : List a) -> (xs : List a) -> NonEmpty xs => Not (zs = zs ++ xs)
  List cannot be equal to itself appended with some non-empty list.

  Totality: total
  Visibility: export
bindConcatPrf : (xs : List a) -> (x : a) -> (f : (a -> List b)) -> (x :: xs) >>= f = f x ++ (xs >>= f)
  Proof of correspondence between list bind and concatenation.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.List.Equalities(source)
Definitions
snocNonEmpty : Not (xs ++ [x] = [])
  A list constructued using snoc cannot be empty.

  Totality: total
  Visibility: export
SnocNonEmpty : (xs : List a) -> (x : a) -> NonEmpty (snoc xs x)
  Proof that snoc'ed list is not empty in terms of `NonEmpty`.

  Totality: total
  Visibility: export
consCong2 : x = y -> xs = ys -> x :: xs = y :: ys
  Two lists are equal, if their heads are equal and their tails are equal.

  Totality: total
  Visibility: export
snocInjective : snoc xs x = snoc ys y -> (xs = ys, x = y)
  Equal non-empty lists should result in equal components after destructuring 'snoc'.

  Totality: total
  Visibility: export
appendCong2 : x1 = y1 -> x2 = y2 -> x1 ++ x2 = y1 ++ y2
  Appending pairwise equal lists gives equal lists

  Totality: total
  Visibility: export
mapDistributesOverAppend : (f : (a -> b)) -> (xs : List a) -> (ys : List a) -> map f (xs ++ ys) = map f xs ++ map f ys
  List.map is distributive over appending.

  Totality: total
  Visibility: export
lengthDistributesOverAppend : (xs : List a) -> (ys : List a) -> length (xs ++ ys) = length xs + length ys
  List.length is distributive over appending.

  Totality: total
  Visibility: export
lengthSnoc : (x : a) -> (xs : List a) -> length (snoc xs x) = S (length xs)
  Length of a snoc'd list is the same as Succ of length list.

  Totality: total
  Visibility: export
appendSameLeftInjective : (xs : List a) -> (ys : List a) -> (zs : List a) -> zs ++ xs = zs ++ ys -> xs = ys
  Appending the same list at left is injective.

  Totality: total
  Visibility: export
appendSameRightInjective : (xs : List a) -> (ys : List a) -> (zs : List a) -> xs ++ zs = ys ++ zs -> xs = ys
  Appending the same list at right is injective.

  Totality: total
  Visibility: export
appendNonEmptyLeftNotEq : (zs : List a) -> (xs : List a) -> NonEmpty xs => Not (zs = xs ++ zs)
  List cannot be equal to itself prepended with some non-empty list.

  Totality: total
  Visibility: export
appendNonEmptyRightNotEq : (zs : List a) -> (xs : List a) -> NonEmpty xs => Not (zs = zs ++ xs)
  List cannot be equal to itself appended with some non-empty list.

  Totality: total
  Visibility: export
bindConcatPrf : (xs : List a) -> (x : a) -> (f : (a -> List b)) -> (x :: xs) >>= f = f x ++ (xs >>= f)
  Proof of correspondence between list bind and concatenation.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.List.Extra.html b/contrib/docs/Data.List.Extra.html
index 26a1e88ce2..69f91263ec 100644
--- a/contrib/docs/Data.List.Extra.html
+++ b/contrib/docs/Data.List.Extra.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List.Extra(source)
Definitions
mapi : (Nat -> a -> b) -> List a -> List b
  Analogous to `map` for `List`, but the function is applied to the index of
  the element as first argument (counting from 0), and the element itself as
  second argument.

  Totality: total
  Visibility: public export
filterLoc : (a -> Bool) -> List a -> (List a, List Nat)
  Applied to a predicate and a list, returns the list of those elements that
  satisfy the predicate with corresponding indices in a stand-alone list.
  See also `Data.List.Extra.filterLoc'`.

  Totality: total
  Visibility: public export
filterLoc' : (a -> Bool) -> List a -> List (a, Nat)
  Applied to a predicate and a list, returns the list of those elements that
  satisfy the predicate with corresponding indices.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.List.Extra(source)
Definitions
mapi : (Nat -> a -> b) -> List a -> List b
  Analogous to `map` for `List`, but the function is applied to the index of
  the element as first argument (counting from 0), and the element itself as
  second argument.

  Totality: total
  Visibility: public export
filterLoc : (a -> Bool) -> List a -> (List a, List Nat)
  Applied to a predicate and a list, returns the list of those elements that
  satisfy the predicate with corresponding indices in a stand-alone list.
  See also `Data.List.Extra.filterLoc'`.

  Totality: total
  Visibility: public export
filterLoc' : (a -> Bool) -> List a -> List (a, Nat)
  Applied to a predicate and a list, returns the list of those elements that
  satisfy the predicate with corresponding indices.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.List.Palindrome.html b/contrib/docs/Data.List.Palindrome.html
index 6a53b08b18..9b9f6fe69f 100644
--- a/contrib/docs/Data.List.Palindrome.html
+++ b/contrib/docs/Data.List.Palindrome.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List.Palindrome(source)
Definitions
data Palindrome : List a -> Type
  Do geese see God?

  Totality: total
  Visibility: public export
  Constructors:
  
Empty : Palindrome []
  
Single : Palindrome [{_:5373}]
  
Multi : Palindrome xs -> Palindrome (x :: snoc xs x)
palindromeReverse : (xs : List a) -> Palindrome xs -> reverse xs = xs
  A Palindrome reversed is itself.

  Totality: total
  Visibility: export
reversePalindrome : (xs : List a) -> reverse xs = xs -> Palindrome xs
  Only Palindromes are equal to their own reverse.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.List.Palindrome(source)
Definitions
data Palindrome : List a -> Type
  Do geese see God?

  Totality: total
  Visibility: public export
  Constructors:
  
Empty : Palindrome []
  
Single : Palindrome [{_:5373}]
  
Multi : Palindrome xs -> Palindrome (x :: snoc xs x)
palindromeReverse : (xs : List a) -> Palindrome xs -> reverse xs = xs
  A Palindrome reversed is itself.

  Totality: total
  Visibility: export
reversePalindrome : (xs : List a) -> reverse xs = xs -> Palindrome xs
  Only Palindromes are equal to their own reverse.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.List.Reverse.html b/contrib/docs/Data.List.Reverse.html
index ce7f6bf3a1..16bc75b34b 100644
--- a/contrib/docs/Data.List.Reverse.html
+++ b/contrib/docs/Data.List.Reverse.html
@@ -62,4 +62,4 @@
 
 
 
Data.List.Reverse(source)
Properties of the reverse function.
-
Definitions
reverseOntoAcc : (xs : List a) -> (ys : List a) -> (zs : List a) -> reverseOnto (ys ++ zs) xs = reverseOnto ys xs ++ zs
  Totality: total
  Visibility: export
reverseOntoSpec : (xs : List a) -> (ys : List a) -> reverseOnto xs ys = reverse ys ++ xs
  Serves as a specification for reverseOnto.

  Totality: total
  Visibility: export
reverseNil : reverse [] = []
  The reverse of an empty list is an empty list.  Together with reverseCons,
  serves as a specification for reverse.

  Totality: total
  Visibility: export
reverseCons : (x : a) -> (xs : List a) -> reverse (x :: xs) = snoc (reverse xs) x
  The reverse of a cons is the reverse of the tail followed by the head.
  Together with reverseNil serves as a specification for reverse.

  Totality: total
  Visibility: export
0 slowReverse : List a -> List a
  A slow recursive definition of reverse.

  Totality: total
  Visibility: public export
reverseEquiv : (xs : List a) -> slowReverse xs = reverse xs
  The iterative and recursive defintions of reverse are the same.

  Totality: total
  Visibility: export
reverseSingletonId : (x : a) -> reverse [x] = [x]
  Reversing a singleton list is a no-op.

  Totality: total
  Visibility: export
reverseOntoLength : (xs : List a) -> (acc : List a) -> length (reverseOnto acc xs) = length acc + length xs
  Reversing onto preserves list length.

  Totality: total
  Visibility: export
reverseLength : (xs : List a) -> length (reverse xs) = length xs
  Reversing preserves list length.

  Totality: total
  Visibility: export
reverseEqual : (xs : List a) -> (ys : List a) -> reverse xs = reverse ys -> xs = ys
  Equal reversed lists are equal.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
reverseOntoAcc : (xs : List a) -> (ys : List a) -> (zs : List a) -> reverseOnto (ys ++ zs) xs = reverseOnto ys xs ++ zs
  Totality: total
  Visibility: export
reverseOntoSpec : (xs : List a) -> (ys : List a) -> reverseOnto xs ys = reverse ys ++ xs
  Serves as a specification for reverseOnto.

  Totality: total
  Visibility: export
reverseNil : reverse [] = []
  The reverse of an empty list is an empty list.  Together with reverseCons,
  serves as a specification for reverse.

  Totality: total
  Visibility: export
reverseCons : (x : a) -> (xs : List a) -> reverse (x :: xs) = snoc (reverse xs) x
  The reverse of a cons is the reverse of the tail followed by the head.
  Together with reverseNil serves as a specification for reverse.

  Totality: total
  Visibility: export
0 slowReverse : List a -> List a
  A slow recursive definition of reverse.

  Totality: total
  Visibility: public export
reverseEquiv : (xs : List a) -> slowReverse xs = reverse xs
  The iterative and recursive defintions of reverse are the same.

  Totality: total
  Visibility: export
reverseSingletonId : (x : a) -> reverse [x] = [x]
  Reversing a singleton list is a no-op.

  Totality: total
  Visibility: export
reverseOntoLength : (xs : List a) -> (acc : List a) -> length (reverseOnto acc xs) = length acc + length xs
  Reversing onto preserves list length.

  Totality: total
  Visibility: export
reverseLength : (xs : List a) -> length (reverse xs) = length xs
  Reversing preserves list length.

  Totality: total
  Visibility: export
reverseEqual : (xs : List a) -> (ys : List a) -> reverse xs = reverse ys -> xs = ys
  Equal reversed lists are equal.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.List.Sufficient.html b/contrib/docs/Data.List.Sufficient.html
index cf6279b7cb..5bfb64cf88 100644
--- a/contrib/docs/Data.List.Sufficient.html
+++ b/contrib/docs/Data.List.Sufficient.html
@@ -62,4 +62,4 @@
 
 
 
Data.List.Sufficient(source)
WellFounded on List suffixes
-
Definitions
data Suffix : List a -> List a -> Type
  Totality: total
  Visibility: public export
  Constructor: 
IsSuffix : (x : a) -> (zs : List a) -> (0 _ : xs = x :: (zs ++ ys)) -> Suffix ys xs

  Hint: 
WellFounded (List a) Suffix

\ No newline at end of file
+
Definitions
data Suffix : List a -> List a -> Type
  Totality: total
  Visibility: public export
  Constructor: 
IsSuffix : (x : a) -> (zs : List a) -> (0 _ : xs = x :: (zs ++ ys)) -> Suffix ys xs

  Hint: 
WellFounded (List a) Suffix

\ No newline at end of file
diff --git a/contrib/docs/Data.List.TailRec.html b/contrib/docs/Data.List.TailRec.html
index ae2cbef6a1..8c217a528f 100644
--- a/contrib/docs/Data.List.TailRec.html
+++ b/contrib/docs/Data.List.TailRec.html
@@ -77,4 +77,4 @@
 2. The proofs below also work on non-publicly exported
    definitions.  This could be due to a bug, and will need to be
    moved elsewhere if it's fixed.
-
Definitions
length : List a -> Nat
  Totality: total
  Visibility: export
length_ext : (xs : List a) -> length xs = length xs
  Totality: total
  Visibility: export
take : Nat -> List a -> List a
  Totality: total
  Visibility: export
take_ext : (n : Nat) -> (xs : List a) -> take n xs = take n xs
  Totality: total
  Visibility: export
span : (a -> Bool) -> List a -> (List a, List a)
  Totality: total
  Visibility: export
span_ext : (p : (a -> Bool)) -> (xs : List a) -> span p xs = span p xs
  Totality: total
  Visibility: export
break : (a -> Bool) -> List a -> (List a, List a)
  Totality: total
  Visibility: export
break_ext : (p : (a -> Bool)) -> (xs : List a) -> break p xs = break p xs
  Totality: total
  Visibility: export
split : (a -> Bool) -> List a -> List1 (List a)
  Totality: total
  Visibility: export
split_ext : (p : (a -> Bool)) -> (xs : List a) -> split p xs = split p xs
  Totality: total
  Visibility: export
splitAt : Nat -> List a -> (List a, List a)
  Totality: total
  Visibility: export
splitAt_ext : (n : Nat) -> (xs : List a) -> splitAt n xs = splitAt n xs
  Totality: total
  Visibility: export
partition : (a -> Bool) -> List a -> (List a, List a)
  Totality: total
  Visibility: export
intersperse : a -> List a -> List a
  Totality: total
  Visibility: export
intersperse_ext : (sep : a) -> (xs : List a) -> intersperse sep xs = intersperse sep xs
  Totality: total
  Visibility: export
mapMaybe : (a -> Maybe b) -> List a -> List b
  Totality: total
  Visibility: export
mapMaybe_ext : (f : (a -> Maybe b)) -> (xs : List a) -> mapMaybe f xs = mapMaybe f xs
  Totality: total
  Visibility: export
sorted : Ord a => List a -> Bool
  Totality: total
  Visibility: export
sorted_ext : {auto {conArg:6976} : Ord a} -> (xs : List a) -> sorted xs = sorted xs
  Visibility: export
mergeBy : (a -> a -> Ordering) -> List a -> List a -> List a
  Totality: total
  Visibility: export
mergeBy_ext : (order : (a -> a -> Ordering)) -> (left : List a) -> (right : List a) -> mergeBy order left right = mergeBy order left right
  Visibility: export
merge : Ord a => List a -> List a -> List a
  Totality: total
  Visibility: export
merge_ext : {auto {conArg:7383} : Ord a} -> (left : List a) -> (right : List a) -> merge left right = merge left right
  Visibility: export
sortBy : (a -> a -> Ordering) -> List a -> List a
  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
length : List a -> Nat
  Totality: total
  Visibility: export
length_ext : (xs : List a) -> length xs = length xs
  Totality: total
  Visibility: export
take : Nat -> List a -> List a
  Totality: total
  Visibility: export
take_ext : (n : Nat) -> (xs : List a) -> take n xs = take n xs
  Totality: total
  Visibility: export
span : (a -> Bool) -> List a -> (List a, List a)
  Totality: total
  Visibility: export
span_ext : (p : (a -> Bool)) -> (xs : List a) -> span p xs = span p xs
  Totality: total
  Visibility: export
break : (a -> Bool) -> List a -> (List a, List a)
  Totality: total
  Visibility: export
break_ext : (p : (a -> Bool)) -> (xs : List a) -> break p xs = break p xs
  Totality: total
  Visibility: export
split : (a -> Bool) -> List a -> List1 (List a)
  Totality: total
  Visibility: export
split_ext : (p : (a -> Bool)) -> (xs : List a) -> split p xs = split p xs
  Totality: total
  Visibility: export
splitAt : Nat -> List a -> (List a, List a)
  Totality: total
  Visibility: export
splitAt_ext : (n : Nat) -> (xs : List a) -> splitAt n xs = splitAt n xs
  Totality: total
  Visibility: export
partition : (a -> Bool) -> List a -> (List a, List a)
  Totality: total
  Visibility: export
intersperse : a -> List a -> List a
  Totality: total
  Visibility: export
intersperse_ext : (sep : a) -> (xs : List a) -> intersperse sep xs = intersperse sep xs
  Totality: total
  Visibility: export
mapMaybe : (a -> Maybe b) -> List a -> List b
  Totality: total
  Visibility: export
mapMaybe_ext : (f : (a -> Maybe b)) -> (xs : List a) -> mapMaybe f xs = mapMaybe f xs
  Totality: total
  Visibility: export
sorted : Ord a => List a -> Bool
  Totality: total
  Visibility: export
sorted_ext : {auto {conArg:6976} : Ord a} -> (xs : List a) -> sorted xs = sorted xs
  Visibility: export
mergeBy : (a -> a -> Ordering) -> List a -> List a -> List a
  Totality: total
  Visibility: export
mergeBy_ext : (order : (a -> a -> Ordering)) -> (left : List a) -> (right : List a) -> mergeBy order left right = mergeBy order left right
  Visibility: export
merge : Ord a => List a -> List a -> List a
  Totality: total
  Visibility: export
merge_ext : {auto {conArg:7383} : Ord a} -> (left : List a) -> (right : List a) -> merge left right = merge left right
  Visibility: export
sortBy : (a -> a -> Ordering) -> List a -> List a
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.List.Views.Extra.html b/contrib/docs/Data.List.Views.Extra.html
index 272e3b17ed..36c28390a2 100644
--- a/contrib/docs/Data.List.Views.Extra.html
+++ b/contrib/docs/Data.List.Views.Extra.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.List.Views.Extra(source)
Definitions
data Balanced : Nat -> Nat -> Type
  Proof that two numbers differ by at most one

  Totality: total
  Visibility: public export
  Constructors:
  
BalancedZ : Balanced 0 0
  
BalancedL : Balanced 1 0
  
BalancedRec : Balanced n m -> Balanced (S n) (S m)

  Hint: 
Uninhabited (Balanced 0 (S k))
balancedPred : Balanced (S x) (S y) -> Balanced x y
  Totality: total
  Visibility: export
mkBalancedEq : n = m -> Balanced n m
  Totality: total
  Visibility: export
mkBalancedL : n = S m -> Balanced n m
  Totality: total
  Visibility: export
data SplitBalanced : List a -> Type
  View of a list split into two halves
  
  The lengths of the lists are guaranteed to differ by at most one

  Totality: total
  Visibility: public export
  Constructor: 
MkSplitBal : Balanced (length xs) (length ys) -> SplitBalanced (xs ++ ys)
splitBalanced : (input : List a) -> SplitBalanced input
  Covering function for the `SplitBalanced`
  
  Constructs the view in linear time

  Totality: total
  Visibility: export
data VList : List a -> Type
  The `VList` view allows us to recurse on the middle of a list,
  inspecting the front and back elements simultaneously.

  Totality: total
  Visibility: public export
  Constructors:
  
VNil : VList []
  
VOne : VList [x]
  
VCons : Lazy (VList xs) -> VList (x :: (xs ++ [y]))
vList : (xs : List a) -> VList xs
  Covering function for `VList`
  Constructs the view in linear time.

  Totality: total
  Visibility: export
data LazyFilterRec : List a -> Type
  Lazy filtering of a list based on a predicate.

  Totality: total
  Visibility: public export
  Constructors:
  
Exhausted : (skip : List a) -> LazyFilterRec skip
  
Found : (skip : List a) -> (head : a) -> Lazy (LazyFilterRec rest) -> LazyFilterRec (skip ++ (head :: rest))
lazyFilterRec : (a -> Bool) -> (xs : List a) -> LazyFilterRec xs
  Covering function for the LazyFilterRec view.
  Constructs the view lazily in linear time.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.List.Views.Extra(source)
Definitions
data Balanced : Nat -> Nat -> Type
  Proof that two numbers differ by at most one

  Totality: total
  Visibility: public export
  Constructors:
  
BalancedZ : Balanced 0 0
  
BalancedL : Balanced 1 0
  
BalancedRec : Balanced n m -> Balanced (S n) (S m)

  Hint: 
Uninhabited (Balanced 0 (S k))
balancedPred : Balanced (S x) (S y) -> Balanced x y
  Totality: total
  Visibility: export
mkBalancedEq : n = m -> Balanced n m
  Totality: total
  Visibility: export
mkBalancedL : n = S m -> Balanced n m
  Totality: total
  Visibility: export
data SplitBalanced : List a -> Type
  View of a list split into two halves
  
  The lengths of the lists are guaranteed to differ by at most one

  Totality: total
  Visibility: public export
  Constructor: 
MkSplitBal : Balanced (length xs) (length ys) -> SplitBalanced (xs ++ ys)
splitBalanced : (input : List a) -> SplitBalanced input
  Covering function for the `SplitBalanced`
  
  Constructs the view in linear time

  Totality: total
  Visibility: export
data VList : List a -> Type
  The `VList` view allows us to recurse on the middle of a list,
  inspecting the front and back elements simultaneously.

  Totality: total
  Visibility: public export
  Constructors:
  
VNil : VList []
  
VOne : VList [x]
  
VCons : Lazy (VList xs) -> VList (x :: (xs ++ [y]))
vList : (xs : List a) -> VList xs
  Covering function for `VList`
  Constructs the view in linear time.

  Totality: total
  Visibility: export
data LazyFilterRec : List a -> Type
  Lazy filtering of a list based on a predicate.

  Totality: total
  Visibility: public export
  Constructors:
  
Exhausted : (skip : List a) -> LazyFilterRec skip
  
Found : (skip : List a) -> (head : a) -> Lazy (LazyFilterRec rest) -> LazyFilterRec (skip ++ (head :: rest))
lazyFilterRec : (a -> Bool) -> (xs : List a) -> LazyFilterRec xs
  Covering function for the LazyFilterRec view.
  Constructs the view lazily in linear time.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Logic.Propositional.html b/contrib/docs/Data.Logic.Propositional.html
index 688cdbc6f7..c59d0d5192 100644
--- a/contrib/docs/Data.Logic.Propositional.html
+++ b/contrib/docs/Data.Logic.Propositional.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Logic.Propositional(source)
Definitions

\ No newline at end of file
+
Data.Logic.Propositional(source)
Definitions

\ No newline at end of file
diff --git a/contrib/docs/Data.Monoid.Exponentiation.html b/contrib/docs/Data.Monoid.Exponentiation.html
index d40848e785..d895b2472a 100644
--- a/contrib/docs/Data.Monoid.Exponentiation.html
+++ b/contrib/docs/Data.Monoid.Exponentiation.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Monoid.Exponentiation(source)
Definitions
linear : Monoid a => a -> Nat -> a
  Totality: total
  Visibility: public export
modularRec : Monoid a => a -> HalfRec n -> a
  Totality: total
  Visibility: public export
modular : Monoid a => a -> Nat -> a
  Totality: total
  Visibility: public export
(^) : Num a => a -> Nat -> a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 10
linearPlusHomo : {auto mon : Monoid a} -> (x <+> y) <+> z = x <+> (y <+> z) -> neutral <+> x = x -> (v : a) -> linear v m <+> linear v n = linear v (m + n)
  Totality: total
  Visibility: export
modularRecCorrect : {auto mon : Monoid a} -> (x <+> y) <+> z = x <+> (y <+> z) -> neutral <+> x = x -> (v : a) -> (p : HalfRec n) -> modularRec v p = linear v n
  Totality: total
  Visibility: export
modularCorrect : {auto mon : Monoid a} -> (x <+> y) <+> z = x <+> (y <+> z) -> neutral <+> x = x -> (v : a) -> modular v n = linear v n
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Monoid.Exponentiation(source)
Definitions
linear : Monoid a => a -> Nat -> a
  Totality: total
  Visibility: public export
modularRec : Monoid a => a -> HalfRec n -> a
  Totality: total
  Visibility: public export
modular : Monoid a => a -> Nat -> a
  Totality: total
  Visibility: public export
(^) : Num a => a -> Nat -> a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 10
linearPlusHomo : {auto mon : Monoid a} -> (x <+> y) <+> z = x <+> (y <+> z) -> neutral <+> x = x -> (v : a) -> linear v m <+> linear v n = linear v (m + n)
  Totality: total
  Visibility: export
modularRecCorrect : {auto mon : Monoid a} -> (x <+> y) <+> z = x <+> (y <+> z) -> neutral <+> x = x -> (v : a) -> (p : HalfRec n) -> modularRec v p = linear v n
  Totality: total
  Visibility: export
modularCorrect : {auto mon : Monoid a} -> (x <+> y) <+> z = x <+> (y <+> z) -> neutral <+> x = x -> (v : a) -> modular v n = linear v n
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Morphisms.Algebra.html b/contrib/docs/Data.Morphisms.Algebra.html
index cf53adc921..226a3f0e6a 100644
--- a/contrib/docs/Data.Morphisms.Algebra.html
+++ b/contrib/docs/Data.Morphisms.Algebra.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Morphisms.Algebra(source)
Definitions

\ No newline at end of file
+
Data.Morphisms.Algebra(source)
Definitions

\ No newline at end of file
diff --git a/contrib/docs/Data.Nat.Ack.html b/contrib/docs/Data.Nat.Ack.html
index f3843f2025..8db7ffa02c 100644
--- a/contrib/docs/Data.Nat.Ack.html
+++ b/contrib/docs/Data.Nat.Ack.html
@@ -62,4 +62,4 @@
 
 
 
Data.Nat.Ack(source)
Properties of Ackermann functions
-

\ No newline at end of file
+
\ No newline at end of file
diff --git a/contrib/docs/Data.Nat.Algebra.html b/contrib/docs/Data.Nat.Algebra.html
index a1f7b9524c..c2aa372bcd 100644
--- a/contrib/docs/Data.Nat.Algebra.html
+++ b/contrib/docs/Data.Nat.Algebra.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Nat.Algebra(source)
Definitions

\ No newline at end of file
+
Data.Nat.Algebra(source)
Definitions

\ No newline at end of file
diff --git a/contrib/docs/Data.Nat.Division.html b/contrib/docs/Data.Nat.Division.html
index 7471bfbd8b..ba2cc4f807 100644
--- a/contrib/docs/Data.Nat.Division.html
+++ b/contrib/docs/Data.Nat.Division.html
@@ -62,4 +62,4 @@
 
 
 
Data.Nat.Division(source)
Division theorem for (type-level) natural number division
-
Definitions
divmodNatNZeqDivMod : (numer : Nat) -> (denom : Nat) -> (0 prf1 : NonZero denom) -> (0 prf2 : NonZero denom) -> (0 prf3 : NonZero denom) -> divmodNatNZ numer denom prf1 = (divNatNZ numer denom prf2, modNatNZ numer denom prf3)
  Totality: total
  Visibility: export
fstDivmodNatNZeqDiv : (numer : Nat) -> (denom : Nat) -> (0 prf1 : NonZero denom) -> (0 prf2 : NonZero denom) -> fst (divmodNatNZ numer denom prf1) = divNatNZ numer denom prf2
  Totality: total
  Visibility: export
sndDivmodNatNZeqMod : (numer : Nat) -> (denom : Nat) -> (0 prf1 : NonZero denom) -> (0 prf2 : NonZero denom) -> snd (divmodNatNZ numer denom prf1) = modNatNZ numer denom prf2
  Totality: total
  Visibility: export
boundModNatNZ : (numer : Nat) -> (denom : Nat) -> (0 denom_nz : NonZero denom) -> LT (modNatNZ numer denom denom_nz) denom
  Totality: total
  Visibility: export
DivisionTheoremDivMod : (numer : Nat) -> (denom : Nat) -> (0 prf : NonZero denom) -> numer = snd (divmodNatNZ numer denom prf) + (fst (divmodNatNZ numer denom prf) * denom)
  Totality: total
  Visibility: export
DivisionTheorem : (numer : Nat) -> (denom : Nat) -> (0 prf1 : NonZero denom) -> (0 prf2 : NonZero denom) -> numer = modNatNZ numer denom prf1 + (divNatNZ numer denom prf2 * denom)
  Totality: total
  Visibility: export
DivisionTheoremUniquenessDivMod : (numer : Nat) -> (denom : Nat) -> (0 denom_nz : NonZero denom) -> (q : Nat) -> (r : Nat) -> LT r denom -> numer = (q * denom) + r -> divmodNatNZ numer denom denom_nz = (q, r)
  Totality: total
  Visibility: export
DivisionTheoremUniqueness : (numer : Nat) -> (denom : Nat) -> (0 denom_nz : NonZero denom) -> (q : Nat) -> (r : Nat) -> LT r denom -> numer = (q * denom) + r -> (divNatNZ numer denom denom_nz = q, modNatNZ numer denom denom_nz = r)
  Totality: total
  Visibility: export
modDividendMinusDivMultDivider : (0 numer : Nat) -> (0 denom : Nat) -> {auto 0 denom_nz : NonZero denom} -> modNatNZ numer denom denom_nz = minus numer (divNatNZ numer denom denom_nz * denom)
  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
divmodNatNZeqDivMod : (numer : Nat) -> (denom : Nat) -> (0 prf1 : NonZero denom) -> (0 prf2 : NonZero denom) -> (0 prf3 : NonZero denom) -> divmodNatNZ numer denom prf1 = (divNatNZ numer denom prf2, modNatNZ numer denom prf3)
  Totality: total
  Visibility: export
fstDivmodNatNZeqDiv : (numer : Nat) -> (denom : Nat) -> (0 prf1 : NonZero denom) -> (0 prf2 : NonZero denom) -> fst (divmodNatNZ numer denom prf1) = divNatNZ numer denom prf2
  Totality: total
  Visibility: export
sndDivmodNatNZeqMod : (numer : Nat) -> (denom : Nat) -> (0 prf1 : NonZero denom) -> (0 prf2 : NonZero denom) -> snd (divmodNatNZ numer denom prf1) = modNatNZ numer denom prf2
  Totality: total
  Visibility: export
boundModNatNZ : (numer : Nat) -> (denom : Nat) -> (0 denom_nz : NonZero denom) -> LT (modNatNZ numer denom denom_nz) denom
  Totality: total
  Visibility: export
DivisionTheoremDivMod : (numer : Nat) -> (denom : Nat) -> (0 prf : NonZero denom) -> numer = snd (divmodNatNZ numer denom prf) + (fst (divmodNatNZ numer denom prf) * denom)
  Totality: total
  Visibility: export
DivisionTheorem : (numer : Nat) -> (denom : Nat) -> (0 prf1 : NonZero denom) -> (0 prf2 : NonZero denom) -> numer = modNatNZ numer denom prf1 + (divNatNZ numer denom prf2 * denom)
  Totality: total
  Visibility: export
DivisionTheoremUniquenessDivMod : (numer : Nat) -> (denom : Nat) -> (0 denom_nz : NonZero denom) -> (q : Nat) -> (r : Nat) -> LT r denom -> numer = (q * denom) + r -> divmodNatNZ numer denom denom_nz = (q, r)
  Totality: total
  Visibility: export
DivisionTheoremUniqueness : (numer : Nat) -> (denom : Nat) -> (0 denom_nz : NonZero denom) -> (q : Nat) -> (r : Nat) -> LT r denom -> numer = (q * denom) + r -> (divNatNZ numer denom denom_nz = q, modNatNZ numer denom denom_nz = r)
  Totality: total
  Visibility: export
modDividendMinusDivMultDivider : (0 numer : Nat) -> (0 denom : Nat) -> {auto 0 denom_nz : NonZero denom} -> modNatNZ numer denom denom_nz = minus numer (divNatNZ numer denom denom_nz * denom)
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Nat.Equational.html b/contrib/docs/Data.Nat.Equational.html
index e9e7c4d92a..d79210fb89 100644
--- a/contrib/docs/Data.Nat.Equational.html
+++ b/contrib/docs/Data.Nat.Equational.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Nat.Equational(source)
Definitions
subtractEqLeft : (a : Nat) -> a + b = a + c -> b = c
  Subtract a number from both sides of an equation.
  Due to partial nature of subtraction in natural numbers, an equation of
  special form is required in order for subtraction to be total.

  Totality: total
  Visibility: export
subtractEqRight : (c : Nat) -> a + c = b + c -> a = b
  Subtract a number from both sides of an equation.
  Due to partial nature of subtraction in natural numbers, an equation of
  special form is required in order for subtraction to be total.

  Totality: total
  Visibility: export
plusLteLeft : (a : Nat) -> LTE b c -> LTE (a + b) (a + c)
  Add a number to both sides of an inequality

  Totality: total
  Visibility: export
plusLteRight : (c : Nat) -> LTE a b -> LTE (a + c) (b + c)
  Add a number to both sides of an inequality

  Totality: total
  Visibility: export
lteZeroIsZero : LTE a 0 -> a = 0
  Only 0 is lte 0
  Useful when the argument is an open term

  Totality: total
  Visibility: export
subtractLteLeft : (a : Nat) -> LTE (a + b) (a + c) -> LTE b c
  Subtract a number from both sides of an inequality.
  Due to partial nature of subtraction, we require an inequality of special form.

  Totality: total
  Visibility: export
subtractLteRight : (c : Nat) -> LTE (a + c) (b + c) -> LTE a b
  Subtract a number from both sides of an inequality.
  Due to partial nature of subtraction, we require an inequality of special form.

  Totality: total
  Visibility: export
rightFactorLteProduct : (a : Nat) -> (b : Nat) -> LTE b (S a * b)
  If one of the factors of a product is greater than 0, then the other factor
  is less than or equal to the product..

  Totality: total
  Visibility: export
leftFactorLteProduct : (a : Nat) -> (b : Nat) -> LTE a (a * S b)
  If one of the factors of a product is greater than 0, then the other factor
  is less than or equal to the product..

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Nat.Equational(source)
Definitions
subtractEqLeft : (a : Nat) -> a + b = a + c -> b = c
  Subtract a number from both sides of an equation.
  Due to partial nature of subtraction in natural numbers, an equation of
  special form is required in order for subtraction to be total.

  Totality: total
  Visibility: export
subtractEqRight : (c : Nat) -> a + c = b + c -> a = b
  Subtract a number from both sides of an equation.
  Due to partial nature of subtraction in natural numbers, an equation of
  special form is required in order for subtraction to be total.

  Totality: total
  Visibility: export
plusLteLeft : (a : Nat) -> LTE b c -> LTE (a + b) (a + c)
  Add a number to both sides of an inequality

  Totality: total
  Visibility: export
plusLteRight : (c : Nat) -> LTE a b -> LTE (a + c) (b + c)
  Add a number to both sides of an inequality

  Totality: total
  Visibility: export
lteZeroIsZero : LTE a 0 -> a = 0
  Only 0 is lte 0
  Useful when the argument is an open term

  Totality: total
  Visibility: export
subtractLteLeft : (a : Nat) -> LTE (a + b) (a + c) -> LTE b c
  Subtract a number from both sides of an inequality.
  Due to partial nature of subtraction, we require an inequality of special form.

  Totality: total
  Visibility: export
subtractLteRight : (c : Nat) -> LTE (a + c) (b + c) -> LTE a b
  Subtract a number from both sides of an inequality.
  Due to partial nature of subtraction, we require an inequality of special form.

  Totality: total
  Visibility: export
rightFactorLteProduct : (a : Nat) -> (b : Nat) -> LTE b (S a * b)
  If one of the factors of a product is greater than 0, then the other factor
  is less than or equal to the product..

  Totality: total
  Visibility: export
leftFactorLteProduct : (a : Nat) -> (b : Nat) -> LTE a (a * S b)
  If one of the factors of a product is greater than 0, then the other factor
  is less than or equal to the product..

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Nat.Exponentiation.html b/contrib/docs/Data.Nat.Exponentiation.html
index 3b43f6947f..438f0c8f5b 100644
--- a/contrib/docs/Data.Nat.Exponentiation.html
+++ b/contrib/docs/Data.Nat.Exponentiation.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Nat.Exponentiation(source)
Definitions
pow : Nat -> Nat -> Nat
  Totality: total
  Visibility: public export
lpow : Nat -> Nat -> Nat
  Totality: total
  Visibility: public export
pow2 : Nat -> Nat
  Totality: total
  Visibility: public export
lpow2 : Nat -> Nat
  Totality: total
  Visibility: public export
modularCorrect : (v : Nat) -> pow v n = lpow v n
  Totality: total
  Visibility: export
pow2Correct : pow2 n = lpow2 n
  Totality: total
  Visibility: export
unfoldLpow2 : lpow2 (S n) = lpow2 n + lpow2 n
  Totality: total
  Visibility: export
unfoldPow2 : pow2 (S n) = pow2 n + pow2 n
  Totality: total
  Visibility: export
lteLpow2 : LTE 1 (lpow2 m)
  Totality: total
  Visibility: export
ltePow2 : LTE 1 (pow2 m)
  Totality: total
  Visibility: export
pow2Increasing : LT (pow2 m) (pow2 (S m))
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Nat.Exponentiation(source)
Definitions
pow : Nat -> Nat -> Nat
  Totality: total
  Visibility: public export
lpow : Nat -> Nat -> Nat
  Totality: total
  Visibility: public export
pow2 : Nat -> Nat
  Totality: total
  Visibility: public export
lpow2 : Nat -> Nat
  Totality: total
  Visibility: public export
modularCorrect : (v : Nat) -> pow v n = lpow v n
  Totality: total
  Visibility: export
pow2Correct : pow2 n = lpow2 n
  Totality: total
  Visibility: export
unfoldLpow2 : lpow2 (S n) = lpow2 n + lpow2 n
  Totality: total
  Visibility: export
unfoldPow2 : pow2 (S n) = pow2 n + pow2 n
  Totality: total
  Visibility: export
lteLpow2 : LTE 1 (lpow2 m)
  Totality: total
  Visibility: export
ltePow2 : LTE 1 (pow2 m)
  Totality: total
  Visibility: export
pow2Increasing : LT (pow2 m) (pow2 (S m))
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Nat.Fact.html b/contrib/docs/Data.Nat.Fact.html
index b4213be395..5132d26d77 100644
--- a/contrib/docs/Data.Nat.Fact.html
+++ b/contrib/docs/Data.Nat.Fact.html
@@ -62,4 +62,4 @@
 
 
 
Data.Nat.Fact(source)
Properties of factorial functions
-
Definitions

\ No newline at end of file
+
Definitions

\ No newline at end of file
diff --git a/contrib/docs/Data.Nat.Factor.html b/contrib/docs/Data.Nat.Factor.html
index 01fc1f62df..53acebc74e 100644
--- a/contrib/docs/Data.Nat.Factor.html
+++ b/contrib/docs/Data.Nat.Factor.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Nat.Factor(source)
Definitions
data Factor : Nat -> Nat -> Type
  Factor n p is a witness that p is indeed a factor of n,
  i.e. there exists a q such that p * q = n.

  Totality: total
  Visibility: public export
  Constructor: 
CofactorExists : (q : Nat) -> n = p * q -> Factor p n

  Hints:
  
Antisymmetric Nat Factor
  
PartialOrder Nat Factor
  
Preorder Nat Factor
  
Reflexive Nat Factor
  
Transitive Nat Factor
  
Uninhabited (Factor 0 (S n))
data NotFactor : Nat -> Nat -> Type
  NotFactor n p is a witness that p is NOT a factor of n,
  i.e. there exist a q and an r, greater than 0 but smaller than p,
  such that p * q + r = n.

  Totality: total
  Visibility: public export
  Constructors:
  
ZeroNotFactorS : (n : Nat) -> NotFactor 0 (S n)
  
ProperRemExists : (q : Nat) -> (r : Fin (pred p)) -> n = (p * q) + S (finToNat r) -> NotFactor p n
data DecFactor : Nat -> Nat -> Type
  DecFactor n p is a result of the process which decides
  whether or not p is a factor on n.

  Totality: total
  Visibility: public export
  Constructors:
  
ItIsFactor : Factor p n -> DecFactor p n
  
ItIsNotFactor : NotFactor p n -> DecFactor p n
data CommonFactor : Nat -> Nat -> Nat -> Type
  CommonFactor n m p is a witness that p is a factor of both n and m.

  Totality: total
  Visibility: public export
  Constructor: 
CommonFactorExists : (p : Nat) -> Factor p a -> Factor p b -> CommonFactor p a b

  Hint: 
Symmetric Nat (CommonFactor p)
data GCD : Nat -> Nat -> Nat -> Type
  GCD n m p is a witness that p is THE greatest common factor of both n and m.
  The second argument to the constructor is a function which for all q being
  a factor of both n and m, proves that q is a factor of p.
  
  This is equivalent to a more straightforward definition, stating that for
  all q being a factor of both n and m, q is less than or equal to p, but more
  powerful and therefore more useful for further proofs. See below for a proof
  that if q is a factor of p then q must be less than or equal to p.

  Totality: total
  Visibility: public export
  Constructor: 
MkGCD : NotBothZero a b => Lazy (CommonFactor p a b) -> ((q : Nat) -> CommonFactor q a b -> Factor q p) -> GCD p a b

  Hint: 
Symmetric Nat (GCD p)
cofactor : Factor p n -> (q : Nat ** Factor q n)
  Given a statement that p is factor of n, return its cofactor.

  Totality: total
  Visibility: export
oneIsFactor : (n : Nat) -> Factor 1 n
  1 is a factor of any natural number.

  Totality: total
  Visibility: export
oneSoleFactorOfOne : (a : Nat) -> Factor a 1 -> a = 1
  1 is the only factor of itself

  Totality: total
  Visibility: export
factorNotFactorAbsurd : Factor p n -> Not (NotFactor p n)
  No number can simultaneously be and not be a factor of another number.

  Totality: total
  Visibility: export
anythingFactorZero : (a : Nat) -> Factor a 0
  Anything is a factor of 0.

  Totality: total
  Visibility: export
multFactor : (p : Nat) -> (q : Nat) -> Factor p (p * q)
  For all natural numbers p and q, p is a factor of (p * q).

  Totality: total
  Visibility: export
factorLteNumber : Factor p n -> LTE 1 n => LTE p n
  If n > 0 then any factor of n must be less than or equal to n.

  Totality: total
  Visibility: export
plusDivisorAlsoFactor : Factor p n -> Factor p (n + p)
  If p is a factor of n, then it is also a factor of (n + p).

  Totality: total
  Visibility: export
plusDivisorNeitherFactor : NotFactor p n -> NotFactor p (n + p)
  If p is NOT a factor of n, then it also is NOT a factor of (n + p).

  Totality: total
  Visibility: export
multNAlsoFactor : Factor p n -> (a : Nat) -> LTE 1 a => Factor p (n * a)
  If p is a factor of n, then it is also a factor of any multiply of n.

  Totality: total
  Visibility: export
plusFactor : Factor p n -> Factor p m -> Factor p (n + m)
  If p is a factor of both n and m, then it is also a factor of their sum.

  Totality: total
  Visibility: export
minusFactor : Factor p (a + b) -> Factor p a -> Factor p b
  If p is a factor of a sum (n + m) and a factor of n, then it is also
  a factor of m. This could be expressed more naturally with minus, but
  it would be more difficult to prove, since minus lacks certain properties
  that one would expect from decent subtraction.

  Totality: total
  Visibility: export
modFactorAlsoFactorOfDivider : {auto 0 nNotZ : NonZero n} -> Factor p n -> Factor p (modNatNZ m n nNotZ) -> Factor p m
  If p is a common factor of n and mod m n, then it is also a factor of m.

  Totality: total
  Visibility: export
commonFactorAlsoFactorOfMod : {auto 0 nNotZ : NonZero n} -> Factor p m -> Factor p n -> Factor p (modNatNZ m n nNotZ)
  If p is a common factor of m and n, then it is also a factor of their mod.

  Totality: total
  Visibility: export
decFactor : (n : Nat) -> (d : Nat) -> DecFactor d n
  A decision procedure for whether of not p is a factor of n.

  Totality: total
  Visibility: export
factNotSuccFact : GT p 1 -> Factor p n -> NotFactor p (S n)
  For all p greater than 1, if p is a factor of n, then it is NOT a factor
  of (n + 1).

  Totality: total
  Visibility: export
commonFactorAlsoFactorOfGCD : Factor p a -> Factor p b -> GCD q a b -> Factor p q
  If p is a common factor of a and b, then it is also a factor of their GCD.
  This actually follows directly from the definition of GCD.

  Totality: total
  Visibility: export
oneCommonFactor : (a : Nat) -> (b : Nat) -> CommonFactor 1 a b
  1 is a common factor of any pair of natural numbers.

  Totality: total
  Visibility: export
selfIsCommonFactor : (a : Nat) -> LTE 1 a => CommonFactor a a a
  Any natural number is a common factor of itself and itself.

  Totality: total
  Visibility: export
gcd : (a : Nat) -> (b : Nat) -> NotBothZero a b => (f : Nat ** GCD f a b)
  An implementation of Euclidean Algorithm for computing greatest common
  divisors. It is proven correct and total; returns a proof that computed
  number actually IS the GCD.

  Totality: total
  Visibility: export
gcdUnique : GCD p a b -> GCD q a b -> p = q
  For every two natural numbers there is a unique greatest common divisor.

  Totality: total
  Visibility: export
divByGcdGcdOne : GCD a (a * b) (a * c) -> GCD 1 b c
  For every two natural numbers, if we divide both of them by their GCD,
  the GCD of resulting numbers will always be 1.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Nat.Factor(source)
Definitions
data Factor : Nat -> Nat -> Type
  Factor n p is a witness that p is indeed a factor of n,
  i.e. there exists a q such that p * q = n.

  Totality: total
  Visibility: public export
  Constructor: 
CofactorExists : (q : Nat) -> n = p * q -> Factor p n

  Hints:
  
Antisymmetric Nat Factor
  
PartialOrder Nat Factor
  
Preorder Nat Factor
  
Reflexive Nat Factor
  
Transitive Nat Factor
  
Uninhabited (Factor 0 (S n))
data NotFactor : Nat -> Nat -> Type
  NotFactor n p is a witness that p is NOT a factor of n,
  i.e. there exist a q and an r, greater than 0 but smaller than p,
  such that p * q + r = n.

  Totality: total
  Visibility: public export
  Constructors:
  
ZeroNotFactorS : (n : Nat) -> NotFactor 0 (S n)
  
ProperRemExists : (q : Nat) -> (r : Fin (pred p)) -> n = (p * q) + S (finToNat r) -> NotFactor p n
data DecFactor : Nat -> Nat -> Type
  DecFactor n p is a result of the process which decides
  whether or not p is a factor on n.

  Totality: total
  Visibility: public export
  Constructors:
  
ItIsFactor : Factor p n -> DecFactor p n
  
ItIsNotFactor : NotFactor p n -> DecFactor p n
data CommonFactor : Nat -> Nat -> Nat -> Type
  CommonFactor n m p is a witness that p is a factor of both n and m.

  Totality: total
  Visibility: public export
  Constructor: 
CommonFactorExists : (p : Nat) -> Factor p a -> Factor p b -> CommonFactor p a b

  Hint: 
Symmetric Nat (CommonFactor p)
data GCD : Nat -> Nat -> Nat -> Type
  GCD n m p is a witness that p is THE greatest common factor of both n and m.
  The second argument to the constructor is a function which for all q being
  a factor of both n and m, proves that q is a factor of p.
  
  This is equivalent to a more straightforward definition, stating that for
  all q being a factor of both n and m, q is less than or equal to p, but more
  powerful and therefore more useful for further proofs. See below for a proof
  that if q is a factor of p then q must be less than or equal to p.

  Totality: total
  Visibility: public export
  Constructor: 
MkGCD : NotBothZero a b => Lazy (CommonFactor p a b) -> ((q : Nat) -> CommonFactor q a b -> Factor q p) -> GCD p a b

  Hint: 
Symmetric Nat (GCD p)
cofactor : Factor p n -> (q : Nat ** Factor q n)
  Given a statement that p is factor of n, return its cofactor.

  Totality: total
  Visibility: export
oneIsFactor : (n : Nat) -> Factor 1 n
  1 is a factor of any natural number.

  Totality: total
  Visibility: export
oneSoleFactorOfOne : (a : Nat) -> Factor a 1 -> a = 1
  1 is the only factor of itself

  Totality: total
  Visibility: export
factorNotFactorAbsurd : Factor p n -> Not (NotFactor p n)
  No number can simultaneously be and not be a factor of another number.

  Totality: total
  Visibility: export
anythingFactorZero : (a : Nat) -> Factor a 0
  Anything is a factor of 0.

  Totality: total
  Visibility: export
multFactor : (p : Nat) -> (q : Nat) -> Factor p (p * q)
  For all natural numbers p and q, p is a factor of (p * q).

  Totality: total
  Visibility: export
factorLteNumber : Factor p n -> LTE 1 n => LTE p n
  If n > 0 then any factor of n must be less than or equal to n.

  Totality: total
  Visibility: export
plusDivisorAlsoFactor : Factor p n -> Factor p (n + p)
  If p is a factor of n, then it is also a factor of (n + p).

  Totality: total
  Visibility: export
plusDivisorNeitherFactor : NotFactor p n -> NotFactor p (n + p)
  If p is NOT a factor of n, then it also is NOT a factor of (n + p).

  Totality: total
  Visibility: export
multNAlsoFactor : Factor p n -> (a : Nat) -> LTE 1 a => Factor p (n * a)
  If p is a factor of n, then it is also a factor of any multiply of n.

  Totality: total
  Visibility: export
plusFactor : Factor p n -> Factor p m -> Factor p (n + m)
  If p is a factor of both n and m, then it is also a factor of their sum.

  Totality: total
  Visibility: export
minusFactor : Factor p (a + b) -> Factor p a -> Factor p b
  If p is a factor of a sum (n + m) and a factor of n, then it is also
  a factor of m. This could be expressed more naturally with minus, but
  it would be more difficult to prove, since minus lacks certain properties
  that one would expect from decent subtraction.

  Totality: total
  Visibility: export
modFactorAlsoFactorOfDivider : {auto 0 nNotZ : NonZero n} -> Factor p n -> Factor p (modNatNZ m n nNotZ) -> Factor p m
  If p is a common factor of n and mod m n, then it is also a factor of m.

  Totality: total
  Visibility: export
commonFactorAlsoFactorOfMod : {auto 0 nNotZ : NonZero n} -> Factor p m -> Factor p n -> Factor p (modNatNZ m n nNotZ)
  If p is a common factor of m and n, then it is also a factor of their mod.

  Totality: total
  Visibility: export
decFactor : (n : Nat) -> (d : Nat) -> DecFactor d n
  A decision procedure for whether of not p is a factor of n.

  Totality: total
  Visibility: export
factNotSuccFact : GT p 1 -> Factor p n -> NotFactor p (S n)
  For all p greater than 1, if p is a factor of n, then it is NOT a factor
  of (n + 1).

  Totality: total
  Visibility: export
commonFactorAlsoFactorOfGCD : Factor p a -> Factor p b -> GCD q a b -> Factor p q
  If p is a common factor of a and b, then it is also a factor of their GCD.
  This actually follows directly from the definition of GCD.

  Totality: total
  Visibility: export
oneCommonFactor : (a : Nat) -> (b : Nat) -> CommonFactor 1 a b
  1 is a common factor of any pair of natural numbers.

  Totality: total
  Visibility: export
selfIsCommonFactor : (a : Nat) -> LTE 1 a => CommonFactor a a a
  Any natural number is a common factor of itself and itself.

  Totality: total
  Visibility: export
gcd : (a : Nat) -> (b : Nat) -> NotBothZero a b => (f : Nat ** GCD f a b)
  An implementation of Euclidean Algorithm for computing greatest common
  divisors. It is proven correct and total; returns a proof that computed
  number actually IS the GCD.

  Totality: total
  Visibility: export
gcdUnique : GCD p a b -> GCD q a b -> p = q
  For every two natural numbers there is a unique greatest common divisor.

  Totality: total
  Visibility: export
divByGcdGcdOne : GCD a (a * b) (a * c) -> GCD 1 b c
  For every two natural numbers, if we divide both of them by their GCD,
  the GCD of resulting numbers will always be 1.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Nat.Fib.html b/contrib/docs/Data.Nat.Fib.html
index 0a38d92513..5330e97fb7 100644
--- a/contrib/docs/Data.Nat.Fib.html
+++ b/contrib/docs/Data.Nat.Fib.html
@@ -62,4 +62,4 @@
 
 
 
Data.Nat.Fib(source)
Properties of Fibonacci functions
-
Definitions

\ No newline at end of file
+
Definitions

\ No newline at end of file
diff --git a/contrib/docs/Data.Nat.Order.Properties.html b/contrib/docs/Data.Nat.Order.Properties.html
index 1146a3bf67..a4f747a5af 100644
--- a/contrib/docs/Data.Nat.Order.Properties.html
+++ b/contrib/docs/Data.Nat.Order.Properties.html
@@ -62,4 +62,4 @@
 
 
 
Data.Nat.Order.Properties(source)
Additional properties/lemmata of Nats involving order
-
Definitions
LTESuccInjectiveMonotone : (m : Nat) -> (n : Nat) -> Reflects (LTE m n) b -> Reflects (LTE (S m) (S n)) b
  Totality: total
  Visibility: export
lteReflection : (a : Nat) -> (b : Nat) -> Reflects (LTE a b) (lte a b)
  Totality: total
  Visibility: export
ltReflection : (a : Nat) -> (b : Nat) -> Reflects (LT a b) (lt a b)
  Totality: total
  Visibility: export
lteIsLTE : (a : Nat) -> (b : Nat) -> lte a b = True -> LTE a b
  Totality: total
  Visibility: export
ltIsLT : (a : Nat) -> (b : Nat) -> lt a b = True -> LT a b
  Totality: total
  Visibility: export
notlteIsNotLTE : (a : Nat) -> (b : Nat) -> lte a b = False -> Not (LTE a b)
  Totality: total
  Visibility: export
notltIsNotLT : (a : Nat) -> (b : Nat) -> lt a b = False -> Not (LT a b)
  Totality: total
  Visibility: export
notlteIsLT : (a : Nat) -> (b : Nat) -> lte a b = False -> LT b a
  Totality: total
  Visibility: export
notltIsGTE : (a : Nat) -> (b : Nat) -> lt a b = False -> GTE a b
  Totality: total
  Visibility: export
LteIslte : (a : Nat) -> (b : Nat) -> LTE a b -> lte a b = True
  Totality: total
  Visibility: export
notLteIsnotlte : (a : Nat) -> (b : Nat) -> Not (LTE a b) -> lte a b = False
  Totality: total
  Visibility: export
GTIsnotlte : (a : Nat) -> (b : Nat) -> LT b a -> lte a b = False
  Totality: total
  Visibility: export
minusLTE : (a : Nat) -> (b : Nat) -> LTE (minus b a) b
  Subtracting a number gives a smaller number

  Totality: total
  Visibility: export
minusPosLT : (a : Nat) -> (b : Nat) -> LT 0 a -> LTE a b -> LT (minus b a) b
  Subtracting a positive number gives a strictly smaller number

  Totality: total
  Visibility: export
multLteMonotoneRight : (l : Nat) -> (a : Nat) -> (b : Nat) -> LTE a b -> LTE (l * a) (l * b)
  Totality: total
  Visibility: export
multLteMonotoneLeft : (a : Nat) -> (b : Nat) -> (r : Nat) -> LTE a b -> LTE (a * r) (b * r)
  Totality: total
  Visibility: export
lteNotLtEq : (a : Nat) -> (b : Nat) -> LTE a b -> Not (LT a b) -> a = b
  Totality: total
  Visibility: export
decomposeLte : (a : Nat) -> (b : Nat) -> LTE a b -> Either (LT a b) (a = b)
  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
LTESuccInjectiveMonotone : (m : Nat) -> (n : Nat) -> Reflects (LTE m n) b -> Reflects (LTE (S m) (S n)) b
  Totality: total
  Visibility: export
lteReflection : (a : Nat) -> (b : Nat) -> Reflects (LTE a b) (lte a b)
  Totality: total
  Visibility: export
ltReflection : (a : Nat) -> (b : Nat) -> Reflects (LT a b) (lt a b)
  Totality: total
  Visibility: export
lteIsLTE : (a : Nat) -> (b : Nat) -> lte a b = True -> LTE a b
  Totality: total
  Visibility: export
ltIsLT : (a : Nat) -> (b : Nat) -> lt a b = True -> LT a b
  Totality: total
  Visibility: export
notlteIsNotLTE : (a : Nat) -> (b : Nat) -> lte a b = False -> Not (LTE a b)
  Totality: total
  Visibility: export
notltIsNotLT : (a : Nat) -> (b : Nat) -> lt a b = False -> Not (LT a b)
  Totality: total
  Visibility: export
notlteIsLT : (a : Nat) -> (b : Nat) -> lte a b = False -> LT b a
  Totality: total
  Visibility: export
notltIsGTE : (a : Nat) -> (b : Nat) -> lt a b = False -> GTE a b
  Totality: total
  Visibility: export
LteIslte : (a : Nat) -> (b : Nat) -> LTE a b -> lte a b = True
  Totality: total
  Visibility: export
notLteIsnotlte : (a : Nat) -> (b : Nat) -> Not (LTE a b) -> lte a b = False
  Totality: total
  Visibility: export
GTIsnotlte : (a : Nat) -> (b : Nat) -> LT b a -> lte a b = False
  Totality: total
  Visibility: export
minusLTE : (a : Nat) -> (b : Nat) -> LTE (minus b a) b
  Subtracting a number gives a smaller number

  Totality: total
  Visibility: export
minusPosLT : (a : Nat) -> (b : Nat) -> LT 0 a -> LTE a b -> LT (minus b a) b
  Subtracting a positive number gives a strictly smaller number

  Totality: total
  Visibility: export
multLteMonotoneRight : (l : Nat) -> (a : Nat) -> (b : Nat) -> LTE a b -> LTE (l * a) (l * b)
  Totality: total
  Visibility: export
multLteMonotoneLeft : (a : Nat) -> (b : Nat) -> (r : Nat) -> LTE a b -> LTE (a * r) (b * r)
  Totality: total
  Visibility: export
lteNotLtEq : (a : Nat) -> (b : Nat) -> LTE a b -> Not (LT a b) -> a = b
  Totality: total
  Visibility: export
decomposeLte : (a : Nat) -> (b : Nat) -> LTE a b -> Either (LT a b) (a = b)
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Nat.Order.Relation.html b/contrib/docs/Data.Nat.Order.Relation.html
index 6b911cc69f..a56088dc19 100644
--- a/contrib/docs/Data.Nat.Order.Relation.html
+++ b/contrib/docs/Data.Nat.Order.Relation.html
@@ -62,4 +62,4 @@
 
 
 
Data.Nat.Order.Relation(source)
An example implementation for the Tolerance relation.
-
Definitions

\ No newline at end of file
+
Definitions

\ No newline at end of file
diff --git a/contrib/docs/Data.Nat.Order.Strict.html b/contrib/docs/Data.Nat.Order.Strict.html
index ffe28bcc39..d786018dc2 100644
--- a/contrib/docs/Data.Nat.Order.Strict.html
+++ b/contrib/docs/Data.Nat.Order.Strict.html
@@ -62,4 +62,4 @@
 
 
 
Data.Nat.Order.Strict(source)
Implementing `Decidable.Order.Strict` for `Data.Nat.LT`
-
Definitions
decLT : (a : Nat) -> (b : Nat) -> DecOrdering a b
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
decLT : (a : Nat) -> (b : Nat) -> DecOrdering a b
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.Nat.Properties.html b/contrib/docs/Data.Nat.Properties.html
index 04325fc375..040b35f2ee 100644
--- a/contrib/docs/Data.Nat.Properties.html
+++ b/contrib/docs/Data.Nat.Properties.html
@@ -62,4 +62,4 @@
 
 
 
Data.Nat.Properties(source)
Additional properties/lemmata of Nats
-
Definitions
unfoldDouble : 2 * n = n + n
  Totality: total
  Visibility: export
unfoldDoubleS : 2 * S n = 2 + (2 * n)
  Totality: total
  Visibility: export
multRightCancel : (a : Nat) -> (b : Nat) -> (r : Nat) -> (0 _ : NonZero r) -> a * r = b * r -> a = b
  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
unfoldDouble : 2 * n = n + n
  Totality: total
  Visibility: export
unfoldDoubleS : 2 * S n = 2 + (2 * n)
  Totality: total
  Visibility: export
multRightCancel : (a : Nat) -> (b : Nat) -> (r : Nat) -> (0 _ : NonZero r) -> a * r = b * r -> a = b
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Order.html b/contrib/docs/Data.Order.html
index 7939d3721f..32bcb534d2 100644
--- a/contrib/docs/Data.Order.html
+++ b/contrib/docs/Data.Order.html
@@ -62,4 +62,4 @@
 
 
 
Data.Order(source)
Additional data types related to ordering notions
-
Definitions
data Trichotomous : (a -> a -> Type) -> (a -> a -> Type) -> (a -> a -> Type) -> a -> a -> Type
  Trichotomous formalises the fact that three relations are mutually exclusive.
  It is meant to be used with relations that complement each other so that the
  `Trichotomous lt eq gt` relation is the total relation.

  Totality: total
  Visibility: public export
  Constructors:
  
MkLT : lt v w -> Not (eq v w) -> Not (gt v w) -> Trichotomous lt eq gt v w
  
MkEQ : Not (lt v w) -> eq v w -> Not (gt v w) -> Trichotomous lt eq gt v w
  
MkGT : Not (lt v w) -> Not (eq v w) -> gt v w -> Trichotomous lt eq gt v w

\ No newline at end of file
+
Definitions
data Trichotomous : (a -> a -> Type) -> (a -> a -> Type) -> (a -> a -> Type) -> a -> a -> Type
  Trichotomous formalises the fact that three relations are mutually exclusive.
  It is meant to be used with relations that complement each other so that the
  `Trichotomous lt eq gt` relation is the total relation.

  Totality: total
  Visibility: public export
  Constructors:
  
MkLT : lt v w -> Not (eq v w) -> Not (gt v w) -> Trichotomous lt eq gt v w
  
MkEQ : Not (lt v w) -> eq v w -> Not (gt v w) -> Trichotomous lt eq gt v w
  
MkGT : Not (lt v w) -> Not (eq v w) -> gt v w -> Trichotomous lt eq gt v w

\ No newline at end of file
diff --git a/contrib/docs/Data.Path.html b/contrib/docs/Data.Path.html
index 24a605ec4d..7d4b64a7f3 100644
--- a/contrib/docs/Data.Path.html
+++ b/contrib/docs/Data.Path.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Path(source)
Definitions
data Path : (t -> t -> Type) -> t -> t -> Type
  Paths in a typed graph as a sequence of edges with source and target nodes matching up domino-style.
  AKA reflexive-transitive closure.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Path g i i
  
(::) : g i j -> Path g j k -> Path g i k
joinPath : Path g i j -> Path g j k -> Path g i k
  Totality: total
  Visibility: export
snocPath : Path g i j -> g j k -> Path g i k
  Totality: total
  Visibility: export
lengthPath : Path g i j -> Nat
  Totality: total
  Visibility: export
mapPath : {0 f : t -> u} -> (gt i j -> gu (f i) (f j)) -> Path gt i j -> Path gu (f i) (f j)
  Totality: total
  Visibility: export
foldPath : {0 gu : u -> u -> Type} -> {0 f : t -> u} -> (gt i j -> gu (f j) (f k) -> gu (f i) (f k)) -> Path gt i j -> gu (f j) (f k) -> gu (f i) (f k)
  Totality: total
  Visibility: export
foldlPath : {0 gu : u -> u -> Type} -> {0 f : t -> u} -> (gu (f i) (f j) -> gt j k -> gu (f i) (f k)) -> gu (f i) (f j) -> Path gt j k -> gu (f i) (f k)
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Path(source)
Definitions
data Path : (t -> t -> Type) -> t -> t -> Type
  Paths in a typed graph as a sequence of edges with source and target nodes matching up domino-style.
  AKA reflexive-transitive closure.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Path g i i
  
(::) : g i j -> Path g j k -> Path g i k
joinPath : Path g i j -> Path g j k -> Path g i k
  Totality: total
  Visibility: export
snocPath : Path g i j -> g j k -> Path g i k
  Totality: total
  Visibility: export
lengthPath : Path g i j -> Nat
  Totality: total
  Visibility: export
mapPath : {0 f : t -> u} -> (gt i j -> gu (f i) (f j)) -> Path gt i j -> Path gu (f i) (f j)
  Totality: total
  Visibility: export
foldPath : {0 gu : u -> u -> Type} -> {0 f : t -> u} -> (gt i j -> gu (f j) (f k) -> gu (f i) (f k)) -> Path gt i j -> gu (f j) (f k) -> gu (f i) (f k)
  Totality: total
  Visibility: export
foldlPath : {0 gu : u -> u -> Type} -> {0 f : t -> u} -> (gu (f i) (f j) -> gt j k -> gu (f i) (f k)) -> gu (f i) (f j) -> Path gt j k -> gu (f i) (f k)
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Rel.Complement.html b/contrib/docs/Data.Rel.Complement.html
index aa83517f13..d080917752 100644
--- a/contrib/docs/Data.Rel.Complement.html
+++ b/contrib/docs/Data.Rel.Complement.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Rel.Complement(source)
Definitions
complement : Rel ts -> Rel ts
  The logical complement of a relation.

  Totality: total
  Visibility: public export
notToComplement : (p : Rel ts) -> (elems : HVect ts) -> Not (uncurry p elems) = uncurry (complement p) elems
  The negation of a relation for some elements
  is equal to the complement of the relation.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Rel.Complement(source)
Definitions
complement : Rel ts -> Rel ts
  The logical complement of a relation.

  Totality: total
  Visibility: public export
notToComplement : (p : Rel ts) -> (elems : HVect ts) -> Not (uncurry p elems) = uncurry (complement p) elems
  The negation of a relation for some elements
  is equal to the complement of the relation.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.Seq.Internal.html b/contrib/docs/Data.Seq.Internal.html
index 6b4f530fce..8c7a2c27c5 100644
--- a/contrib/docs/Data.Seq.Internal.html
+++ b/contrib/docs/Data.Seq.Internal.html
@@ -71,4 +71,4 @@
 
 Original Copyrights: Copyright 2004, The University Court of the University of Glasgow
                      (c) Ross Paterson 2005
-
Definitions
data Elem : Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkElem : a -> Elem a

  Hints:
  
Applicative Elem
  
Eq a => Eq (Elem a)
  
Functor Elem
  
Ord a => Ord (Elem a)
  
Show a => Show (Elem a)
  
Sized (Elem a)
unElem : Elem a -> a
  Totality: total
  Visibility: export
data FingerTree : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Empty : FingerTree e
  
Single : e -> FingerTree e
  
Deep : Nat -> Digit e -> FingerTree (Node e) -> Digit e -> FingerTree e

  Hints:
  
Sized a => Eq a => Eq (FingerTree a)
  
Foldable FingerTree
  
Functor FingerTree
  
Sized a => Ord a => Ord (FingerTree a)
  
Show a => Show (FingerTree a)
  
Sized e => Sized (FingerTree e)
  
Traversable FingerTree
reverseTree : (a -> a) -> FingerTree a -> FingerTree a
  Totality: total
  Visibility: export
lookupTree : Sized a => Nat -> FingerTree a -> (Nat, a)
  Totality: total
  Visibility: export
adjustTree : Sized a => (Nat -> a -> a) -> Nat -> FingerTree a -> FingerTree a
  Totality: total
  Visibility: export
viewLTree : Sized a => FingerTree a -> Maybe (a, FingerTree a)
  Totality: total
  Visibility: export
viewRTree : Sized a => FingerTree a -> Maybe (FingerTree a, a)
  Totality: total
  Visibility: export
consTree : Sized e => e -> FingerTree e -> FingerTree e
  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 5
snocTree : Sized e => FingerTree e -> e -> FingerTree e
  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 5
split : Nat -> FingerTree (Elem a) -> (FingerTree (Elem a), FingerTree (Elem a))
  Totality: total
  Visibility: export
addTree0 : FingerTree (Elem a) -> FingerTree (Elem a) -> FingerTree (Elem a)
  Totality: total
  Visibility: export
toList' : FingerTree (Elem a) -> List a
  Totality: total
  Visibility: export
replicate' : Nat -> e -> FingerTree (Elem e)
  Totality: total
  Visibility: export
length' : FingerTree (Elem e) -> Nat
  Totality: total
  Visibility: export
zipWith' : (a -> b -> c) -> FingerTree (Elem a) -> FingerTree (Elem b) -> FingerTree (Elem c)
  Totality: total
  Visibility: export
zipWith3' : (a -> b -> c -> d) -> FingerTree (Elem a) -> FingerTree (Elem b) -> FingerTree (Elem c) -> FingerTree (Elem d)
  Totality: total
  Visibility: export
unzipWith' : (a -> (b, c)) -> FingerTree (Elem a) -> (FingerTree (Elem b), FingerTree (Elem c))
  Totality: total
  Visibility: export
unzipWith3' : (a -> (b, (c, d))) -> FingerTree (Elem a) -> (FingerTree (Elem b), (FingerTree (Elem c), FingerTree (Elem d)))
  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
data Elem : Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkElem : a -> Elem a

  Hints:
  
Applicative Elem
  
Eq a => Eq (Elem a)
  
Functor Elem
  
Ord a => Ord (Elem a)
  
Show a => Show (Elem a)
  
Sized (Elem a)
unElem : Elem a -> a
  Totality: total
  Visibility: export
data FingerTree : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Empty : FingerTree e
  
Single : e -> FingerTree e
  
Deep : Nat -> Digit e -> FingerTree (Node e) -> Digit e -> FingerTree e

  Hints:
  
Sized a => Eq a => Eq (FingerTree a)
  
Foldable FingerTree
  
Functor FingerTree
  
Sized a => Ord a => Ord (FingerTree a)
  
Show a => Show (FingerTree a)
  
Sized e => Sized (FingerTree e)
  
Traversable FingerTree
reverseTree : (a -> a) -> FingerTree a -> FingerTree a
  Totality: total
  Visibility: export
lookupTree : Sized a => Nat -> FingerTree a -> (Nat, a)
  Totality: total
  Visibility: export
adjustTree : Sized a => (Nat -> a -> a) -> Nat -> FingerTree a -> FingerTree a
  Totality: total
  Visibility: export
viewLTree : Sized a => FingerTree a -> Maybe (a, FingerTree a)
  Totality: total
  Visibility: export
viewRTree : Sized a => FingerTree a -> Maybe (FingerTree a, a)
  Totality: total
  Visibility: export
consTree : Sized e => e -> FingerTree e -> FingerTree e
  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 5
snocTree : Sized e => FingerTree e -> e -> FingerTree e
  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 5
split : Nat -> FingerTree (Elem a) -> (FingerTree (Elem a), FingerTree (Elem a))
  Totality: total
  Visibility: export
addTree0 : FingerTree (Elem a) -> FingerTree (Elem a) -> FingerTree (Elem a)
  Totality: total
  Visibility: export
toList' : FingerTree (Elem a) -> List a
  Totality: total
  Visibility: export
replicate' : Nat -> e -> FingerTree (Elem e)
  Totality: total
  Visibility: export
length' : FingerTree (Elem e) -> Nat
  Totality: total
  Visibility: export
zipWith' : (a -> b -> c) -> FingerTree (Elem a) -> FingerTree (Elem b) -> FingerTree (Elem c)
  Totality: total
  Visibility: export
zipWith3' : (a -> b -> c -> d) -> FingerTree (Elem a) -> FingerTree (Elem b) -> FingerTree (Elem c) -> FingerTree (Elem d)
  Totality: total
  Visibility: export
unzipWith' : (a -> (b, c)) -> FingerTree (Elem a) -> (FingerTree (Elem b), FingerTree (Elem c))
  Totality: total
  Visibility: export
unzipWith3' : (a -> (b, (c, d))) -> FingerTree (Elem a) -> (FingerTree (Elem b), (FingerTree (Elem c), FingerTree (Elem d)))
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Seq.Sized.html b/contrib/docs/Data.Seq.Sized.html
index c8a2d9aa93..fbf3409a21 100644
--- a/contrib/docs/Data.Seq.Sized.html
+++ b/contrib/docs/Data.Seq.Sized.html
@@ -65,4 +65,4 @@
 with length in its type.
 
 This is implemented by finger tree.
-
Reexports
import public Data.Fin
import public Data.Nat
import public Data.Vect
import public Data.Zippable
Definitions
data Seq : Nat -> Type -> Type
  A two-end finite sequences, with length in its type.

  Totality: total
  Visibility: export
  Constructor: 
MkSeq : FingerTree (Elem e) -> Seq n e

  Hints:
  
Applicative (Seq n)
  
Eq a => Eq (Seq n a)
  
Foldable (Seq n)
  
Functor (Seq n)
  
Ord a => Ord (Seq n a)
  
Show a => Show (Seq n a)
  
Sized (Seq n a)
  
Traversable (Seq n)
  
Zippable (Seq n)
empty : Seq 0 e
  O(1). The empty sequence.

  Totality: total
  Visibility: export
singleton : e -> Seq 1 e
  O(1). A singleton sequence.

  Totality: total
  Visibility: export
replicate : (n : Nat) -> e -> Seq n e
  O(n). A sequence of length n with a the value of every element.

  Totality: total
  Visibility: export
length : Seq n a -> Nat
  O(1). The number of elements in the sequence.

  Totality: total
  Visibility: export
reverse : Seq n a -> Seq n a
  O(n). Reverse the sequence.

  Totality: total
  Visibility: export
cons : e -> Seq n e -> Seq (S n) e
  O(1). Add an element to the left end of a sequence.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 5
snoc : Seq n e -> e -> Seq (S n) e
  O(1). Add an element to the right end of a sequence.

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 5
(++) : Seq m e -> Seq n e -> Seq (m + n) e
  O(log(min(m, n))). Concatenate two sequences.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 7
viewl : Seq (S n) a -> (a, Seq n a)
  O(1). View from the left of the sequence.

  Totality: total
  Visibility: export
head : Seq (S n) a -> a
  O(1). The first element of the sequence.

  Totality: total
  Visibility: export
tail : Seq (S n) a -> Seq n a
  O(1). The elements after the head of the sequence.

  Totality: total
  Visibility: export
viewr : Seq (S n) a -> (Seq n a, a)
  O(1). View from the right of the sequence.

  Totality: total
  Visibility: export
init : Seq (S n) a -> Seq n a
  O(1). The elements before the last element of the sequence.

  Totality: total
  Visibility: export
last : Seq (S n) a -> a
  O(1). The last element of the sequence.

  Totality: total
  Visibility: export
fromVect : Vect n a -> Seq n a
  O(n). Turn a vector into a sequence.

  Totality: total
  Visibility: export
fromList : (xs : List a) -> Seq (length xs) a
  O(n). Turn a list into a sequence.

  Totality: total
  Visibility: export
toVect : Seq n a -> Vect n a
  O(n). Turn a sequence into a vector.

  Totality: total
  Visibility: export
index : (i : Nat) -> Seq n a -> LT i n => a
  O(log(min(i, n-i))). The element at the specified position.

  Totality: total
  Visibility: export
index' : Seq n a -> Fin n -> a
  O(log(min(i, n-i))). The element at the specified position.
  Use Fin n to index instead.

  Totality: total
  Visibility: export
adjust : (a -> a) -> (i : Nat) -> Seq n a -> LT i n => Seq n a
  O(log(min(i, n-i))). Update the element at the specified position.

  Totality: total
  Visibility: export
update : (i : Nat) -> a -> Seq n a -> LT i n => Seq n a
  O(log(min(i, n-i))). Replace the element at the specified position.

  Totality: total
  Visibility: export
splitAt : (i : Nat) -> Seq (i + j) a -> (Seq i a, Seq j a)
  O(log(min(i, n-i))). Split a sequence at a given position.

  Totality: total
  Visibility: export
take : (i : Nat) -> Seq (i + j) a -> Seq i a
  O(log(min(i, n-i))). The first i elements of a sequence.

  Totality: total
  Visibility: export
drop : (i : Nat) -> Seq (i + j) a -> Seq j a
  O(log(min(i, n-i))). Elements of a sequence after the first i.

  Totality: total
  Visibility: export
show' : Show a => Seq n a -> String
  Dump the internal structure of the finger tree.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Reexports
import public Data.Fin
import public Data.Nat
import public Data.Vect
import public Data.Zippable
Definitions
data Seq : Nat -> Type -> Type
  A two-end finite sequences, with length in its type.

  Totality: total
  Visibility: export
  Constructor: 
MkSeq : FingerTree (Elem e) -> Seq n e

  Hints:
  
Applicative (Seq n)
  
Eq a => Eq (Seq n a)
  
Foldable (Seq n)
  
Functor (Seq n)
  
Ord a => Ord (Seq n a)
  
Show a => Show (Seq n a)
  
Sized (Seq n a)
  
Traversable (Seq n)
  
Zippable (Seq n)
empty : Seq 0 e
  O(1). The empty sequence.

  Totality: total
  Visibility: export
singleton : e -> Seq 1 e
  O(1). A singleton sequence.

  Totality: total
  Visibility: export
replicate : (n : Nat) -> e -> Seq n e
  O(n). A sequence of length n with a the value of every element.

  Totality: total
  Visibility: export
length : Seq n a -> Nat
  O(1). The number of elements in the sequence.

  Totality: total
  Visibility: export
reverse : Seq n a -> Seq n a
  O(n). Reverse the sequence.

  Totality: total
  Visibility: export
cons : e -> Seq n e -> Seq (S n) e
  O(1). Add an element to the left end of a sequence.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 5
snoc : Seq n e -> e -> Seq (S n) e
  O(1). Add an element to the right end of a sequence.

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 5
(++) : Seq m e -> Seq n e -> Seq (m + n) e
  O(log(min(m, n))). Concatenate two sequences.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 7
viewl : Seq (S n) a -> (a, Seq n a)
  O(1). View from the left of the sequence.

  Totality: total
  Visibility: export
head : Seq (S n) a -> a
  O(1). The first element of the sequence.

  Totality: total
  Visibility: export
tail : Seq (S n) a -> Seq n a
  O(1). The elements after the head of the sequence.

  Totality: total
  Visibility: export
viewr : Seq (S n) a -> (Seq n a, a)
  O(1). View from the right of the sequence.

  Totality: total
  Visibility: export
init : Seq (S n) a -> Seq n a
  O(1). The elements before the last element of the sequence.

  Totality: total
  Visibility: export
last : Seq (S n) a -> a
  O(1). The last element of the sequence.

  Totality: total
  Visibility: export
fromVect : Vect n a -> Seq n a
  O(n). Turn a vector into a sequence.

  Totality: total
  Visibility: export
fromList : (xs : List a) -> Seq (length xs) a
  O(n). Turn a list into a sequence.

  Totality: total
  Visibility: export
toVect : Seq n a -> Vect n a
  O(n). Turn a sequence into a vector.

  Totality: total
  Visibility: export
index : (i : Nat) -> Seq n a -> LT i n => a
  O(log(min(i, n-i))). The element at the specified position.

  Totality: total
  Visibility: export
index' : Seq n a -> Fin n -> a
  O(log(min(i, n-i))). The element at the specified position.
  Use Fin n to index instead.

  Totality: total
  Visibility: export
adjust : (a -> a) -> (i : Nat) -> Seq n a -> LT i n => Seq n a
  O(log(min(i, n-i))). Update the element at the specified position.

  Totality: total
  Visibility: export
update : (i : Nat) -> a -> Seq n a -> LT i n => Seq n a
  O(log(min(i, n-i))). Replace the element at the specified position.

  Totality: total
  Visibility: export
splitAt : (i : Nat) -> Seq (i + j) a -> (Seq i a, Seq j a)
  O(log(min(i, n-i))). Split a sequence at a given position.

  Totality: total
  Visibility: export
take : (i : Nat) -> Seq (i + j) a -> Seq i a
  O(log(min(i, n-i))). The first i elements of a sequence.

  Totality: total
  Visibility: export
drop : (i : Nat) -> Seq (i + j) a -> Seq j a
  O(log(min(i, n-i))). Elements of a sequence after the first i.

  Totality: total
  Visibility: export
show' : Show a => Seq n a -> String
  Dump the internal structure of the finger tree.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Seq.Unsized.html b/contrib/docs/Data.Seq.Unsized.html
index 0570a3215e..5c075deeec 100644
--- a/contrib/docs/Data.Seq.Unsized.html
+++ b/contrib/docs/Data.Seq.Unsized.html
@@ -64,4 +64,4 @@
 
Data.Seq.Unsized(source)
General purpose two-end finite sequences.
 
 This is implemented by finger tree.
-
Reexports
import public Data.Zippable
Definitions
data Seq : Type -> Type
  A two-end finite sequences.

  Totality: total
  Visibility: export
  Constructor: 
MkSeq : FingerTree (Elem e) -> Seq e

  Hints:
  
Applicative Seq
  
Eq a => Eq (Seq a)
  
Foldable Seq
  
Functor Seq
  
Monad Seq
  
Monoid (Seq a)
  
Ord a => Ord (Seq a)
  
Semigroup (Seq a)
  
Show a => Show (Seq a)
  
Sized (Seq a)
  
Traversable Seq
  
Zippable Seq
empty : Seq e
  O(1). The empty sequence.

  Totality: total
  Visibility: export
singleton : e -> Seq e
  O(1). A singleton sequence.

  Totality: total
  Visibility: export
replicate : Nat -> e -> Seq e
  O(n). A sequence of length n with a the value of every element.

  Totality: total
  Visibility: export
length : Seq a -> Nat
  O(1). The number of elements in the sequence.

  Totality: total
  Visibility: export
reverse : Seq a -> Seq a
  O(n). Reverse the sequence.

  Totality: total
  Visibility: export
cons : e -> Seq e -> Seq e
  O(1). Add an element to the left end of a sequence.

  Totality: total
  Visibility: export
  Fixity Declarations:
  infixr operator, level 5
infixr operator, level 5
snoc : Seq e -> e -> Seq e
  O(1). Add an element to the right end of a sequence.

  Totality: total
  Visibility: export
  Fixity Declarations:
  infixl operator, level 5
infixl operator, level 5
(++) : Seq e -> Seq e -> Seq e
  O(log(min(m, n))). Concatenate two sequences.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 7
viewl : Seq a -> Maybe (a, Seq a)
  O(1). View from the left of the sequence.

  Totality: total
  Visibility: export
head : Seq a -> Maybe a
  O(1). The first element of the sequence.

  Totality: total
  Visibility: export
tail : Seq a -> Seq a
  O(1). The elements after the head of the sequence.
  Returns an empty sequence when the sequence is empty.

  Totality: total
  Visibility: export
viewr : Seq a -> Maybe (Seq a, a)
  O(1). View from the right of the sequence.

  Totality: total
  Visibility: export
init : Seq a -> Seq a
  O(1). The elements before the last element of the sequence.
  Returns an empty sequence when the sequence is empty.

  Totality: total
  Visibility: export
last : Seq a -> Maybe a
  O(1). The last element of the sequence.

  Totality: total
  Visibility: export
fromList : List a -> Seq a
  O(n). Turn a list into a sequence.

  Totality: total
  Visibility: export
index : Nat -> Seq a -> Maybe a
  O(log(min(i, n-i))). The element at the specified position.

  Totality: total
  Visibility: export
adjust : (a -> a) -> Nat -> Seq a -> Seq a
  O(log(min(i, n-i))). Update the element at the specified position.
  If the position is out of range, the original sequence is returned.

  Totality: total
  Visibility: export
update : Nat -> a -> Seq a -> Seq a
  O(log(min(i, n-i))). Replace the element at the specified position.
  If the position is out of range, the original sequence is returned.

  Totality: total
  Visibility: export
splitAt : Nat -> Seq a -> (Seq a, Seq a)
  O(log(min(i, n-i))). Split a sequence at a given position.
  splitAt i s = (take i s, drop i s)

  Totality: total
  Visibility: export
take : Nat -> Seq a -> Seq a
  O(log(min(i,n-i))). The first i elements of a sequence.
  If the sequence contains fewer than i elements, the whole sequence is returned.

  Totality: total
  Visibility: export
drop : Nat -> Seq a -> Seq a
  O(log(min(i,n-i))). Elements of a sequence after the first i.
  If the sequence contains fewer than i elements, the empty sequence is returned.

  Totality: total
  Visibility: export
show' : Show a => Seq a -> String
  Dump the internal structure of the finger tree.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Reexports
import public Data.Zippable
Definitions
data Seq : Type -> Type
  A two-end finite sequences.

  Totality: total
  Visibility: export
  Constructor: 
MkSeq : FingerTree (Elem e) -> Seq e

  Hints:
  
Applicative Seq
  
Eq a => Eq (Seq a)
  
Foldable Seq
  
Functor Seq
  
Monad Seq
  
Monoid (Seq a)
  
Ord a => Ord (Seq a)
  
Semigroup (Seq a)
  
Show a => Show (Seq a)
  
Sized (Seq a)
  
Traversable Seq
  
Zippable Seq
empty : Seq e
  O(1). The empty sequence.

  Totality: total
  Visibility: export
singleton : e -> Seq e
  O(1). A singleton sequence.

  Totality: total
  Visibility: export
replicate : Nat -> e -> Seq e
  O(n). A sequence of length n with a the value of every element.

  Totality: total
  Visibility: export
length : Seq a -> Nat
  O(1). The number of elements in the sequence.

  Totality: total
  Visibility: export
reverse : Seq a -> Seq a
  O(n). Reverse the sequence.

  Totality: total
  Visibility: export
cons : e -> Seq e -> Seq e
  O(1). Add an element to the left end of a sequence.

  Totality: total
  Visibility: export
  Fixity Declarations:
  infixr operator, level 5
infixr operator, level 5
snoc : Seq e -> e -> Seq e
  O(1). Add an element to the right end of a sequence.

  Totality: total
  Visibility: export
  Fixity Declarations:
  infixl operator, level 5
infixl operator, level 5
(++) : Seq e -> Seq e -> Seq e
  O(log(min(m, n))). Concatenate two sequences.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 7
viewl : Seq a -> Maybe (a, Seq a)
  O(1). View from the left of the sequence.

  Totality: total
  Visibility: export
head : Seq a -> Maybe a
  O(1). The first element of the sequence.

  Totality: total
  Visibility: export
tail : Seq a -> Seq a
  O(1). The elements after the head of the sequence.
  Returns an empty sequence when the sequence is empty.

  Totality: total
  Visibility: export
viewr : Seq a -> Maybe (Seq a, a)
  O(1). View from the right of the sequence.

  Totality: total
  Visibility: export
init : Seq a -> Seq a
  O(1). The elements before the last element of the sequence.
  Returns an empty sequence when the sequence is empty.

  Totality: total
  Visibility: export
last : Seq a -> Maybe a
  O(1). The last element of the sequence.

  Totality: total
  Visibility: export
fromList : List a -> Seq a
  O(n). Turn a list into a sequence.

  Totality: total
  Visibility: export
index : Nat -> Seq a -> Maybe a
  O(log(min(i, n-i))). The element at the specified position.

  Totality: total
  Visibility: export
adjust : (a -> a) -> Nat -> Seq a -> Seq a
  O(log(min(i, n-i))). Update the element at the specified position.
  If the position is out of range, the original sequence is returned.

  Totality: total
  Visibility: export
update : Nat -> a -> Seq a -> Seq a
  O(log(min(i, n-i))). Replace the element at the specified position.
  If the position is out of range, the original sequence is returned.

  Totality: total
  Visibility: export
splitAt : Nat -> Seq a -> (Seq a, Seq a)
  O(log(min(i, n-i))). Split a sequence at a given position.
  splitAt i s = (take i s, drop i s)

  Totality: total
  Visibility: export
take : Nat -> Seq a -> Seq a
  O(log(min(i,n-i))). The first i elements of a sequence.
  If the sequence contains fewer than i elements, the whole sequence is returned.

  Totality: total
  Visibility: export
drop : Nat -> Seq a -> Seq a
  O(log(min(i,n-i))). Elements of a sequence after the first i.
  If the sequence contains fewer than i elements, the empty sequence is returned.

  Totality: total
  Visibility: export
show' : Show a => Seq a -> String
  Dump the internal structure of the finger tree.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Stream.Extra.html b/contrib/docs/Data.Stream.Extra.html
index 5bc5e52598..eba313e3b0 100644
--- a/contrib/docs/Data.Stream.Extra.html
+++ b/contrib/docs/Data.Stream.Extra.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Stream.Extra(source)
Definitions
startWith : Foldable t => t a -> Stream a -> Stream a
  Insert elements from a Foldable at the start of an existing Stream
  @ pfx the Foldable containing elements to prepend
  @ stream the Stream to prepend the elements to

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Stream.Extra(source)
Definitions
startWith : Foldable t => t a -> Stream a -> Stream a
  Insert elements from a Foldable at the start of an existing Stream
  @ pfx the Foldable containing elements to prepend
  @ stream the Stream to prepend the elements to

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.String.Extra.html b/contrib/docs/Data.String.Extra.html
index 6e74f4758d..1cc393ddf6 100644
--- a/contrib/docs/Data.String.Extra.html
+++ b/contrib/docs/Data.String.Extra.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.String.Extra(source)
Definitions
strSnoc : String -> Char -> String
  Adds a character to the end of the specified string.
  
  ```idris example
  strSnoc "AB" 'C'
  ```
  ```idris example
  strSnoc "" 'A'
  ```

  Totality: total
  Visibility: public export
(+>) : String -> Char -> String
  Alias of `strSnoc`
  
  ```idris example
  "AB" +> 'C'
  ```

  Totality: total
  Visibility: public export
  Fixity Declarations:
  infixl operator, level 5
infixl operator, level 5
(<+) : Char -> String -> String
  Alias of `strCons`
  
  ```idris example
  'A' <+ "AB"
  ```

  Totality: total
  Visibility: public export
  Fixity Declarations:
  infixr operator, level 5
infixr operator, level 5
take : Nat -> String -> String
  Take the first `n` characters from a string. Returns the whole string
  if it's too short.

  Totality: total
  Visibility: public export
takeLast : Nat -> String -> String
  Take the last `n` characters from a string. Returns the whole string
  if it's too short.

  Totality: total
  Visibility: public export
drop : Nat -> String -> String
  Remove the first `n` characters from a string. Returns the empty string if
  the input string is too short.

  Totality: total
  Visibility: public export
dropLast : Nat -> String -> String
  Remove the last `n` characters from a string. Returns the empty string if
  the input string is too short.

  Totality: total
  Visibility: public export
shrink : Nat -> String -> String
  Remove the first and last `n` characters from a string. Returns the empty
  string if the input string is too short.

  Totality: total
  Visibility: public export
join : String -> Foldable t => t String -> String
  Concatenate the strings from a `Foldable` containing strings, separated by
  the given string.

  Totality: total
  Visibility: public export
index : Nat -> String -> Maybe Char
  Get a character from a string if the string is long enough.

  Totality: total
  Visibility: public export
indentLines : Nat -> String -> String
  Indent each line of a given string by `n` spaces.

  Totality: total
  Visibility: public export
justifyLeft : Nat -> Char -> String -> String
  Left-justify a string to the given length, using the
  specified fill character on the right.

  Totality: total
  Visibility: export
justifyRight : Nat -> Char -> String -> String
  Right-justify a string to the given length, using the
  specified fill character on the left.

  Totality: total
  Visibility: export
leftEllipsis : Nat -> String -> String -> String
  Truncates a string to the given length.
  If the given string is longer, replace first characters with given prefix.
  
  Say, `leftEllipsis 5 ".." "abcdefgh"` should give `"..fgh"` and
  `leftEllipsis 5 "" "abcdefgh"` should give `"defgh"`.
  
  Notice, that the resulting string can be longer than max length if the prefix is longer.

  Totality: total
  Visibility: export
rightEllipsis : Nat -> String -> String -> String
  Truncates a string to the given length.
  If the given string is longer, replace last characters with given suffix.
  
  Say, `rightEllipsis 5 ".." "abcdefgh"` should give `"abc.."` and
  `rightEllipsis 5 "" "abcdefgh"` should give `"abcde"`.
  
  Notice, that the resulting string can be longer than max length if the suffix is longer.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.String.Extra(source)
Definitions
strSnoc : String -> Char -> String
  Adds a character to the end of the specified string.
  
  ```idris example
  strSnoc "AB" 'C'
  ```
  ```idris example
  strSnoc "" 'A'
  ```

  Totality: total
  Visibility: public export
(+>) : String -> Char -> String
  Alias of `strSnoc`
  
  ```idris example
  "AB" +> 'C'
  ```

  Totality: total
  Visibility: public export
  Fixity Declarations:
  infixl operator, level 5
infixl operator, level 5
(<+) : Char -> String -> String
  Alias of `strCons`
  
  ```idris example
  'A' <+ "AB"
  ```

  Totality: total
  Visibility: public export
  Fixity Declarations:
  infixr operator, level 5
infixr operator, level 5
take : Nat -> String -> String
  Take the first `n` characters from a string. Returns the whole string
  if it's too short.

  Totality: total
  Visibility: public export
takeLast : Nat -> String -> String
  Take the last `n` characters from a string. Returns the whole string
  if it's too short.

  Totality: total
  Visibility: public export
drop : Nat -> String -> String
  Remove the first `n` characters from a string. Returns the empty string if
  the input string is too short.

  Totality: total
  Visibility: public export
dropLast : Nat -> String -> String
  Remove the last `n` characters from a string. Returns the empty string if
  the input string is too short.

  Totality: total
  Visibility: public export
shrink : Nat -> String -> String
  Remove the first and last `n` characters from a string. Returns the empty
  string if the input string is too short.

  Totality: total
  Visibility: public export
join : String -> Foldable t => t String -> String
  Concatenate the strings from a `Foldable` containing strings, separated by
  the given string.

  Totality: total
  Visibility: public export
index : Nat -> String -> Maybe Char
  Get a character from a string if the string is long enough.

  Totality: total
  Visibility: public export
indentLines : Nat -> String -> String
  Indent each line of a given string by `n` spaces.

  Totality: total
  Visibility: public export
justifyLeft : Nat -> Char -> String -> String
  Left-justify a string to the given length, using the
  specified fill character on the right.

  Totality: total
  Visibility: export
justifyRight : Nat -> Char -> String -> String
  Right-justify a string to the given length, using the
  specified fill character on the left.

  Totality: total
  Visibility: export
leftEllipsis : Nat -> String -> String -> String
  Truncates a string to the given length.
  If the given string is longer, replace first characters with given prefix.
  
  Say, `leftEllipsis 5 ".." "abcdefgh"` should give `"..fgh"` and
  `leftEllipsis 5 "" "abcdefgh"` should give `"defgh"`.
  
  Notice, that the resulting string can be longer than max length if the prefix is longer.

  Totality: total
  Visibility: export
rightEllipsis : Nat -> String -> String -> String
  Truncates a string to the given length.
  If the given string is longer, replace last characters with given suffix.
  
  Say, `rightEllipsis 5 ".." "abcdefgh"` should give `"abc.."` and
  `rightEllipsis 5 "" "abcdefgh"` should give `"abcde"`.
  
  Notice, that the resulting string can be longer than max length if the suffix is longer.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.String.Interpolation.html b/contrib/docs/Data.String.Interpolation.html
index 7ad857c5b4..ceeac91206 100644
--- a/contrib/docs/Data.String.Interpolation.html
+++ b/contrib/docs/Data.String.Interpolation.html
@@ -63,4 +63,4 @@
 
 
Data.String.Interpolation(source)
A DYI version of 'string interpolation', mimicking Python 3's 'f-string' syntax
 Not as fancy
-
Definitions
F : List String -> String
  Visibility: public export
F : List (List String) -> String
  Visibility: public export

\ No newline at end of file
+
Definitions
F : List String -> String
  Visibility: public export
F : List (List String) -> String
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.String.Iterator.html b/contrib/docs/Data.String.Iterator.html
index 6b213558e5..50c11e4706 100644
--- a/contrib/docs/Data.String.Iterator.html
+++ b/contrib/docs/Data.String.Iterator.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.String.Iterator(source)
Reexports
import public Data.List.Lazy
Definitions
data StringIterator : String -> Type
  Totality: total
  Visibility: export
withString : (str : String) -> ((1 _ : StringIterator str) -> a) -> a
  Totality: total
  Visibility: export
withIteratorString : (str : String) -> (1 _ : StringIterator str) -> (String -> a) -> a
  Runs the action `f` on the slice `res` of the original string `str` represented by the
  iterator `it`
data UnconsResult : String -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
EOF : UnconsResult str
  
Character : Char -> (1 _ : StringIterator str) -> UnconsResult str
uncons : (str : String) -> (1 _ : StringIterator str) -> UnconsResult str
foldl : (accTy -> Char -> accTy) -> accTy -> String -> accTy
  Totality: total
  Visibility: export
unpack : String -> LazyList Char
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.String.Iterator(source)
Reexports
import public Data.List.Lazy
Definitions
data StringIterator : String -> Type
  Totality: total
  Visibility: export
withString : (str : String) -> ((1 _ : StringIterator str) -> a) -> a
  Totality: total
  Visibility: export
withIteratorString : (str : String) -> (1 _ : StringIterator str) -> (String -> a) -> a
  Runs the action `f` on the slice `res` of the original string `str` represented by the
  iterator `it`
data UnconsResult : String -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
EOF : UnconsResult str
  
Character : Char -> (1 _ : StringIterator str) -> UnconsResult str
uncons : (str : String) -> (1 _ : StringIterator str) -> UnconsResult str
foldl : (accTy -> Char -> accTy) -> accTy -> String -> accTy
  Totality: total
  Visibility: export
unpack : String -> LazyList Char
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.String.Parser.Expression.html b/contrib/docs/Data.String.Parser.Expression.html
index bf66a78749..906e1f8851 100644
--- a/contrib/docs/Data.String.Parser.Expression.html
+++ b/contrib/docs/Data.String.Parser.Expression.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.String.Parser.Expression(source)
Definitions
data Assoc : Type
  Totality: total
  Visibility: public export
  Constructors:
  
AssocNone : Assoc
  
AssocLeft : Assoc
  
AssocRight : Assoc
data Operator : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Infix : Parser (a -> a -> a) -> Assoc -> Operator a
  
Prefix : Parser (a -> a) -> Operator a
  
Postfix : Parser (a -> a) -> Operator a
OperatorTable : Type -> Type
  Visibility: public export
BinaryOperator : Type -> Type
  Visibility: public export
UnaryOperator : Type -> Type
  Visibility: public export
data Ops : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
BinOp : BinaryOperator a -> Ops a
  
UnOp : UnaryOperator a -> Ops a
ReturnType : Type -> Type
  Visibility: public export
buildExpressionParser : (a : Type) -> OperatorTable a -> Parser a -> Parser a
  Visibility: public export

\ No newline at end of file
+
Data.String.Parser.Expression(source)
Definitions
data Assoc : Type
  Totality: total
  Visibility: public export
  Constructors:
  
AssocNone : Assoc
  
AssocLeft : Assoc
  
AssocRight : Assoc
data Operator : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Infix : Parser (a -> a -> a) -> Assoc -> Operator a
  
Prefix : Parser (a -> a) -> Operator a
  
Postfix : Parser (a -> a) -> Operator a
OperatorTable : Type -> Type
  Visibility: public export
BinaryOperator : Type -> Type
  Visibility: public export
UnaryOperator : Type -> Type
  Visibility: public export
data Ops : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
BinOp : BinaryOperator a -> Ops a
  
UnOp : UnaryOperator a -> Ops a
ReturnType : Type -> Type
  Visibility: public export
buildExpressionParser : (a : Type) -> OperatorTable a -> Parser a -> Parser a
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.String.Parser.html b/contrib/docs/Data.String.Parser.html
index 84bc6a3555..36d24e7519 100644
--- a/contrib/docs/Data.String.Parser.html
+++ b/contrib/docs/Data.String.Parser.html
@@ -62,4 +62,4 @@
 
 
 
Data.String.Parser(source)
A simple parser combinator library for String. Inspired by attoparsec zepto.
-
Reexports
import public Control.Monad.Identity
Definitions
record State : Type
  The input state, pos is position in the string and maxPos is the length of the input string.

  Totality: total
  Visibility: public export
  Constructor: 
S : String -> Int -> Int -> State

  Projections:
  
.input : State -> String
  
.maxPos : State -> Int
  
.pos : State -> Int

  Hint: 
Show State
.input : State -> String
  Totality: total
  Visibility: public export
input : State -> String
  Totality: total
  Visibility: public export
.pos : State -> Int
  Totality: total
  Visibility: public export
pos : State -> Int
  Totality: total
  Visibility: public export
.maxPos : State -> Int
  Totality: total
  Visibility: public export
maxPos : State -> Int
  Totality: total
  Visibility: public export
data Result : Type -> Type
  Result of applying a parser

  Totality: total
  Visibility: public export
  Constructors:
  
Fail : Int -> String -> Result a
  
OK : a -> State -> Result a

  Hint: 
Functor Result
record ParseT : (Type -> Type) -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
P : (State -> m (Result a)) -> ParseT m a

  Projection: 
.runParser : ParseT m a -> State -> m (Result a)

  Hints:
  
Monad m => Alternative (ParseT m)
  
Monad m => Applicative (ParseT m)
  
Functor m => Functor (ParseT m)
  
Monad m => Monad (ParseT m)
  
MonadTrans ParseT
.runParser : ParseT m a -> State -> m (Result a)
  Totality: total
  Visibility: public export
runParser : ParseT m a -> State -> m (Result a)
  Totality: total
  Visibility: public export
Parser : Type -> Type
  Totality: total
  Visibility: public export
parseT : Functor m => ParseT m a -> String -> m (Either String (a, Int))
  Run a parser in a monad
  Returns a tuple of the result and final position on success.
  Returns an error message on failure.

  Totality: total
  Visibility: export
parse : Parser a -> String -> Either String (a, Int)
  Run a parser in a pure function
  Returns a tuple of the result and final position on success.
  Returns an error message on failure.

  Totality: total
  Visibility: export
(<?>) : Functor m => ParseT m a -> String -> ParseT m a
  Combinator that replaces the error message on failure.
  This allows combinators to output relevant errors

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 0
skip : Functor m => ParseT m a -> ParseT m ()
  Discards the result of a parser

  Totality: total
  Visibility: export
optionMap : Functor m => b -> (a -> b) -> ParseT m a -> ParseT m b
  Maps the result of the parser `p` or returns `def` if it fails.

  Totality: total
  Visibility: export
option : Functor m => a -> ParseT m a -> ParseT m a
  Runs the result of the parser `p` or returns `def` if it fails.

  Totality: total
  Visibility: export
succeeds : Functor m => ParseT m a -> ParseT m Bool
  Returns a Bool indicating whether `p` succeeded

  Totality: total
  Visibility: export
optional : Functor m => ParseT m a -> ParseT m (Maybe a)
  Returns a Maybe that contains the result of `p` if it succeeds or `Nothing` if it fails.

  Totality: total
  Visibility: export
requireFailure : Functor m => ParseT m a -> ParseT m ()
  Succeeds if and only if the argument parser fails.
  
  In Parsec, this combinator is called `notFollowedBy`.

  Totality: total
  Visibility: export
fail : Applicative m => String -> ParseT m a
  Fail with some error message

  Totality: total
  Visibility: export
satisfy : Applicative m => (Char -> Bool) -> ParseT m Char
  Succeeds if the next char satisfies the predicate `f`

  Totality: total
  Visibility: export
string : Applicative m => String -> ParseT m String
  Succeeds if the string `str` follows.

  Totality: total
  Visibility: export
eos : Applicative m => ParseT m ()
  Succeeds if the end of the string is reached.

  Totality: total
  Visibility: export
char : Applicative m => Char -> ParseT m Char
  Succeeds if the next char is `c`

  Totality: total
  Visibility: export
space : Applicative m => ParseT m Char
  Parses a space character

  Totality: total
  Visibility: export
alphaNum : Applicative m => ParseT m Char
  Parses a letter or digit (a character between \'0\' and \'9\').
  Returns the parsed character.

  Totality: total
  Visibility: export
letter : Applicative m => ParseT m Char
  Parses a letter (an upper case or lower case character). Returns the
  parsed character.

  Totality: total
  Visibility: export
some : Monad m => ParseT m a -> ParseT m (List a)
  Succeeds if `p` succeeds, will continue to match `p` until it fails
  and accumulate the results in a list

  Visibility: export
many : Monad m => ParseT m a -> ParseT m (List a)
  Always succeeds, will accumulate the results of `p` in a list until it fails.

  Visibility: export
hchainl : Monad m => ParseT m init -> ParseT m (init -> arg -> init) -> ParseT m arg -> ParseT m init
  Parse left-nested lists of the form `((init op arg) op arg) op arg`

  Visibility: export
hchainr : Monad m => ParseT m arg -> ParseT m (arg -> end -> end) -> ParseT m end -> ParseT m end
  Parse right-nested lists of the form `arg op (arg op (arg op end))`

  Visibility: export
takeWhile : Monad m => (Char -> Bool) -> ParseT m String
  Always succeeds, applies the predicate `f` on chars until it fails and creates a string
  from the results.

  Visibility: export
takeWhile1 : Monad m => (Char -> Bool) -> ParseT m String
  Similar to `takeWhile` but fails if the resulting string is empty.

  Visibility: export
takeUntil : Monad m => String -> ParseT m String
  Takes from the input until the `stop` string is found.
  Fails if the `stop` string cannot be found.

  Visibility: export
spaces : Monad m => ParseT m ()
  Parses zero or more space characters

  Visibility: export
spaces1 : Monad m => ParseT m ()
  Parses one or more space characters

  Visibility: export
parens : Monad m => ParseT m a -> ParseT m a
  Discards brackets around a matching parser

  Totality: total
  Visibility: export
lexeme : Monad m => ParseT m a -> ParseT m a
  Discards whitespace after a matching parser

  Visibility: export
token : Monad m => String -> ParseT m ()
  Matches a specific string, then skips following whitespace

  Visibility: export
digit : Monad m => ParseT m (Fin 10)
  Matches a single digit

  Totality: total
  Visibility: export
natural : Monad m => ParseT m Nat
  Matches a natural number

  Visibility: export
integer : Monad m => ParseT m Integer
  Matches an integer, eg. "12", "-4"

  Visibility: export
sepBy1 : Monad m => ParseT m a -> ParseT m b -> ParseT m (List1 a)
  Parse repeated instances of at least one `p`, separated by `s`,
  returning a list of successes.
  
  @ p the parser for items
  @ s the parser for separators

  Visibility: export
sepBy : Monad m => ParseT m a -> ParseT m b -> ParseT m (List a)
  Parse zero or more `p`s, separated by `s`s, returning a list of
  successes.
  
  @ p the parser for items
  @ s the parser for separators

  Visibility: export
commaSep1 : Monad m => ParseT m a -> ParseT m (List1 a)
  Parses /one/ or more occurrences of `p` separated by `comma`.

  Visibility: export
commaSep : Monad m => ParseT m a -> ParseT m (List a)
  Parses /zero/ or more occurrences of `p` separated by `comma`.

  Visibility: export
alternating : Monad m => ParseT m a -> ParseT m b -> ParseT m (Odd a b)
  Parses alternating occurrences of `a`s and `b`s.
  Can be thought of as parsing:
  - a list of `b`s, separated, and surrounded, by `a`s
  - a non-empty list of `a`s, separated by `b`s
  where we care about the separators

  Visibility: export
ntimes : Monad m => (n : Nat) -> ParseT m a -> ParseT m (Vect n a)
  Run the specified parser precisely `n` times, returning a vector
  of successes.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Reexports
import public Control.Monad.Identity
Definitions
record State : Type
  The input state, pos is position in the string and maxPos is the length of the input string.

  Totality: total
  Visibility: public export
  Constructor: 
S : String -> Int -> Int -> State

  Projections:
  
.input : State -> String
  
.maxPos : State -> Int
  
.pos : State -> Int

  Hint: 
Show State
.input : State -> String
  Totality: total
  Visibility: public export
input : State -> String
  Totality: total
  Visibility: public export
.pos : State -> Int
  Totality: total
  Visibility: public export
pos : State -> Int
  Totality: total
  Visibility: public export
.maxPos : State -> Int
  Totality: total
  Visibility: public export
maxPos : State -> Int
  Totality: total
  Visibility: public export
data Result : Type -> Type
  Result of applying a parser

  Totality: total
  Visibility: public export
  Constructors:
  
Fail : Int -> String -> Result a
  
OK : a -> State -> Result a

  Hint: 
Functor Result
record ParseT : (Type -> Type) -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
P : (State -> m (Result a)) -> ParseT m a

  Projection: 
.runParser : ParseT m a -> State -> m (Result a)

  Hints:
  
Monad m => Alternative (ParseT m)
  
Monad m => Applicative (ParseT m)
  
Functor m => Functor (ParseT m)
  
Monad m => Monad (ParseT m)
  
MonadTrans ParseT
.runParser : ParseT m a -> State -> m (Result a)
  Totality: total
  Visibility: public export
runParser : ParseT m a -> State -> m (Result a)
  Totality: total
  Visibility: public export
Parser : Type -> Type
  Totality: total
  Visibility: public export
parseT : Functor m => ParseT m a -> String -> m (Either String (a, Int))
  Run a parser in a monad
  Returns a tuple of the result and final position on success.
  Returns an error message on failure.

  Totality: total
  Visibility: export
parse : Parser a -> String -> Either String (a, Int)
  Run a parser in a pure function
  Returns a tuple of the result and final position on success.
  Returns an error message on failure.

  Totality: total
  Visibility: export
(<?>) : Functor m => ParseT m a -> String -> ParseT m a
  Combinator that replaces the error message on failure.
  This allows combinators to output relevant errors

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 0
skip : Functor m => ParseT m a -> ParseT m ()
  Discards the result of a parser

  Totality: total
  Visibility: export
optionMap : Functor m => b -> (a -> b) -> ParseT m a -> ParseT m b
  Maps the result of the parser `p` or returns `def` if it fails.

  Totality: total
  Visibility: export
option : Functor m => a -> ParseT m a -> ParseT m a
  Runs the result of the parser `p` or returns `def` if it fails.

  Totality: total
  Visibility: export
succeeds : Functor m => ParseT m a -> ParseT m Bool
  Returns a Bool indicating whether `p` succeeded

  Totality: total
  Visibility: export
optional : Functor m => ParseT m a -> ParseT m (Maybe a)
  Returns a Maybe that contains the result of `p` if it succeeds or `Nothing` if it fails.

  Totality: total
  Visibility: export
requireFailure : Functor m => ParseT m a -> ParseT m ()
  Succeeds if and only if the argument parser fails.
  
  In Parsec, this combinator is called `notFollowedBy`.

  Totality: total
  Visibility: export
fail : Applicative m => String -> ParseT m a
  Fail with some error message

  Totality: total
  Visibility: export
satisfy : Applicative m => (Char -> Bool) -> ParseT m Char
  Succeeds if the next char satisfies the predicate `f`

  Totality: total
  Visibility: export
string : Applicative m => String -> ParseT m String
  Succeeds if the string `str` follows.

  Totality: total
  Visibility: export
eos : Applicative m => ParseT m ()
  Succeeds if the end of the string is reached.

  Totality: total
  Visibility: export
char : Applicative m => Char -> ParseT m Char
  Succeeds if the next char is `c`

  Totality: total
  Visibility: export
space : Applicative m => ParseT m Char
  Parses a space character

  Totality: total
  Visibility: export
alphaNum : Applicative m => ParseT m Char
  Parses a letter or digit (a character between \'0\' and \'9\').
  Returns the parsed character.

  Totality: total
  Visibility: export
letter : Applicative m => ParseT m Char
  Parses a letter (an upper case or lower case character). Returns the
  parsed character.

  Totality: total
  Visibility: export
some : Monad m => ParseT m a -> ParseT m (List a)
  Succeeds if `p` succeeds, will continue to match `p` until it fails
  and accumulate the results in a list

  Visibility: export
many : Monad m => ParseT m a -> ParseT m (List a)
  Always succeeds, will accumulate the results of `p` in a list until it fails.

  Visibility: export
hchainl : Monad m => ParseT m init -> ParseT m (init -> arg -> init) -> ParseT m arg -> ParseT m init
  Parse left-nested lists of the form `((init op arg) op arg) op arg`

  Visibility: export
hchainr : Monad m => ParseT m arg -> ParseT m (arg -> end -> end) -> ParseT m end -> ParseT m end
  Parse right-nested lists of the form `arg op (arg op (arg op end))`

  Visibility: export
takeWhile : Monad m => (Char -> Bool) -> ParseT m String
  Always succeeds, applies the predicate `f` on chars until it fails and creates a string
  from the results.

  Visibility: export
takeWhile1 : Monad m => (Char -> Bool) -> ParseT m String
  Similar to `takeWhile` but fails if the resulting string is empty.

  Visibility: export
takeUntil : Monad m => String -> ParseT m String
  Takes from the input until the `stop` string is found.
  Fails if the `stop` string cannot be found.

  Visibility: export
spaces : Monad m => ParseT m ()
  Parses zero or more space characters

  Visibility: export
spaces1 : Monad m => ParseT m ()
  Parses one or more space characters

  Visibility: export
parens : Monad m => ParseT m a -> ParseT m a
  Discards brackets around a matching parser

  Totality: total
  Visibility: export
lexeme : Monad m => ParseT m a -> ParseT m a
  Discards whitespace after a matching parser

  Visibility: export
token : Monad m => String -> ParseT m ()
  Matches a specific string, then skips following whitespace

  Visibility: export
digit : Monad m => ParseT m (Fin 10)
  Matches a single digit

  Totality: total
  Visibility: export
natural : Monad m => ParseT m Nat
  Matches a natural number

  Visibility: export
integer : Monad m => ParseT m Integer
  Matches an integer, eg. "12", "-4"

  Visibility: export
sepBy1 : Monad m => ParseT m a -> ParseT m b -> ParseT m (List1 a)
  Parse repeated instances of at least one `p`, separated by `s`,
  returning a list of successes.
  
  @ p the parser for items
  @ s the parser for separators

  Visibility: export
sepBy : Monad m => ParseT m a -> ParseT m b -> ParseT m (List a)
  Parse zero or more `p`s, separated by `s`s, returning a list of
  successes.
  
  @ p the parser for items
  @ s the parser for separators

  Visibility: export
commaSep1 : Monad m => ParseT m a -> ParseT m (List1 a)
  Parses /one/ or more occurrences of `p` separated by `comma`.

  Visibility: export
commaSep : Monad m => ParseT m a -> ParseT m (List a)
  Parses /zero/ or more occurrences of `p` separated by `comma`.

  Visibility: export
alternating : Monad m => ParseT m a -> ParseT m b -> ParseT m (Odd a b)
  Parses alternating occurrences of `a`s and `b`s.
  Can be thought of as parsing:
  - a list of `b`s, separated, and surrounded, by `a`s
  - a non-empty list of `a`s, separated by `b`s
  where we care about the separators

  Visibility: export
ntimes : Monad m => (n : Nat) -> ParseT m a -> ParseT m (Vect n a)
  Run the specified parser precisely `n` times, returning a vector
  of successes.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.String.Position.html b/contrib/docs/Data.String.Position.html
index 9e95d24f60..0aa924dd23 100644
--- a/contrib/docs/Data.String.Position.html
+++ b/contrib/docs/Data.String.Position.html
@@ -64,4 +64,4 @@
 
Data.String.Position(source)
A small library introducing string positions
 This can be used as an alternative to unpacking a string into a list of
 characters
-
Definitions
record ValidPosition : String -> Type
  @ValidPosition points to an existing character into
  @str  its parameter string
  Do NOT publicly export so that users cannot manufacture arbitrary positions

  Totality: total
  Visibility: export
  Constructor: 
MkValidPosition : Int -> Int -> ValidPosition str

  Projections:
  
.currentIndex : ValidPosition str -> Int
  @currentIndex is the valid position into str
  
.parameterLength : ValidPosition str -> Int
  @parameterLength is the length of the parameter str
Position : String -> Type
  A position is either a ValidPosition or the end of the string

  Totality: total
  Visibility: public export
mkPosition : (str : String) -> Int -> Position str
  Manufacture a position by checking it is strictly inside the string

  Totality: total
  Visibility: export
mvPosition : ValidPosition str -> Int -> Position str
  Move a position (note that we do not need access to the string here)

  Totality: total
  Visibility: export
init : (str : String) -> Position str
  Find the initial position inside the input string

  Totality: total
  Visibility: export
next : ValidPosition str -> Position str
  Move from a valid position to the next position in the string

  Totality: total
  Visibility: export
index : ValidPosition str -> Char
  We can safely access the character at a valid position

  Totality: total
  Visibility: export
uncons : ValidPosition str -> (Char, Position str)
  We can successfully uncons the substring starting at a `ValidPosition`.
  Note that we can use `map uncons pos` to uncons the substring starting
  a `Position`.

  Totality: total
  Visibility: export
span : (Char -> Bool) -> Position str -> Position str
  @span keeps munching characters of the substring starting at a given
  position as long as the predicate is true of them. It returns the position
  after the last successful munch.
  Using `subString` to recover the string selected by `span` should yield
  the same result as Data.String's `span`. That is to say we should have:
  ```
  subString pos (Position.span p pos) = String.span p (subString pos Nothing)
  ```

  Totality: total
  Visibility: export
count : (Char -> Bool) -> Position str -> Nat
  @count computes the length of the substring one would obtain if one were
  to filter out characters based on the predicate passed as an argument.
  It replaces the `length (filter p (fastUnpack str))` pattern.

  Totality: total
  Visibility: export
distance : Position str -> Position str -> Int
  Distance between a starting position and an end one.
  We assume that the end position is *after* the starting one, otherwise the
  output may be negative.

  Totality: total
  Visibility: export
subString : Position str -> Position str -> String
  the substring of length `distance start end` that is contained between
  start (inclusive) and end (exclusive).

  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
record ValidPosition : String -> Type
  @ValidPosition points to an existing character into
  @str  its parameter string
  Do NOT publicly export so that users cannot manufacture arbitrary positions

  Totality: total
  Visibility: export
  Constructor: 
MkValidPosition : Int -> Int -> ValidPosition str

  Projections:
  
.currentIndex : ValidPosition str -> Int
  @currentIndex is the valid position into str
  
.parameterLength : ValidPosition str -> Int
  @parameterLength is the length of the parameter str
Position : String -> Type
  A position is either a ValidPosition or the end of the string

  Totality: total
  Visibility: public export
mkPosition : (str : String) -> Int -> Position str
  Manufacture a position by checking it is strictly inside the string

  Totality: total
  Visibility: export
mvPosition : ValidPosition str -> Int -> Position str
  Move a position (note that we do not need access to the string here)

  Totality: total
  Visibility: export
init : (str : String) -> Position str
  Find the initial position inside the input string

  Totality: total
  Visibility: export
next : ValidPosition str -> Position str
  Move from a valid position to the next position in the string

  Totality: total
  Visibility: export
index : ValidPosition str -> Char
  We can safely access the character at a valid position

  Totality: total
  Visibility: export
uncons : ValidPosition str -> (Char, Position str)
  We can successfully uncons the substring starting at a `ValidPosition`.
  Note that we can use `map uncons pos` to uncons the substring starting
  a `Position`.

  Totality: total
  Visibility: export
span : (Char -> Bool) -> Position str -> Position str
  @span keeps munching characters of the substring starting at a given
  position as long as the predicate is true of them. It returns the position
  after the last successful munch.
  Using `subString` to recover the string selected by `span` should yield
  the same result as Data.String's `span`. That is to say we should have:
  ```
  subString pos (Position.span p pos) = String.span p (subString pos Nothing)
  ```

  Totality: total
  Visibility: export
count : (Char -> Bool) -> Position str -> Nat
  @count computes the length of the substring one would obtain if one were
  to filter out characters based on the predicate passed as an argument.
  It replaces the `length (filter p (fastUnpack str))` pattern.

  Totality: total
  Visibility: export
distance : Position str -> Position str -> Int
  Distance between a starting position and an end one.
  We assume that the end position is *after* the starting one, otherwise the
  output may be negative.

  Totality: total
  Visibility: export
subString : Position str -> Position str -> String
  the substring of length `distance start end` that is contained between
  start (inclusive) and end (exclusive).

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Telescope.Congruence.html b/contrib/docs/Data.Telescope.Congruence.html
index c68f5d3b0c..5802dc09e1 100644
--- a/contrib/docs/Data.Telescope.Congruence.html
+++ b/contrib/docs/Data.Telescope.Congruence.html
@@ -62,4 +62,4 @@
 
 
 
Data.Telescope.Congruence(source)
N-ary congruence for reasoning
-
Definitions
congType : (delta : Segment n gamma) -> (env1 : Environment gamma) -> (sy1 : SimpleFun env1 delta Type) -> Fun env1 delta sy1 -> (env2 : Environment gamma) -> (sy2 : SimpleFun env2 delta Type) -> Fun env2 delta sy2 -> Type
  Visibility: public export
congSegment : (0 delta : Segment n gamma) -> (0 env1 : Environment gamma) -> (0 sy1 : SimpleFun env1 delta Type) -> (0 lhs : Fun env1 delta sy1) -> (0 env2 : Environment gamma) -> (0 sy2 : SimpleFun env2 delta Type) -> (0 rhs : Fun env2 delta sy2) -> (0 _ : env1 = env2) -> (0 _ : sy1 = sy2) -> (0 _ : lhs = rhs) -> congType delta env1 sy1 lhs env2 sy2 rhs
  Visibility: public export
cong : (context : Fun () delta sy) -> congType delta () sy context () sy context
  Visibility: public export

\ No newline at end of file
+
Definitions
congType : (delta : Segment n gamma) -> (env1 : Environment gamma) -> (sy1 : SimpleFun env1 delta Type) -> Fun env1 delta sy1 -> (env2 : Environment gamma) -> (sy2 : SimpleFun env2 delta Type) -> Fun env2 delta sy2 -> Type
  Visibility: public export
congSegment : (0 delta : Segment n gamma) -> (0 env1 : Environment gamma) -> (0 sy1 : SimpleFun env1 delta Type) -> (0 lhs : Fun env1 delta sy1) -> (0 env2 : Environment gamma) -> (0 sy2 : SimpleFun env2 delta Type) -> (0 rhs : Fun env2 delta sy2) -> (0 _ : env1 = env2) -> (0 _ : sy1 = sy2) -> (0 _ : lhs = rhs) -> congType delta env1 sy1 lhs env2 sy2 rhs
  Visibility: public export
cong : (context : Fun () delta sy) -> congType delta () sy context () sy context
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.Telescope.Fun.html b/contrib/docs/Data.Telescope.Fun.html
index a0ff6ebe3f..6768545cf6 100644
--- a/contrib/docs/Data.Telescope.Fun.html
+++ b/contrib/docs/Data.Telescope.Fun.html
@@ -65,4 +65,4 @@
 
 Compare with `base/Data.Fun` and:
 Guillaume Allais. 2019. Generic level polymorphic n-ary functions. TyDe 2019.
-
Definitions
0 Fun : (env : Environment gamma) -> (0 delta : Segment n gamma) -> SimpleFun env delta Type -> Type
  Visibility: public export
uncurry : Fun env delta cod -> (ext : Environment env delta) -> uncurry cod ext
  Visibility: public export
curry : ((ext : Environment env delta) -> uncurry cod ext) -> Fun env delta cod
  Visibility: public export

\ No newline at end of file
+
Definitions
0 Fun : (env : Environment gamma) -> (0 delta : Segment n gamma) -> SimpleFun env delta Type -> Type
  Visibility: public export
uncurry : Fun env delta cod -> (ext : Environment env delta) -> uncurry cod ext
  Visibility: public export
curry : ((ext : Environment env delta) -> uncurry cod ext) -> Fun env delta cod
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.Telescope.Segment.html b/contrib/docs/Data.Telescope.Segment.html
index 5a789837ef..d41681679e 100644
--- a/contrib/docs/Data.Telescope.Segment.html
+++ b/contrib/docs/Data.Telescope.Segment.html
@@ -70,4 +70,4 @@
 
 As with telescopes, indexing segments by their length (hopefully)
 helps the type-checker infer stuff.
-
Definitions
data Segment : Nat -> Telescope k -> Type
  A segment is a compositional fragment of a telescope, indexed by
  the segment's length.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Segment 0 gamma
  
(::) : (ty : TypeIn gamma) -> Segment n (gamma -. ty) -> Segment (S n) gamma
tabulate : (n : Nat) -> (Environment gamma -> Telescope n) -> Segment n gamma
  A segment of size `n` indexed by `gamma` can be seen as the tabulation of a
  function that turns environments for `gamma` into telescopes of size `n`.

  Totality: total
  Visibility: public export
fromTelescope : Telescope k -> Segment k []
  Any telescope is a segment in the empty telescope. It amounts to looking
  at it left-to-right instead of right-to-left.

  Totality: total
  Visibility: public export
untabulate : Segment n gamma -> Environment gamma -> Telescope n
  Conversely, a segment of size `n` in telescope `gamma` can be seen as a function
  from environments for `gamma` to telescopes of size `n`.

  Totality: total
  Visibility: public export
toTelescope : Segment k [] -> Telescope k
  Any segment in the empty telescope correspond to a telescope.

  Totality: total
  Visibility: public export
keep : (0 _ : a = b) -> a = b
  Totality: total
  Visibility: public export
(|++) : (gamma : Telescope k) -> Segment n gamma -> Telescope (n + k)
  Segments act on telescope from the right.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 3
(++) : (lft : Segment n gamma) -> Segment m (gamma |++ lft) -> Segment (n + m) gamma
  Segments form a kind of an indexed monoid w.r.t. the action `(|++)`

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
actSegmentAssociative : (gamma : Telescope k) -> (lft : Segment n gamma) -> (rgt : Segment m (gamma |++ lft)) -> gamma |++ (lft ++ rgt) = (gamma |++ lft) |++ rgt
  Totality: total
  Visibility: export
weaken : TypeIn gamma -> TypeIn (gamma |++ delta)
  Totality: total
  Visibility: public export
projection : Environment (gamma |++ delta) -> Environment gamma
  Totality: total
  Visibility: public export
data Environment : Environment gamma -> Segment n gamma -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Empty : Environment env []
  
(.=) : (x : ty env) -> Environment (env ** x) delta -> Environment env (ty :: delta)
(:++) : (env : Environment gamma) -> Environment env delta -> Environment (gamma |++ delta)
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 3

\ No newline at end of file
+
Definitions
data Segment : Nat -> Telescope k -> Type
  A segment is a compositional fragment of a telescope, indexed by
  the segment's length.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Segment 0 gamma
  
(::) : (ty : TypeIn gamma) -> Segment n (gamma -. ty) -> Segment (S n) gamma
tabulate : (n : Nat) -> (Environment gamma -> Telescope n) -> Segment n gamma
  A segment of size `n` indexed by `gamma` can be seen as the tabulation of a
  function that turns environments for `gamma` into telescopes of size `n`.

  Totality: total
  Visibility: public export
fromTelescope : Telescope k -> Segment k []
  Any telescope is a segment in the empty telescope. It amounts to looking
  at it left-to-right instead of right-to-left.

  Totality: total
  Visibility: public export
untabulate : Segment n gamma -> Environment gamma -> Telescope n
  Conversely, a segment of size `n` in telescope `gamma` can be seen as a function
  from environments for `gamma` to telescopes of size `n`.

  Totality: total
  Visibility: public export
toTelescope : Segment k [] -> Telescope k
  Any segment in the empty telescope correspond to a telescope.

  Totality: total
  Visibility: public export
keep : (0 _ : a = b) -> a = b
  Totality: total
  Visibility: public export
(|++) : (gamma : Telescope k) -> Segment n gamma -> Telescope (n + k)
  Segments act on telescope from the right.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 3
(++) : (lft : Segment n gamma) -> Segment m (gamma |++ lft) -> Segment (n + m) gamma
  Segments form a kind of an indexed monoid w.r.t. the action `(|++)`

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
actSegmentAssociative : (gamma : Telescope k) -> (lft : Segment n gamma) -> (rgt : Segment m (gamma |++ lft)) -> gamma |++ (lft ++ rgt) = (gamma |++ lft) |++ rgt
  Totality: total
  Visibility: export
weaken : TypeIn gamma -> TypeIn (gamma |++ delta)
  Totality: total
  Visibility: public export
projection : Environment (gamma |++ delta) -> Environment gamma
  Totality: total
  Visibility: public export
data Environment : Environment gamma -> Segment n gamma -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Empty : Environment env []
  
(.=) : (x : ty env) -> Environment (env ** x) delta -> Environment env (ty :: delta)
(:++) : (env : Environment gamma) -> Environment env delta -> Environment (gamma |++ delta)
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 3

\ No newline at end of file
diff --git a/contrib/docs/Data.Telescope.SimpleFun.html b/contrib/docs/Data.Telescope.SimpleFun.html
index 8555724dcf..53d97de953 100644
--- a/contrib/docs/Data.Telescope.SimpleFun.html
+++ b/contrib/docs/Data.Telescope.SimpleFun.html
@@ -65,4 +65,4 @@
 
 Compare with `base/Data.Fun` and `contrib/Data.Fun.Extra` and with:
 Guillaume Allais. 2019. Generic level polymorphic n-ary functions. TyDe 2019.
-
Definitions
0 SimpleFun : Environment gamma -> (0 _ : Segment n gamma) -> Type -> Type
  An n-ary function whose codomain does not depend on its
  arguments. The arguments may have dependencies.

  Visibility: public export
target : SimpleFun env delta cod -> Type
  Visibility: public export
uncurry : SimpleFun env delta cod -> Environment env delta -> cod
  Visibility: public export
curry : (Environment env delta -> cod) -> SimpleFun env delta cod
  Visibility: public export

\ No newline at end of file
+
Definitions
0 SimpleFun : Environment gamma -> (0 _ : Segment n gamma) -> Type -> Type
  An n-ary function whose codomain does not depend on its
  arguments. The arguments may have dependencies.

  Visibility: public export
target : SimpleFun env delta cod -> Type
  Visibility: public export
uncurry : SimpleFun env delta cod -> Environment env delta -> cod
  Visibility: public export
curry : (Environment env delta -> cod) -> SimpleFun env delta cod
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.Telescope.Telescope.html b/contrib/docs/Data.Telescope.Telescope.html
index d2d54a4b7b..8c630673ab 100644
--- a/contrib/docs/Data.Telescope.Telescope.html
+++ b/contrib/docs/Data.Telescope.Telescope.html
@@ -65,4 +65,4 @@
 
 Indexing telescopes by their length (hopefully) helps inform the
 type-checker during inference.
-
Definitions
plusAcc : Nat -> Nat -> Nat
  Totality: total
  Visibility: public export
plusAccIsPlus : (m : Nat) -> (n : Nat) -> m + n = plusAcc m n
  Totality: total
  Visibility: export
plusAccZeroRightNeutral : (m : Nat) -> plusAcc m 0 = m
  Totality: total
  Visibility: public export
data Telescope : Nat -> Type
  A left-nested sequence of dependent types

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Telescope 0
  
(-.) : (gamma : Telescope k) -> TypeIn gamma -> Telescope (S k)
TypeIn : Telescope k -> Type
  A type with dependencies in the given context

  Totality: total
  Visibility: public export
Environment : Telescope k -> Type
  A tuple of values of each type in the telescope

  Totality: total
  Visibility: public export
weakenTypeIn : TypeIn gamma -> TypeIn (gamma -. sigma)
  Totality: total
  Visibility: export
uncons : (gamma : Telescope (S k)) -> (ty : Type ** (delta : ty -> Telescope k ** (v : ty) -> Environment (delta v) -> Environment gamma))
  Totality: total
  Visibility: public export
(++) : (gamma : Telescope m) -> (Environment gamma -> Telescope n) -> Telescope (plusAcc n m)
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
cons : (ty : Type) -> (ty -> Telescope k) -> Telescope (S k)
  Totality: total
  Visibility: public export
  Fixity Declarations:
  infixr operator, level 5
infixr operator, level 5
Position : Telescope k -> Type
  A position between the variables of a telescope, counting from the _end_:
  Telescope:   Nil -. ty1 -. ... -. tyn
  Positions: ^k    ^k-1   ^k-2   ^1     ^0

  Totality: total
  Visibility: public export
start : (gamma : Telescope k) -> Position gamma
  The position at the beginning of the telescope

  Totality: total
  Visibility: public export
data Telescope : Nat -> Type
  A right-nested sequence of dependent types

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Telescope 0
  
(.-) : (ty : Type) -> (ty -> Telescope k) -> Telescope (S k)
Environment : Telescope k -> Type
  A tuple of values of each type in the telescope

  Totality: total
  Visibility: public export
empty : (0 gamma : Telescope 0) -> Environment gamma
  Totality: total
  Visibility: export
snoc : (gamma : Telescope k) -> (Environment gamma -> Type) -> Telescope (S k)
  Totality: total
  Visibility: export
  Fixity Declarations:
  infixl operator, level 5
infixl operator, level 5
unsnoc : (gamma : Telescope (S k)) -> (delta : Telescope k ** (sigma : Environment delta -> Type ** (env : Environment delta) -> sigma env -> Environment gamma))
  Totality: total
  Visibility: export
(++) : (gamma : Telescope m) -> (Environment gamma -> Telescope n) -> Telescope (m + n)
  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 7
split : (gamma : Telescope m) -> (delta : (Environment gamma -> Telescope n)) -> Environment (gamma ++ delta) -> (env : Environment gamma ** Environment (delta env))
  Totality: total
  Visibility: export
data Telescope : Nat -> Type
  A tree of dependent types

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Telescope 0
  
Elt : Type -> Telescope 1
  
(><) : (gamma : Telescope m) -> (Environment gamma -> Telescope n) -> Telescope (m + n)
Environment : Telescope k -> Type
  A tuple of values of each type in the telescope

  Totality: total
  Visibility: public export
concat : (gamma : Telescope k) -> (delta : Telescope k ** Environment delta -> Environment gamma)
  Totality: total
  Visibility: export
(<++>) : (gamma : Telescope m) -> (Environment gamma -> Telescope n) -> Telescope (plusAcc m n)
  Totality: total
  Visibility: public export
  Fixity Declarations:
  infix operator, level 5
infixr operator, level 5
leftToRight : Telescope m -> Telescope m
  Totality: total
  Visibility: export
rightToLeft : Telescope m -> Telescope m
  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
plusAcc : Nat -> Nat -> Nat
  Totality: total
  Visibility: public export
plusAccIsPlus : (m : Nat) -> (n : Nat) -> m + n = plusAcc m n
  Totality: total
  Visibility: export
plusAccZeroRightNeutral : (m : Nat) -> plusAcc m 0 = m
  Totality: total
  Visibility: public export
data Telescope : Nat -> Type
  A left-nested sequence of dependent types

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Telescope 0
  
(-.) : (gamma : Telescope k) -> TypeIn gamma -> Telescope (S k)
TypeIn : Telescope k -> Type
  A type with dependencies in the given context

  Totality: total
  Visibility: public export
Environment : Telescope k -> Type
  A tuple of values of each type in the telescope

  Totality: total
  Visibility: public export
weakenTypeIn : TypeIn gamma -> TypeIn (gamma -. sigma)
  Totality: total
  Visibility: export
uncons : (gamma : Telescope (S k)) -> (ty : Type ** (delta : ty -> Telescope k ** (v : ty) -> Environment (delta v) -> Environment gamma))
  Totality: total
  Visibility: public export
(++) : (gamma : Telescope m) -> (Environment gamma -> Telescope n) -> Telescope (plusAcc n m)
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
cons : (ty : Type) -> (ty -> Telescope k) -> Telescope (S k)
  Totality: total
  Visibility: public export
  Fixity Declarations:
  infixr operator, level 5
infixr operator, level 5
Position : Telescope k -> Type
  A position between the variables of a telescope, counting from the _end_:
  Telescope:   Nil -. ty1 -. ... -. tyn
  Positions: ^k    ^k-1   ^k-2   ^1     ^0

  Totality: total
  Visibility: public export
start : (gamma : Telescope k) -> Position gamma
  The position at the beginning of the telescope

  Totality: total
  Visibility: public export
data Telescope : Nat -> Type
  A right-nested sequence of dependent types

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Telescope 0
  
(.-) : (ty : Type) -> (ty -> Telescope k) -> Telescope (S k)
Environment : Telescope k -> Type
  A tuple of values of each type in the telescope

  Totality: total
  Visibility: public export
empty : (0 gamma : Telescope 0) -> Environment gamma
  Totality: total
  Visibility: export
snoc : (gamma : Telescope k) -> (Environment gamma -> Type) -> Telescope (S k)
  Totality: total
  Visibility: export
  Fixity Declarations:
  infixl operator, level 5
infixl operator, level 5
unsnoc : (gamma : Telescope (S k)) -> (delta : Telescope k ** (sigma : Environment delta -> Type ** (env : Environment delta) -> sigma env -> Environment gamma))
  Totality: total
  Visibility: export
(++) : (gamma : Telescope m) -> (Environment gamma -> Telescope n) -> Telescope (m + n)
  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 7
split : (gamma : Telescope m) -> (delta : (Environment gamma -> Telescope n)) -> Environment (gamma ++ delta) -> (env : Environment gamma ** Environment (delta env))
  Totality: total
  Visibility: export
data Telescope : Nat -> Type
  A tree of dependent types

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Telescope 0
  
Elt : Type -> Telescope 1
  
(><) : (gamma : Telescope m) -> (Environment gamma -> Telescope n) -> Telescope (m + n)
Environment : Telescope k -> Type
  A tuple of values of each type in the telescope

  Totality: total
  Visibility: public export
concat : (gamma : Telescope k) -> (delta : Telescope k ** Environment delta -> Environment gamma)
  Totality: total
  Visibility: export
(<++>) : (gamma : Telescope m) -> (Environment gamma -> Telescope n) -> Telescope (plusAcc m n)
  Totality: total
  Visibility: public export
  Fixity Declarations:
  infix operator, level 5
infixr operator, level 5
leftToRight : Telescope m -> Telescope m
  Totality: total
  Visibility: export
rightToLeft : Telescope m -> Telescope m
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Telescope.html b/contrib/docs/Data.Telescope.html
index 5355ab69fc..1c1adc0a4e 100644
--- a/contrib/docs/Data.Telescope.html
+++ b/contrib/docs/Data.Telescope.html
@@ -75,4 +75,4 @@
 Unifiers as Equivalences: Proof-Relevant Unification of Dependently Typed Data.
 Jesper Cockx, Dominique Devriese, Frank Piessens, ICFP'16.
 but they don't seem to have segments and their left action on contexts.
-
Reexports
import public Data.Telescope.Telescope
import public Data.Telescope.Segment
import public Data.Telescope.SimpleFun
import public Data.Telescope.Fun
import public Data.Telescope.Congruence
\ No newline at end of file
+
Reexports
import public Data.Telescope.Telescope
import public Data.Telescope.Segment
import public Data.Telescope.SimpleFun
import public Data.Telescope.Fun
import public Data.Telescope.Congruence
\ No newline at end of file
diff --git a/contrib/docs/Data.Validated.html b/contrib/docs/Data.Validated.html
index 4cc2bd8d0a..de5a1c61a1 100644
--- a/contrib/docs/Data.Validated.html
+++ b/contrib/docs/Data.Validated.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Validated(source)
Definitions
data Validated : Type -> Type -> Type
  `Validated` is like an `Either` but accumulates all errors with semigroup operation.

  Totality: total
  Visibility: public export
  Constructors:
  
Valid : a -> Validated e a
  
Invalid : e -> Validated e a

  Hints:
  
Monoid e => Alternative (Validated e)
  
Semigroup e => Applicative (Validated e)
  
Bifoldable Validated
  
Bifunctor Validated
  
Bitraversable Validated
  
(DecEq e, DecEq a) => DecEq (Validated e a)
  
(Eq e, Eq a) => Eq (Validated e a)
  
Foldable (Validated e)
  
Functor (Validated e)
  
Injective Valid
  
Injective Invalid
  
Monoid e => Monoid (Validated e a)
  
Semigroup e => Semigroup (Validated e a)
  
(Show e, Show a) => Show (Validated e a)
  
Traversable (Validated e)
  
Uninhabited (Valid x = Invalid e)
  
Uninhabited (Invalid e = Valid x)
  
Semigroup e => Zippable (Validated e)
ValidatedL : Type -> Type -> Type
  Special case of `Validated` with a `List` as an error accumulator.

  Totality: total
  Visibility: public export
oneInvalid : Applicative f => e -> Validated (f e) a
  Totality: total
  Visibility: public export
fromEither : Either e a -> Validated e a
  Totality: total
  Visibility: public export
fromEitherL : Either e a -> ValidatedL e a
  Totality: total
  Visibility: public export
toEither : Validated e a -> Either e a
  Totality: total
  Visibility: public export
fromMaybe : Monoid e => Maybe a -> Validated e a
  Totality: total
  Visibility: public export
toMaybe : Validated e a -> Maybe a
  Totality: total
  Visibility: public export
data IsValid : Validated e a -> Type
  Totality: total
  Visibility: public export
  Constructor: 
ItIsValid : IsValid (Valid x)

  Hint: 
Uninhabited (IsValid (Invalid e))
isItValid : (v : Validated e a) -> Dec (IsValid v)
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Validated(source)
Definitions
data Validated : Type -> Type -> Type
  `Validated` is like an `Either` but accumulates all errors with semigroup operation.

  Totality: total
  Visibility: public export
  Constructors:
  
Valid : a -> Validated e a
  
Invalid : e -> Validated e a

  Hints:
  
Monoid e => Alternative (Validated e)
  
Semigroup e => Applicative (Validated e)
  
Bifoldable Validated
  
Bifunctor Validated
  
Bitraversable Validated
  
(DecEq e, DecEq a) => DecEq (Validated e a)
  
(Eq e, Eq a) => Eq (Validated e a)
  
Foldable (Validated e)
  
Functor (Validated e)
  
Injective Valid
  
Injective Invalid
  
Monoid e => Monoid (Validated e a)
  
Semigroup e => Semigroup (Validated e a)
  
(Show e, Show a) => Show (Validated e a)
  
Traversable (Validated e)
  
Uninhabited (Valid x = Invalid e)
  
Uninhabited (Invalid e = Valid x)
  
Semigroup e => Zippable (Validated e)
ValidatedL : Type -> Type -> Type
  Special case of `Validated` with a `List` as an error accumulator.

  Totality: total
  Visibility: public export
oneInvalid : Applicative f => e -> Validated (f e) a
  Totality: total
  Visibility: public export
fromEither : Either e a -> Validated e a
  Totality: total
  Visibility: public export
fromEitherL : Either e a -> ValidatedL e a
  Totality: total
  Visibility: public export
toEither : Validated e a -> Either e a
  Totality: total
  Visibility: public export
fromMaybe : Monoid e => Maybe a -> Validated e a
  Totality: total
  Visibility: public export
toMaybe : Validated e a -> Maybe a
  Totality: total
  Visibility: public export
data IsValid : Validated e a -> Type
  Totality: total
  Visibility: public export
  Constructor: 
ItIsValid : IsValid (Valid x)

  Hint: 
Uninhabited (IsValid (Invalid e))
isItValid : (v : Validated e a) -> Dec (IsValid v)
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.Vect.Extra.html b/contrib/docs/Data.Vect.Extra.html
index 13eefc2ce5..a7ba15b9bd 100644
--- a/contrib/docs/Data.Vect.Extra.html
+++ b/contrib/docs/Data.Vect.Extra.html
@@ -62,4 +62,4 @@
 
 
 
Data.Vect.Extra(source)
Additional functions about vectors
-
Definitions
mapWithPos : (Fin n -> a -> b) -> Vect n a -> Vect n b
  Version of `map` with access to the current position

  Visibility: public export
mapWithElem : (xs : Vect n a) -> ((x : a) -> (0 _ : Elem x xs) -> b) -> Vect n b
  Version of `map` with runtime-irrelevant information that the
  argument is an element of the vector

  Visibility: public export

\ No newline at end of file
+
Definitions
mapWithPos : (Fin n -> a -> b) -> Vect n a -> Vect n b
  Version of `map` with access to the current position

  Visibility: public export
mapWithElem : (xs : Vect n a) -> ((x : a) -> (0 _ : Elem x xs) -> b) -> Vect n b
  Version of `map` with runtime-irrelevant information that the
  argument is an element of the vector

  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.Vect.Properties.Fin.html b/contrib/docs/Data.Vect.Properties.Fin.html
index 08e6074801..2930d07d09 100644
--- a/contrib/docs/Data.Vect.Properties.Fin.html
+++ b/contrib/docs/Data.Vect.Properties.Fin.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Vect.Properties.Fin(source)
Definitions
data NonEmpty : Vect n a -> Type
  Witnesses non-empty runtime-irrelevant vectors. Analogous to Data.List.NonEmpty

  Totality: total
  Visibility: public export
  Constructor: 
IsNonEmpty : NonEmpty (x :: xs)
etaCons : (xs : Vect (S n) a) -> head xs :: tail xs = xs
  eta-law (extensionality) of head-tail cons

  Visibility: export
finNonZero : Fin n -> NonZero n
  Inhabitants of `Fin n` witness `NonZero n`

  Visibility: export
finNonEmpty : (0 xs : Vect n a) -> NonZero n -> NonEmpty xs
  Inhabitants of `Fin n` witness runtime-irrelevant vectors of length `n` aren't empty

  Visibility: export
finToElem : (0 xs : Vect n a) -> (i : Fin n) -> Elem (index i xs) xs
  Cast an index into a runtime-irrelevant `Vect` into the position
  of the corresponding element

  Visibility: public export
indexNaturalityWithElem : (i : Fin n) -> (xs : Vect n a) -> (f : ((x : a) -> (0 _ : Elem x xs) -> b)) -> index i (mapWithElem xs f) = f (index i xs) (finToElem xs i)
  Analogus to `indexNaturality`, but morhisms can (irrelevantly) know the context

  Visibility: export

\ No newline at end of file
+
Data.Vect.Properties.Fin(source)
Definitions
data NonEmpty : Vect n a -> Type
  Witnesses non-empty runtime-irrelevant vectors. Analogous to Data.List.NonEmpty

  Totality: total
  Visibility: public export
  Constructor: 
IsNonEmpty : NonEmpty (x :: xs)
etaCons : (xs : Vect (S n) a) -> head xs :: tail xs = xs
  eta-law (extensionality) of head-tail cons

  Visibility: export
finNonZero : Fin n -> NonZero n
  Inhabitants of `Fin n` witness `NonZero n`

  Visibility: export
finNonEmpty : (0 xs : Vect n a) -> NonZero n -> NonEmpty xs
  Inhabitants of `Fin n` witness runtime-irrelevant vectors of length `n` aren't empty

  Visibility: export
finToElem : (0 xs : Vect n a) -> (i : Fin n) -> Elem (index i xs) xs
  Cast an index into a runtime-irrelevant `Vect` into the position
  of the corresponding element

  Visibility: public export
indexNaturalityWithElem : (i : Fin n) -> (xs : Vect n a) -> (f : ((x : a) -> (0 _ : Elem x xs) -> b)) -> index i (mapWithElem xs f) = f (index i xs) (finToElem xs i)
  Analogus to `indexNaturality`, but morhisms can (irrelevantly) know the context

  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Vect.Properties.Foldr.html b/contrib/docs/Data.Vect.Properties.Foldr.html
index 15091781cd..165384284b 100644
--- a/contrib/docs/Data.Vect.Properties.Foldr.html
+++ b/contrib/docs/Data.Vect.Properties.Foldr.html
@@ -72,4 +72,4 @@
 
 Since the prelude defines foldr tail-recursively, this fact isn't immediate
 and we need some lemmata to prove it.
-
Definitions
sumR : Num a => Foldable f => f a -> a
  Sum implemented with foldr

  Visibility: public export
record VectHomomorphismProperty : {0 A : Type} -> {0 B : Type} -> (A -> B -> B) -> B -> (Vect n A -> B) -> Type
  A function H : forall n. Vect n A -> B preserving the structure of vectors over A

  Totality: total
  Visibility: public export
  Constructor: 
ShowVectHomomorphismProperty : {0 A : Type} -> {0 B : Type} -> {0 F : A -> B -> B} -> {0 E : B} -> {0 H : Vect n A -> B} -> H [] = E -> ((x : A) -> (xs : Vect n A) -> H (x :: xs) = F x (H xs)) -> VectHomomorphismProperty F E (\0 {n:4651} => H)

  Projections:
  
.cons : {0 A : Type} -> {0 B : Type} -> {0 F : A -> B -> B} -> {0 E : B} -> {0 H : Vect n A -> B} -> VectHomomorphismProperty F E (\0 {n:4819} => H) -> (x : A) -> (xs : Vect n A) -> H (x :: xs) = F x (H xs)
  
.nil : {0 A : Type} -> {0 B : Type} -> {0 F : A -> B -> B} -> {0 E : B} -> {0 H : Vect n A -> B} -> VectHomomorphismProperty F E (\0 {n:4693} => H) -> H [] = E
.nil : {0 A : Type} -> {0 B : Type} -> {0 F : A -> B -> B} -> {0 E : B} -> {0 H : Vect n A -> B} -> VectHomomorphismProperty F E (\0 {n:4693} => H) -> H [] = E
  Visibility: public export
nil : {0 A : Type} -> {0 B : Type} -> {0 F : A -> B -> B} -> {0 E : B} -> {0 H : Vect n A -> B} -> VectHomomorphismProperty F E (\0 {n:4757} => H) -> H [] = E
  Visibility: public export
.cons : {0 A : Type} -> {0 B : Type} -> {0 F : A -> B -> B} -> {0 E : B} -> {0 H : Vect n A -> B} -> VectHomomorphismProperty F E (\0 {n:4819} => H) -> (x : A) -> (xs : Vect n A) -> H (x :: xs) = F x (H xs)
  Visibility: public export
  Fixity Declarations:
  infixr operator, level 5
infixr operator, level 5
cons : {0 A : Type} -> {0 B : Type} -> {0 F : A -> B -> B} -> {0 E : B} -> {0 H : Vect n A -> B} -> VectHomomorphismProperty F E (\0 {n:4898} => H) -> (x : A) -> (xs : Vect n A) -> H (x :: xs) = F x (H xs)
  Visibility: public export
  Fixity Declarations:
  infixr operator, level 5
infixr operator, level 5
nilConsInitiality : (f : (a -> b -> b)) -> (e : b) -> (h1 : (Vect n a -> b)) -> (h2 : (Vect n a -> b)) -> VectHomomorphismProperty f e (\0 {n:4978} => h1) -> VectHomomorphismProperty f e (\0 {n:4990} => h2) -> (xs : Vect n a) -> h1 xs = h2 xs
  There is an extensionally unique function preserving the vector structure

  Visibility: export
foldrVectHomomorphism : VectHomomorphismProperty f e (\0 {n:5386} => foldr f e)
  Our tail-recursive foldr preserves the vector structure

  Visibility: export
foldrUniqueness : (h : (Vect n a -> b)) -> VectHomomorphismProperty f e (\0 {n:5586} => h) -> (xs : Vect n a) -> h xs = foldr f e xs
  foldr is the unique function preserving the vector structure

  Visibility: export
sumIsGTEtoParts : (xs : Vect n Nat) -> Elem x xs -> GTE (sumR xs) x
  Each summand is `LTE` the sum

  Visibility: export
sumMonotone : (xs : Vect n Nat) -> (ys : Vect n Nat) -> ((i : Fin n) -> LTE (index i xs) (index i ys)) -> LTE (sumR xs) (sumR ys)
  `sumR : Vect n Nat -> Nat` is monotone

  Visibility: export

\ No newline at end of file
+
Definitions
sumR : Num a => Foldable f => f a -> a
  Sum implemented with foldr

  Visibility: public export
record VectHomomorphismProperty : {0 A : Type} -> {0 B : Type} -> (A -> B -> B) -> B -> (Vect n A -> B) -> Type
  A function H : forall n. Vect n A -> B preserving the structure of vectors over A

  Totality: total
  Visibility: public export
  Constructor: 
ShowVectHomomorphismProperty : {0 A : Type} -> {0 B : Type} -> {0 F : A -> B -> B} -> {0 E : B} -> {0 H : Vect n A -> B} -> H [] = E -> ((x : A) -> (xs : Vect n A) -> H (x :: xs) = F x (H xs)) -> VectHomomorphismProperty F E (\0 {n:4651} => H)

  Projections:
  
.cons : {0 A : Type} -> {0 B : Type} -> {0 F : A -> B -> B} -> {0 E : B} -> {0 H : Vect n A -> B} -> VectHomomorphismProperty F E (\0 {n:4819} => H) -> (x : A) -> (xs : Vect n A) -> H (x :: xs) = F x (H xs)
  
.nil : {0 A : Type} -> {0 B : Type} -> {0 F : A -> B -> B} -> {0 E : B} -> {0 H : Vect n A -> B} -> VectHomomorphismProperty F E (\0 {n:4693} => H) -> H [] = E
.nil : {0 A : Type} -> {0 B : Type} -> {0 F : A -> B -> B} -> {0 E : B} -> {0 H : Vect n A -> B} -> VectHomomorphismProperty F E (\0 {n:4693} => H) -> H [] = E
  Visibility: public export
nil : {0 A : Type} -> {0 B : Type} -> {0 F : A -> B -> B} -> {0 E : B} -> {0 H : Vect n A -> B} -> VectHomomorphismProperty F E (\0 {n:4757} => H) -> H [] = E
  Visibility: public export
.cons : {0 A : Type} -> {0 B : Type} -> {0 F : A -> B -> B} -> {0 E : B} -> {0 H : Vect n A -> B} -> VectHomomorphismProperty F E (\0 {n:4819} => H) -> (x : A) -> (xs : Vect n A) -> H (x :: xs) = F x (H xs)
  Visibility: public export
  Fixity Declarations:
  infixr operator, level 5
infixr operator, level 5
cons : {0 A : Type} -> {0 B : Type} -> {0 F : A -> B -> B} -> {0 E : B} -> {0 H : Vect n A -> B} -> VectHomomorphismProperty F E (\0 {n:4898} => H) -> (x : A) -> (xs : Vect n A) -> H (x :: xs) = F x (H xs)
  Visibility: public export
  Fixity Declarations:
  infixr operator, level 5
infixr operator, level 5
nilConsInitiality : (f : (a -> b -> b)) -> (e : b) -> (h1 : (Vect n a -> b)) -> (h2 : (Vect n a -> b)) -> VectHomomorphismProperty f e (\0 {n:4978} => h1) -> VectHomomorphismProperty f e (\0 {n:4990} => h2) -> (xs : Vect n a) -> h1 xs = h2 xs
  There is an extensionally unique function preserving the vector structure

  Visibility: export
foldrVectHomomorphism : VectHomomorphismProperty f e (\0 {n:5386} => foldr f e)
  Our tail-recursive foldr preserves the vector structure

  Visibility: export
foldrUniqueness : (h : (Vect n a -> b)) -> VectHomomorphismProperty f e (\0 {n:5586} => h) -> (xs : Vect n a) -> h xs = foldr f e xs
  foldr is the unique function preserving the vector structure

  Visibility: export
sumIsGTEtoParts : (xs : Vect n Nat) -> Elem x xs -> GTE (sumR xs) x
  Each summand is `LTE` the sum

  Visibility: export
sumMonotone : (xs : Vect n Nat) -> (ys : Vect n Nat) -> ((i : Fin n) -> LTE (index i xs) (index i ys)) -> LTE (sumR xs) (sumR ys)
  `sumR : Vect n Nat -> Nat` is monotone

  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Vect.Properties.Index.html b/contrib/docs/Data.Vect.Properties.Index.html
index 81177e9f93..ba44efc221 100644
--- a/contrib/docs/Data.Vect.Properties.Index.html
+++ b/contrib/docs/Data.Vect.Properties.Index.html
@@ -62,4 +62,4 @@
 
 
 
Data.Vect.Properties.Index(source)
Properties of Data.Vect.index
-
Definitions
recallElem : Elem x xs -> a
  Recall an element by its position, as we may not have the element
  at runtime

  Visibility: public export
recallElemSpec : (pos : Elem x xs) -> recallElem pos = x
  Recalling by a position of `x` does yield `x`

  Visibility: export
indexNaturality : (i : Fin n) -> (f : (a -> b)) -> (xs : Vect n a) -> index i (map f xs) = f (index i xs)
  `index i : Vect n a -> a` is a natural transformation

  Visibility: export
indexReplicate : (i : Fin n) -> (x : a) -> index i (replicate n x) = x
  Replication tabulates the constant function

  Visibility: export
indexRange : (i : Fin n) -> index i range = i
  `range` tabulates the identity function (by definition)

  Visibility: export
indexTranspose : (xss : Vect m (Vect n a)) -> (i : Fin n) -> index i (transpose xss) = map (index i) xss
  The `i`-th vector in a transposed matrix is the vector of `i`-th components

  Visibility: export

\ No newline at end of file
+
Definitions
recallElem : Elem x xs -> a
  Recall an element by its position, as we may not have the element
  at runtime

  Visibility: public export
recallElemSpec : (pos : Elem x xs) -> recallElem pos = x
  Recalling by a position of `x` does yield `x`

  Visibility: export
indexNaturality : (i : Fin n) -> (f : (a -> b)) -> (xs : Vect n a) -> index i (map f xs) = f (index i xs)
  `index i : Vect n a -> a` is a natural transformation

  Visibility: export
indexReplicate : (i : Fin n) -> (x : a) -> index i (replicate n x) = x
  Replication tabulates the constant function

  Visibility: export
indexRange : (i : Fin n) -> index i range = i
  `range` tabulates the identity function (by definition)

  Visibility: export
indexTranspose : (xss : Vect m (Vect n a)) -> (i : Fin n) -> index i (transpose xss) = map (index i) xss
  The `i`-th vector in a transposed matrix is the vector of `i`-th components

  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Vect.Properties.Map.html b/contrib/docs/Data.Vect.Properties.Map.html
index 502a71547e..b5b01acd6e 100644
--- a/contrib/docs/Data.Vect.Properties.Map.html
+++ b/contrib/docs/Data.Vect.Properties.Map.html
@@ -62,4 +62,4 @@
 
 
 
Data.Vect.Properties.Map(source)
Properties of Data.Vect.map
-
Definitions
mapId : (xs : Vect n a) -> map id xs = xs
  `map` functoriality: identity preservation

  Visibility: export
indexMapWithPos : (f : (Fin n -> a -> b)) -> (xs : Vect n a) -> (i : Fin n) -> index i (mapWithPos f xs) = f i (index i xs)
  `mapWtihPos f` represents post-composition the tabulated function `f`

  Visibility: export
mapTabulate : (f : (a -> b)) -> (g : (Fin n -> a)) -> tabulate (f . g) = map f (tabulate g)
  `tabulate : (Fin n ->) -> Vect n` is a natural transformation

  Visibility: export
tabulateConstantly : (x : a) -> tabulate (const x) = replicate len x
  Tabulating with the constant function is replication

  Visibility: export
mapRestrictedExtensional : (f : (a -> b)) -> (g : (a -> b)) -> (xs : Vect n a) -> ((i : Fin n) -> f (index i xs) = g (index i xs)) -> map f xs = map g xs
  It's enough that two functions agree on the elements of a vector for the maps to agree

  Visibility: export
mapExtensional : (f : (a -> b)) -> (g : (a -> b)) -> ((x : a) -> f x = g x) -> (xs : Vect n a) -> map f xs = map g xs
  function extensionality is a congruence wrt map

  Visibility: export
mapFusion : (f : (b -> c)) -> (g : (a -> b)) -> (xs : Vect n a) -> map f (map g xs) = map (f . g) xs
  map-fusion property for vectors up to function extensionality

  Visibility: export
mapWithElemExtensional : (xs : Vect n a) -> (f : ((x : a) -> (0 _ : Elem x xs) -> b)) -> (g : ((x : a) -> (0 _ : Elem x xs) -> b)) -> ((x : a) -> (0 pos : Elem x xs) -> f x pos = g x pos) -> mapWithElem xs f = mapWithElem xs g
  function extensionality is a congruence wrt mapWithElem

  Visibility: export

\ No newline at end of file
+
Definitions
mapId : (xs : Vect n a) -> map id xs = xs
  `map` functoriality: identity preservation

  Visibility: export
indexMapWithPos : (f : (Fin n -> a -> b)) -> (xs : Vect n a) -> (i : Fin n) -> index i (mapWithPos f xs) = f i (index i xs)
  `mapWtihPos f` represents post-composition the tabulated function `f`

  Visibility: export
mapTabulate : (f : (a -> b)) -> (g : (Fin n -> a)) -> tabulate (f . g) = map f (tabulate g)
  `tabulate : (Fin n ->) -> Vect n` is a natural transformation

  Visibility: export
tabulateConstantly : (x : a) -> tabulate (const x) = replicate len x
  Tabulating with the constant function is replication

  Visibility: export
mapRestrictedExtensional : (f : (a -> b)) -> (g : (a -> b)) -> (xs : Vect n a) -> ((i : Fin n) -> f (index i xs) = g (index i xs)) -> map f xs = map g xs
  It's enough that two functions agree on the elements of a vector for the maps to agree

  Visibility: export
mapExtensional : (f : (a -> b)) -> (g : (a -> b)) -> ((x : a) -> f x = g x) -> (xs : Vect n a) -> map f xs = map g xs
  function extensionality is a congruence wrt map

  Visibility: export
mapFusion : (f : (b -> c)) -> (g : (a -> b)) -> (xs : Vect n a) -> map f (map g xs) = map (f . g) xs
  map-fusion property for vectors up to function extensionality

  Visibility: export
mapWithElemExtensional : (xs : Vect n a) -> (f : ((x : a) -> (0 _ : Elem x xs) -> b)) -> (g : ((x : a) -> (0 _ : Elem x xs) -> b)) -> ((x : a) -> (0 pos : Elem x xs) -> f x pos = g x pos) -> mapWithElem xs f = mapWithElem xs g
  function extensionality is a congruence wrt mapWithElem

  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Vect.Properties.Tabulate.html b/contrib/docs/Data.Vect.Properties.Tabulate.html
index 984ae137bc..7a8d6b82ab 100644
--- a/contrib/docs/Data.Vect.Properties.Tabulate.html
+++ b/contrib/docs/Data.Vect.Properties.Tabulate.html
@@ -63,4 +63,4 @@
 
 
Data.Vect.Properties.Tabulate(source)
Tabulation gives a bijection between functions `f : Fin n -> a`
 (up to extensional equality) and vectors `tabulate f : Vect n a`.
-
Definitions
vectorExtensionality : (xs : Vect n a) -> (ys : Vect n a) -> ((i : Fin n) -> index i xs = index i ys) -> xs = ys
  Vectors are uniquely determined by their elements

  Visibility: export
tabulateExtensional : (f : (Fin n -> a)) -> (g : (Fin n -> a)) -> ((i : Fin n) -> f i = g i) -> tabulate f = tabulate g
  Extensionally equivalent functions tabulate to the same vector

  Visibility: export
indexTabulate : (f : (Fin n -> a)) -> (i : Fin n) -> index i (tabulate f) = f i
  Taking an index amounts to applying the tabulated function

  Visibility: export
emptyInitial : (v : Vect 0 a) -> v = []
  The empty vector represents the unique function `Fin 0 -> a`

  Visibility: export

\ No newline at end of file
+
Definitions
vectorExtensionality : (xs : Vect n a) -> (ys : Vect n a) -> ((i : Fin n) -> index i xs = index i ys) -> xs = ys
  Vectors are uniquely determined by their elements

  Visibility: export
tabulateExtensional : (f : (Fin n -> a)) -> (g : (Fin n -> a)) -> ((i : Fin n) -> f i = g i) -> tabulate f = tabulate g
  Extensionally equivalent functions tabulate to the same vector

  Visibility: export
indexTabulate : (f : (Fin n -> a)) -> (i : Fin n) -> index i (tabulate f) = f i
  Taking an index amounts to applying the tabulated function

  Visibility: export
emptyInitial : (v : Vect 0 a) -> v = []
  The empty vector represents the unique function `Fin 0 -> a`

  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Vect.Properties.html b/contrib/docs/Data.Vect.Properties.html
index f16bf283c6..dc661b5dc7 100644
--- a/contrib/docs/Data.Vect.Properties.html
+++ b/contrib/docs/Data.Vect.Properties.html
@@ -62,4 +62,4 @@
 
 
 
Data.Vect.Properties(source)
Additional properties and lemmata to do with Vect
-
Reexports
import public Data.Vect.Properties.Tabulate
import public Data.Vect.Properties.Index
import public Data.Vect.Properties.Foldr
import public Data.Vect.Properties.Map
import public Data.Vect.Properties.Fin

\ No newline at end of file
+
Reexports
import public Data.Vect.Properties.Tabulate
import public Data.Vect.Properties.Index
import public Data.Vect.Properties.Foldr
import public Data.Vect.Properties.Map
import public Data.Vect.Properties.Fin
\ No newline at end of file
diff --git a/contrib/docs/Data.Vect.Sort.html b/contrib/docs/Data.Vect.Sort.html
index 8af8eec6c2..5dbb3f8ef7 100644
--- a/contrib/docs/Data.Vect.Sort.html
+++ b/contrib/docs/Data.Vect.Sort.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Vect.Sort(source)
Definitions
sortBy : (a -> a -> Ordering) -> Vect n a -> Vect n a
  Merge sort implementation for Vect n a

  Totality: total
  Visibility: export
sort : Ord a => Vect n a -> Vect n a
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Vect.Sort(source)
Definitions
sortBy : (a -> a -> Ordering) -> Vect n a -> Vect n a
  Merge sort implementation for Vect n a

  Totality: total
  Visibility: export
sort : Ord a => Vect n a -> Vect n a
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Data.Vect.Views.Extra.html b/contrib/docs/Data.Vect.Views.Extra.html
index d2e5795dad..e40f90dc51 100644
--- a/contrib/docs/Data.Vect.Views.Extra.html
+++ b/contrib/docs/Data.Vect.Views.Extra.html
@@ -62,4 +62,4 @@
 
 
 
Data.Vect.Views.Extra(source)
Additional views for Vect
-
Definitions
data Split : Vect n a -> Type
  View for splitting a vector in half, non-recursively

  Totality: total
  Visibility: public export
  Constructors:
  
SplitNil : Split []
  
SplitOne : Split [x]
  
SplitPair : (x : a) -> (xs : Vect n a) -> (y : a) -> (ys : Vect m a) -> Split (x :: (xs ++ (y :: ys)))
  two non-empty parts
split : (xs : Vect n a) -> Split xs
  Covering function for the `Split` view
  Constructs the view in linear time

  Totality: total
  Visibility: export
data SplitRec : Vect k a -> Type
  View for splitting a vector in half, recursively
  
  This allows us to define recursive functions which repeatedly split vectors
  in half, with base cases for the empty and singleton lists.

  Totality: total
  Visibility: public export
  Constructors:
  
SplitRecNil : SplitRec []
  
SplitRecOne : SplitRec [x]
  
SplitRecPair : Lazy (SplitRec xs) -> Lazy (SplitRec ys) -> SplitRec (xs ++ ys)
splitRec : (xs : Vect k a) -> SplitRec xs
  Covering function for the `SplitRec` view
  Constructs the view in O(n lg n)

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
data Split : Vect n a -> Type
  View for splitting a vector in half, non-recursively

  Totality: total
  Visibility: public export
  Constructors:
  
SplitNil : Split []
  
SplitOne : Split [x]
  
SplitPair : (x : a) -> (xs : Vect n a) -> (y : a) -> (ys : Vect m a) -> Split (x :: (xs ++ (y :: ys)))
  two non-empty parts
split : (xs : Vect n a) -> Split xs
  Covering function for the `Split` view
  Constructs the view in linear time

  Totality: total
  Visibility: export
data SplitRec : Vect k a -> Type
  View for splitting a vector in half, recursively
  
  This allows us to define recursive functions which repeatedly split vectors
  in half, with base cases for the empty and singleton lists.

  Totality: total
  Visibility: public export
  Constructors:
  
SplitRecNil : SplitRec []
  
SplitRecOne : SplitRec [x]
  
SplitRecPair : Lazy (SplitRec xs) -> Lazy (SplitRec ys) -> SplitRec (xs ++ ys)
splitRec : (xs : Vect k a) -> SplitRec xs
  Covering function for the `SplitRec` view
  Constructs the view in O(n lg n)

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Data.Void.html b/contrib/docs/Data.Void.html
index ed5a33251e..db23a08105 100644
--- a/contrib/docs/Data.Void.html
+++ b/contrib/docs/Data.Void.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Void(source)
Definitions
absurdity : Uninhabited t => (0 _ : t) -> s
  Visibility: export
contradiction : Uninhabited t => (0 _ : (x -> t)) -> x -> s
  Visibility: export

\ No newline at end of file
+
Data.Void(source)
Definitions
absurdity : Uninhabited t => (0 _ : t) -> s
  Visibility: export
contradiction : Uninhabited t => (0 _ : (x -> t)) -> x -> s
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Debug.Buffer.html b/contrib/docs/Debug.Buffer.html
index 7fc3c63333..fe00b64d52 100644
--- a/contrib/docs/Debug.Buffer.html
+++ b/contrib/docs/Debug.Buffer.html
@@ -61,4 +61,4 @@
 
 
 
-
Debug.Buffer(source)
Definitions
dumpBuffer : HasIO io => Buffer -> io String
  Visibility: export
printBuffer : HasIO io => Buffer -> io ()
  Visibility: export

\ No newline at end of file
+
Debug.Buffer(source)
Definitions
dumpBuffer : HasIO io => Buffer -> io String
  Visibility: export
printBuffer : HasIO io => Buffer -> io ()
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Decidable.Decidable.Extra.html b/contrib/docs/Decidable.Decidable.Extra.html
index 9e33981ee8..3626662c15 100644
--- a/contrib/docs/Decidable.Decidable.Extra.html
+++ b/contrib/docs/Decidable.Decidable.Extra.html
@@ -61,4 +61,4 @@
 
 
 
-
Decidable.Decidable.Extra(source)
Definitions
NotNot : Rel ts -> Rel ts
  Totality: total
  Visibility: public export
doubleNegationElimination : Decidable n ts r => (witness : HVect ts) -> uncurry (NotNot r) witness -> uncurry r witness
  Totality: total
  Visibility: public export
doubleNegationExists : Decidable n ts r => Ex ts (NotNot r) -> Ex ts r
  Totality: total
  Visibility: public export
negateDec : Dec a -> Dec (Not a)
  Convert a decision about a decidable property into one about its negation.

  Totality: total
  Visibility: public export
notExistsNotForall : {0 p : a -> Type} -> ((x : a) -> Dec (p x)) -> Dec (x : a ** Not (p x)) -> Dec ((x : a) -> p x)
  We can turn (Not (Exists Not)) into Forall for decidable types

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Decidable.Decidable.Extra(source)
Definitions
NotNot : Rel ts -> Rel ts
  Totality: total
  Visibility: public export
doubleNegationElimination : Decidable n ts r => (witness : HVect ts) -> uncurry (NotNot r) witness -> uncurry r witness
  Totality: total
  Visibility: public export
doubleNegationExists : Decidable n ts r => Ex ts (NotNot r) -> Ex ts r
  Totality: total
  Visibility: public export
negateDec : Dec a -> Dec (Not a)
  Convert a decision about a decidable property into one about its negation.

  Totality: total
  Visibility: public export
notExistsNotForall : {0 p : a -> Type} -> ((x : a) -> Dec (p x)) -> Dec (x : a ** Not (p x)) -> Dec ((x : a) -> p x)
  We can turn (Not (Exists Not)) into Forall for decidable types

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Decidable.Finite.Fin.html b/contrib/docs/Decidable.Finite.Fin.html
index b628f47796..fe06591875 100644
--- a/contrib/docs/Decidable.Finite.Fin.html
+++ b/contrib/docs/Decidable.Finite.Fin.html
@@ -61,4 +61,4 @@
 
 
 
-
Decidable.Finite.Fin(source)
Definitions
finiteDecEx : {0 p : Fin n -> Type} -> ((k : Fin n) -> Dec (p k)) -> Dec (k : Fin n ** p k)
  Given a decidable predicate on Fin n,
  it's decidable whether any number in Fin n satisfies it.

  Visibility: public export
finiteDecAll : {0 p : Fin n -> Type} -> ((k : Fin n) -> Dec (p k)) -> Dec ((k : Fin n) -> p k)
  Given a decidable predicate on Fin n,
  it's decidable whether all numbers in Fin n satisfy it.

  Visibility: public export

\ No newline at end of file
+
Decidable.Finite.Fin(source)
Definitions
finiteDecEx : {0 p : Fin n -> Type} -> ((k : Fin n) -> Dec (p k)) -> Dec (k : Fin n ** p k)
  Given a decidable predicate on Fin n,
  it's decidable whether any number in Fin n satisfies it.

  Visibility: public export
finiteDecAll : {0 p : Fin n -> Type} -> ((k : Fin n) -> Dec (p k)) -> Dec ((k : Fin n) -> p k)
  Given a decidable predicate on Fin n,
  it's decidable whether all numbers in Fin n satisfy it.

  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Decidable.Order.Strict.html b/contrib/docs/Decidable.Order.Strict.html
index 316212c333..e4d2a23639 100644
--- a/contrib/docs/Decidable.Order.Strict.html
+++ b/contrib/docs/Decidable.Order.Strict.html
@@ -67,4 +67,4 @@
 This module extends base's Control.Order with the strict versions.
 The interface system seems to struggle a bit with some of the constructions,
 so I hacked them a bit. Sorry.
-
Definitions
interface Irreflexive : (ty : Type) -> (ty -> ty -> Type) -> Type
  Parameters: ty, rel
Methods:
  
irreflexive : Not (rel x x)

Implementation: 
Irreflexive Nat LT
irreflexive : Irreflexive ty rel => Not (rel x x)
  Totality: total
  Visibility: public export
interface StrictPreorder : (ty : Type) -> (ty -> ty -> Type) -> Type
  Parameters: ty, rel
Constraints: Transitive ty rel, Irreflexive ty rel
Implementation: 
StrictPreorder Nat LT
interface Asymmetric : (ty : Type) -> (ty -> ty -> Type) -> Type
  Parameters: ty, rel
Methods:
  
asymmetric : rel x y -> Not (rel y x)
asymmetric : Asymmetric ty rel => rel x y -> Not (rel y x)
  Totality: total
  Visibility: public export
record EqOr : Rel t -> t -> t -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkEqOr : Either (a = b) (spo a b) -> EqOr spo a b

  Projection: 
.runEqOr : EqOr spo a b -> Either (a = b) (spo a b)

  Hints:
  
(Irreflexive ty rel, Asymmetric ty rel) => Antisymmetric ty (EqOr rel)
  
Connex ty rel => Connex ty (EqOr rel)
  
(Irreflexive ty rel, (Asymmetric ty rel, Transitive ty rel)) => PartialOrder ty (EqOr rel)
  
Transitive ty rel => Preorder ty (EqOr rel)
  
Reflexive ty (EqOr rel)
  
(Connex ty rel, DecEq ty) => StronglyConnex ty (EqOr rel)
  
Transitive ty rel => Transitive ty (EqOr rel)
.runEqOr : EqOr spo a b -> Either (a = b) (spo a b)
  Totality: total
  Visibility: public export
runEqOr : EqOr spo a b -> Either (a = b) (spo a b)
  Totality: total
  Visibility: public export
data DecOrdering : t -> t -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
DecLT : lt a b -> DecOrdering a b
  
DecEQ : a = b -> DecOrdering a b
  
DecGT : lt b a -> DecOrdering a b
interface StrictOrdered : (t : Type) -> (t -> t -> Type) -> Type
  Parameters: t, spo
Constraints: StrictPreorder t spo
Methods:
  
order : (a : t) -> (b : t) -> DecOrdering a b

Implementation: 
StrictOrdered Nat LT
order : StrictOrdered t spo => (a : t) -> (b : t) -> DecOrdering a b
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
interface Irreflexive : (ty : Type) -> (ty -> ty -> Type) -> Type
  Parameters: ty, rel
Methods:
  
irreflexive : Not (rel x x)

Implementation: 
Irreflexive Nat LT
irreflexive : Irreflexive ty rel => Not (rel x x)
  Totality: total
  Visibility: public export
interface StrictPreorder : (ty : Type) -> (ty -> ty -> Type) -> Type
  Parameters: ty, rel
Constraints: Transitive ty rel, Irreflexive ty rel
Implementation: 
StrictPreorder Nat LT
interface Asymmetric : (ty : Type) -> (ty -> ty -> Type) -> Type
  Parameters: ty, rel
Methods:
  
asymmetric : rel x y -> Not (rel y x)
asymmetric : Asymmetric ty rel => rel x y -> Not (rel y x)
  Totality: total
  Visibility: public export
record EqOr : Rel t -> t -> t -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkEqOr : Either (a = b) (spo a b) -> EqOr spo a b

  Projection: 
.runEqOr : EqOr spo a b -> Either (a = b) (spo a b)

  Hints:
  
(Irreflexive ty rel, Asymmetric ty rel) => Antisymmetric ty (EqOr rel)
  
Connex ty rel => Connex ty (EqOr rel)
  
(Irreflexive ty rel, (Asymmetric ty rel, Transitive ty rel)) => PartialOrder ty (EqOr rel)
  
Transitive ty rel => Preorder ty (EqOr rel)
  
Reflexive ty (EqOr rel)
  
(Connex ty rel, DecEq ty) => StronglyConnex ty (EqOr rel)
  
Transitive ty rel => Transitive ty (EqOr rel)
.runEqOr : EqOr spo a b -> Either (a = b) (spo a b)
  Totality: total
  Visibility: public export
runEqOr : EqOr spo a b -> Either (a = b) (spo a b)
  Totality: total
  Visibility: public export
data DecOrdering : t -> t -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
DecLT : lt a b -> DecOrdering a b
  
DecEQ : a = b -> DecOrdering a b
  
DecGT : lt b a -> DecOrdering a b
interface StrictOrdered : (t : Type) -> (t -> t -> Type) -> Type
  Parameters: t, spo
Constraints: StrictPreorder t spo
Methods:
  
order : (a : t) -> (b : t) -> DecOrdering a b

Implementation: 
StrictOrdered Nat LT
order : StrictOrdered t spo => (a : t) -> (b : t) -> DecOrdering a b
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Language.JSON.Data.html b/contrib/docs/Language.JSON.Data.html
index c0de733b0f..423fbbfb8a 100644
--- a/contrib/docs/Language.JSON.Data.html
+++ b/contrib/docs/Language.JSON.Data.html
@@ -61,4 +61,4 @@
 
 
 
-
Language.JSON.Data(source)
Definitions
data JSON : Type
  Totality: total
  Visibility: public export
  Constructors:
  
JNull : JSON
  
JBoolean : Bool -> JSON
  
JNumber : Double -> JSON
  
JString : String -> JSON
  
JArray : List JSON -> JSON
  
JObject : List (String, JSON) -> JSON

  Hints:
  
Cast () JSON
  
Cast Bool JSON
  
Cast Double JSON
  
Cast String JSON
  
Cast a JSON => Cast (List a) JSON
  
Show JSON
format : {default 0 _ : Nat} -> Nat -> JSON -> String
  Format a JSON value, indenting by `n` spaces per nesting level.
  
  @curr The current indentation amount, measured in spaces.
  @n The amount of spaces to indent per nesting level.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Language.JSON.Data(source)
Definitions
data JSON : Type
  Totality: total
  Visibility: public export
  Constructors:
  
JNull : JSON
  
JBoolean : Bool -> JSON
  
JNumber : Double -> JSON
  
JString : String -> JSON
  
JArray : List JSON -> JSON
  
JObject : List (String, JSON) -> JSON

  Hints:
  
Cast () JSON
  
Cast Bool JSON
  
Cast Double JSON
  
Cast String JSON
  
Cast a JSON => Cast (List a) JSON
  
Show JSON
format : {default 0 _ : Nat} -> Nat -> JSON -> String
  Format a JSON value, indenting by `n` spaces per nesting level.
  
  @curr The current indentation amount, measured in spaces.
  @n The amount of spaces to indent per nesting level.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Language.JSON.Lexer.html b/contrib/docs/Language.JSON.Lexer.html
index 149fd357c9..ec366471ae 100644
--- a/contrib/docs/Language.JSON.Lexer.html
+++ b/contrib/docs/Language.JSON.Lexer.html
@@ -61,4 +61,4 @@
 
 
 
-
Language.JSON.Lexer(source)
Reexports
import public Language.JSON.Tokens
Definitions
lexJSON : String -> Maybe (List (WithBounds JSONToken))
  Totality: total
  Visibility: export

\ No newline at end of file
+
Language.JSON.Lexer(source)
Reexports
import public Language.JSON.Tokens
Definitions
lexJSON : String -> Maybe (List (WithBounds JSONToken))
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Language.JSON.Parser.html b/contrib/docs/Language.JSON.Parser.html
index 4e503bf835..1cc9887397 100644
--- a/contrib/docs/Language.JSON.Parser.html
+++ b/contrib/docs/Language.JSON.Parser.html
@@ -61,4 +61,4 @@
 
 
 
-
Language.JSON.Parser(source)
Reexports
import public Language.JSON.Tokens
Definitions
parseJSON : List (WithBounds JSONToken) -> Maybe JSON
  Totality: total
  Visibility: export

\ No newline at end of file
+
Language.JSON.Parser(source)
Reexports
import public Language.JSON.Tokens
Definitions
parseJSON : List (WithBounds JSONToken) -> Maybe JSON
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Language.JSON.String.Lexer.html b/contrib/docs/Language.JSON.String.Lexer.html
index 22fe9edf65..ba31428a6e 100644
--- a/contrib/docs/Language.JSON.String.Lexer.html
+++ b/contrib/docs/Language.JSON.String.Lexer.html
@@ -61,4 +61,4 @@
 
 
 
-
Language.JSON.String.Lexer(source)
Definitions
quo : Lexer
  Totality: total
  Visibility: export
esc : Lexer -> Lexer
  Totality: total
  Visibility: export
lexString : String -> Maybe (List (WithBounds JSONStringToken))
  Totality: total
  Visibility: export

\ No newline at end of file
+
Language.JSON.String.Lexer(source)
Definitions
quo : Lexer
  Totality: total
  Visibility: export
esc : Lexer -> Lexer
  Totality: total
  Visibility: export
lexString : String -> Maybe (List (WithBounds JSONStringToken))
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Language.JSON.String.Parser.html b/contrib/docs/Language.JSON.String.Parser.html
index 00f0370f45..728c68ccb1 100644
--- a/contrib/docs/Language.JSON.String.Parser.html
+++ b/contrib/docs/Language.JSON.String.Parser.html
@@ -61,4 +61,4 @@
 
 
 
-
Language.JSON.String.Parser(source)
Definitions
parseString : List (WithBounds JSONStringToken) -> Maybe String
  Totality: total
  Visibility: export

\ No newline at end of file
+
Language.JSON.String.Parser(source)
Definitions
parseString : List (WithBounds JSONStringToken) -> Maybe String
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Language.JSON.String.Tokens.html b/contrib/docs/Language.JSON.String.Tokens.html
index 7e6d02f807..1dbe2258ec 100644
--- a/contrib/docs/Language.JSON.String.Tokens.html
+++ b/contrib/docs/Language.JSON.String.Tokens.html
@@ -61,4 +61,4 @@
 
 
 
-
Language.JSON.String.Tokens(source)
Definitions
data JSONStringTokenKind : Type
  Totality: total
  Visibility: public export
  Constructors:
  
JSTQuote : JSONStringTokenKind
  
JSTChar : JSONStringTokenKind
  
JSTSimpleEscape : JSONStringTokenKind
  
JSTUnicodeEscape : JSONStringTokenKind

  Hints:
  
Eq JSONStringTokenKind
  
TokenKind JSONStringTokenKind
JSONStringToken : Type
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Language.JSON.String.Tokens(source)
Definitions
data JSONStringTokenKind : Type
  Totality: total
  Visibility: public export
  Constructors:
  
JSTQuote : JSONStringTokenKind
  
JSTChar : JSONStringTokenKind
  
JSTSimpleEscape : JSONStringTokenKind
  
JSTUnicodeEscape : JSONStringTokenKind

  Hints:
  
Eq JSONStringTokenKind
  
TokenKind JSONStringTokenKind
JSONStringToken : Type
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Language.JSON.String.html b/contrib/docs/Language.JSON.String.html
index 3c4acfd297..8fa87ce6a0 100644
--- a/contrib/docs/Language.JSON.String.html
+++ b/contrib/docs/Language.JSON.String.html
@@ -61,4 +61,4 @@
 
 
 
-
Language.JSON.String(source)
Definitions
permissiveStringLit : Lexer
  Totality: total
  Visibility: export
stringValue : String -> Maybe String
  Totality: total
  Visibility: export

\ No newline at end of file
+
Language.JSON.String(source)
Definitions
permissiveStringLit : Lexer
  Totality: total
  Visibility: export
stringValue : String -> Maybe String
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Language.JSON.Tokens.html b/contrib/docs/Language.JSON.Tokens.html
index 95ec841848..a18ab05725 100644
--- a/contrib/docs/Language.JSON.Tokens.html
+++ b/contrib/docs/Language.JSON.Tokens.html
@@ -61,4 +61,4 @@
 
 
 
-
Language.JSON.Tokens(source)
Definitions
strTrue : String
  Totality: total
  Visibility: public export
strFalse : String
  Totality: total
  Visibility: public export
data Bracket : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Open : Bracket
  
Close : Bracket

  Hint: 
Eq Bracket
data Punctuation : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Comma : Punctuation
  
Colon : Punctuation
  
Square : Bracket -> Punctuation
  
Curly : Bracket -> Punctuation

  Hint: 
Eq Punctuation
data JSONTokenKind : Type
  Totality: total
  Visibility: public export
  Constructors:
  
JTBoolean : JSONTokenKind
  
JTNumber : JSONTokenKind
  
JTString : JSONTokenKind
  
JTNull : JSONTokenKind
  
JTPunct : Punctuation -> JSONTokenKind
  
JTIgnore : JSONTokenKind

  Hints:
  
Eq JSONTokenKind
  
TokenKind JSONTokenKind
JSONToken : Type
  Totality: total
  Visibility: public export
ignored : WithBounds JSONToken -> Bool
  Totality: total
  Visibility: export

\ No newline at end of file
+
Language.JSON.Tokens(source)
Definitions
strTrue : String
  Totality: total
  Visibility: public export
strFalse : String
  Totality: total
  Visibility: public export
data Bracket : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Open : Bracket
  
Close : Bracket

  Hint: 
Eq Bracket
data Punctuation : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Comma : Punctuation
  
Colon : Punctuation
  
Square : Bracket -> Punctuation
  
Curly : Bracket -> Punctuation

  Hint: 
Eq Punctuation
data JSONTokenKind : Type
  Totality: total
  Visibility: public export
  Constructors:
  
JTBoolean : JSONTokenKind
  
JTNumber : JSONTokenKind
  
JTString : JSONTokenKind
  
JTNull : JSONTokenKind
  
JTPunct : Punctuation -> JSONTokenKind
  
JTIgnore : JSONTokenKind

  Hints:
  
Eq JSONTokenKind
  
TokenKind JSONTokenKind
JSONToken : Type
  Totality: total
  Visibility: public export
ignored : WithBounds JSONToken -> Bool
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Language.JSON.html b/contrib/docs/Language.JSON.html
index 43d2d6d694..3c15a5c116 100644
--- a/contrib/docs/Language.JSON.html
+++ b/contrib/docs/Language.JSON.html
@@ -62,4 +62,4 @@
 
 
 
Language.JSON(source)
The JSON language, as described at https://json.org/
-
Reexports
import public Language.JSON.Data
import public Text.Bounded
Definitions
parse : String -> Maybe JSON
  Parse a JSON string.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Reexports
import public Language.JSON.Data
import public Text.Bounded
Definitions
parse : String -> Maybe JSON
  Parse a JSON string.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Syntax.WithProof.html b/contrib/docs/Syntax.WithProof.html
index 9c9f24dbe7..5e0e826c91 100644
--- a/contrib/docs/Syntax.WithProof.html
+++ b/contrib/docs/Syntax.WithProof.html
@@ -61,4 +61,4 @@
 
 
 
-
Syntax.WithProof(source)
Definitions
(@@) : (t : a) -> (u : a ** t = u)
  Until Idris2 supports the 'with (...) proof p' construct, here's a
  poor-man's replacement.

  Visibility: public export
  Fixity Declaration: prefix operator, level 10

\ No newline at end of file
+
Syntax.WithProof(source)
Definitions
(@@) : (t : a) -> (u : a ** t = u)
  Until Idris2 supports the 'with (...) proof p' construct, here's a
  poor-man's replacement.

  Visibility: public export
  Fixity Declaration: prefix operator, level 10

\ No newline at end of file
diff --git a/contrib/docs/System.Console.GetOpt.html b/contrib/docs/System.Console.GetOpt.html
index c7ab99ce34..6b1b9249db 100644
--- a/contrib/docs/System.Console.GetOpt.html
+++ b/contrib/docs/System.Console.GetOpt.html
@@ -65,4 +65,4 @@
 in a standalone program. It is essentially an Idris port of the GNU getopt library.
 (Actually, it is an Idris port of the [corresponding Haskell module]
 (http://hackage.haskell.org/package/base-4.14.1.0/docs/System-Console-GetOpt.html)).
-
Definitions
data ArgOrder : Type -> Type
  What to do with options following non-options

  Totality: total
  Visibility: public export
  Constructors:
  
RequireOrder : ArgOrder a
  no option processing after first non-option
  
Permute : ArgOrder a
  freely intersperse options and non-options
  
ReturnInOrder : (String -> a) -> ArgOrder a
  wrap non-options into options
  
ReturnInOrder' : (String -> Either String a) -> ArgOrder a
  wrap non-options into options (or fail, if can't)

  Hint: 
Functor ArgOrder
data ArgDescr : Type -> Type
  Describes whether an option takes an argument or not, and if so
  how the argument is injected into a value of type `a`.

  Totality: total
  Visibility: public export
  Constructors:
  
NoArg : a -> ArgDescr a
  no argument expected
  
ReqArg : (String -> a) -> String -> ArgDescr a
  option requires argument
  
ReqArg' : (String -> Either String a) -> String -> ArgDescr a
  option requires argument and may fail during parsing
  
OptArg : (Maybe String -> a) -> String -> ArgDescr a
  optional argument
  
OptArg' : (Maybe String -> Either String a) -> String -> ArgDescr a
  optional argument and may fail during parsing

  Hint: 
Functor ArgDescr
record OptDescr : Type -> Type
  Each `OptDescr` describes a single option.
  
  The arguments to 'Option' are:
  
  * list of short option characters
  * list of long option strings (without \"--\")
  * argument descriptor
  * explanation of option for user

  Totality: total
  Visibility: public export
  Constructor: 
MkOpt : List Char -> List String -> ArgDescr a -> String -> OptDescr a

  Projections:
  
.argDescr : OptDescr a -> ArgDescr a
  argument descriptor
  
.description : OptDescr a -> String
  explanation of option for user
  
.longNames : OptDescr a -> List String
  list of long option strings (without "--")
  
.shortNames : OptDescr a -> List Char
  list of short option characters

  Hint: 
Functor OptDescr
.shortNames : OptDescr a -> List Char
  list of short option characters

  Totality: total
  Visibility: public export
shortNames : OptDescr a -> List Char
  list of short option characters

  Totality: total
  Visibility: public export
.longNames : OptDescr a -> List String
  list of long option strings (without "--")

  Totality: total
  Visibility: public export
longNames : OptDescr a -> List String
  list of long option strings (without "--")

  Totality: total
  Visibility: public export
.argDescr : OptDescr a -> ArgDescr a
  argument descriptor

  Totality: total
  Visibility: public export
argDescr : OptDescr a -> ArgDescr a
  argument descriptor

  Totality: total
  Visibility: public export
.description : OptDescr a -> String
  explanation of option for user

  Totality: total
  Visibility: public export
description : OptDescr a -> String
  explanation of option for user

  Totality: total
  Visibility: public export
usageInfo : String -> List (OptDescr a) -> String
  Return a string describing the usage of a command, derived from
  the header (first argument) and the options described by the
  second argument.

  Totality: total
  Visibility: public export
record Result : Type -> Type
  Result of parsing the command line arguments accoring to a list
  of `OptDescr`s. (see also function `getOpt`).

  Totality: total
  Visibility: public export
  Constructor: 
MkResult : List a -> List String -> List String -> List String -> Result a

  Projections:
  
.errors : Result a -> List String
  Errors during option parsing. These occur, for instance, when
  an option requires an additional argument but none was given.
  
.nonOptions : Result a -> List String
  List of non-options (other command line arguments)
  
.options : Result a -> List a
  List of successfully parsed options
  
.unrecognized : Result a -> List String
  List of unrecognized options.

  Hint: 
Functor Result
.options : Result a -> List a
  List of successfully parsed options

  Totality: total
  Visibility: public export
options : Result a -> List a
  List of successfully parsed options

  Totality: total
  Visibility: public export
.nonOptions : Result a -> List String
  List of non-options (other command line arguments)

  Totality: total
  Visibility: public export
nonOptions : Result a -> List String
  List of non-options (other command line arguments)

  Totality: total
  Visibility: public export
.unrecognized : Result a -> List String
  List of unrecognized options.

  Totality: total
  Visibility: public export
unrecognized : Result a -> List String
  List of unrecognized options.

  Totality: total
  Visibility: public export
.errors : Result a -> List String
  Errors during option parsing. These occur, for instance, when
  an option requires an additional argument but none was given.

  Totality: total
  Visibility: public export
errors : Result a -> List String
  Errors during option parsing. These occur, for instance, when
  an option requires an additional argument but none was given.

  Totality: total
  Visibility: public export
emptyRes : Result a
  Totality: total
  Visibility: public export
getOpt : ArgOrder a -> List (OptDescr a) -> List String -> Result a
  Process the command-line, and return the list of values that matched
  (and those that didn't). The arguments are:
  
  * The order requirements (see `ArgOrder`)
  
  * The option descriptions (see `OptDescr`)
  
  * The actual command line arguments (presumably got from
    `System.getArgs`).

  Totality: total
  Visibility: export
getOpt' : Applicative f => ArgOrder (f a) -> List (OptDescr (f a)) -> List String -> f (Result a)
  Parse the command-line like `getOpt`, but allow each option parser to do
  additional work in some `Applicative`.
  
  Place, notice that options parsing is done first, i.e. if you use
  applicatives that can have a failure semantics, you will lose all errors
  reported inside the `Result` type in case of any option parsing fails.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
data ArgOrder : Type -> Type
  What to do with options following non-options

  Totality: total
  Visibility: public export
  Constructors:
  
RequireOrder : ArgOrder a
  no option processing after first non-option
  
Permute : ArgOrder a
  freely intersperse options and non-options
  
ReturnInOrder : (String -> a) -> ArgOrder a
  wrap non-options into options
  
ReturnInOrder' : (String -> Either String a) -> ArgOrder a
  wrap non-options into options (or fail, if can't)

  Hint: 
Functor ArgOrder
data ArgDescr : Type -> Type
  Describes whether an option takes an argument or not, and if so
  how the argument is injected into a value of type `a`.

  Totality: total
  Visibility: public export
  Constructors:
  
NoArg : a -> ArgDescr a
  no argument expected
  
ReqArg : (String -> a) -> String -> ArgDescr a
  option requires argument
  
ReqArg' : (String -> Either String a) -> String -> ArgDescr a
  option requires argument and may fail during parsing
  
OptArg : (Maybe String -> a) -> String -> ArgDescr a
  optional argument
  
OptArg' : (Maybe String -> Either String a) -> String -> ArgDescr a
  optional argument and may fail during parsing

  Hint: 
Functor ArgDescr
record OptDescr : Type -> Type
  Each `OptDescr` describes a single option.
  
  The arguments to 'Option' are:
  
  * list of short option characters
  * list of long option strings (without \"--\")
  * argument descriptor
  * explanation of option for user

  Totality: total
  Visibility: public export
  Constructor: 
MkOpt : List Char -> List String -> ArgDescr a -> String -> OptDescr a

  Projections:
  
.argDescr : OptDescr a -> ArgDescr a
  argument descriptor
  
.description : OptDescr a -> String
  explanation of option for user
  
.longNames : OptDescr a -> List String
  list of long option strings (without "--")
  
.shortNames : OptDescr a -> List Char
  list of short option characters

  Hint: 
Functor OptDescr
.shortNames : OptDescr a -> List Char
  list of short option characters

  Totality: total
  Visibility: public export
shortNames : OptDescr a -> List Char
  list of short option characters

  Totality: total
  Visibility: public export
.longNames : OptDescr a -> List String
  list of long option strings (without "--")

  Totality: total
  Visibility: public export
longNames : OptDescr a -> List String
  list of long option strings (without "--")

  Totality: total
  Visibility: public export
.argDescr : OptDescr a -> ArgDescr a
  argument descriptor

  Totality: total
  Visibility: public export
argDescr : OptDescr a -> ArgDescr a
  argument descriptor

  Totality: total
  Visibility: public export
.description : OptDescr a -> String
  explanation of option for user

  Totality: total
  Visibility: public export
description : OptDescr a -> String
  explanation of option for user

  Totality: total
  Visibility: public export
usageInfo : String -> List (OptDescr a) -> String
  Return a string describing the usage of a command, derived from
  the header (first argument) and the options described by the
  second argument.

  Totality: total
  Visibility: public export
record Result : Type -> Type
  Result of parsing the command line arguments accoring to a list
  of `OptDescr`s. (see also function `getOpt`).

  Totality: total
  Visibility: public export
  Constructor: 
MkResult : List a -> List String -> List String -> List String -> Result a

  Projections:
  
.errors : Result a -> List String
  Errors during option parsing. These occur, for instance, when
  an option requires an additional argument but none was given.
  
.nonOptions : Result a -> List String
  List of non-options (other command line arguments)
  
.options : Result a -> List a
  List of successfully parsed options
  
.unrecognized : Result a -> List String
  List of unrecognized options.

  Hint: 
Functor Result
.options : Result a -> List a
  List of successfully parsed options

  Totality: total
  Visibility: public export
options : Result a -> List a
  List of successfully parsed options

  Totality: total
  Visibility: public export
.nonOptions : Result a -> List String
  List of non-options (other command line arguments)

  Totality: total
  Visibility: public export
nonOptions : Result a -> List String
  List of non-options (other command line arguments)

  Totality: total
  Visibility: public export
.unrecognized : Result a -> List String
  List of unrecognized options.

  Totality: total
  Visibility: public export
unrecognized : Result a -> List String
  List of unrecognized options.

  Totality: total
  Visibility: public export
.errors : Result a -> List String
  Errors during option parsing. These occur, for instance, when
  an option requires an additional argument but none was given.

  Totality: total
  Visibility: public export
errors : Result a -> List String
  Errors during option parsing. These occur, for instance, when
  an option requires an additional argument but none was given.

  Totality: total
  Visibility: public export
emptyRes : Result a
  Totality: total
  Visibility: public export
getOpt : ArgOrder a -> List (OptDescr a) -> List String -> Result a
  Process the command-line, and return the list of values that matched
  (and those that didn't). The arguments are:
  
  * The order requirements (see `ArgOrder`)
  
  * The option descriptions (see `OptDescr`)
  
  * The actual command line arguments (presumably got from
    `System.getArgs`).

  Totality: total
  Visibility: export
getOpt' : Applicative f => ArgOrder (f a) -> List (OptDescr (f a)) -> List String -> f (Result a)
  Parse the command-line like `getOpt`, but allow each option parser to do
  additional work in some `Applicative`.
  
  Place, notice that options parsing is done first, i.e. if you use
  applicatives that can have a failure semantics, you will lose all errors
  reported inside the `Result` type in case of any option parsing fails.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/System.Directory.Tree.html b/contrib/docs/System.Directory.Tree.html
index 20339757ea..fc90bd9802 100644
--- a/contrib/docs/System.Directory.Tree.html
+++ b/contrib/docs/System.Directory.Tree.html
@@ -61,4 +61,4 @@
 
 
 
-
System.Directory.Tree(source)
Definitions
data FileName : Path -> Type
  A `Filename root` is anchored in `root`.
  We use a `data` type so that Idris can easily infer `root` when passing
  a `FileName` around. We do not use a `record` because we do not want to
  allow users to manufacture their own `FileName`.
  To get an absolute path, we need to append said filename to the root.

  Totality: total
  Visibility: export
  Constructor: 
MkFileName : String -> FileName root
fileName : FileName root -> String
  Project the string out of a `FileName`.

  Totality: total
  Visibility: export
toRelative : FileName root -> FileName (parse "")
  Totality: total
  Visibility: export
toFilePath : FileName root -> Path
  Convert a filename anchored in `root` to a filepath by appending the name
  to the root path.

  Totality: total
  Visibility: export
directoryExists : FileName root -> IO Bool
  Totality: total
  Visibility: export
SubTree : Path -> Type
  A `Tree root` is the representation of a directory tree anchored in `root`.
  Each directory contains a list of files and a list of subtrees waiting to be
  explored. The fact these subtrees are IO-bound means the subtrees will be
  lazily constructed on demand.

  Totality: total
  Visibility: public export
record Tree : Path -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkTree : List (FileName root) -> List (SubTree root) -> Tree root

  Projections:
  
.files : Tree root -> List (FileName root)
  
.subTrees : Tree root -> List (SubTree root)
.files : Tree root -> List (FileName root)
  Totality: total
  Visibility: public export
files : Tree root -> List (FileName root)
  Totality: total
  Visibility: public export
.subTrees : Tree root -> List (SubTree root)
  Totality: total
  Visibility: public export
subTrees : Tree root -> List (SubTree root)
  Totality: total
  Visibility: public export
emptyTree : Tree root
  An empty tree contains no files and has no sub-directories.

  Totality: total
  Visibility: export
toRelative : Tree root -> Tree (parse "")
  No run time information is changed,
  so we assert the identity.

  Totality: total
  Visibility: export
filter : (FileName root -> Bool) -> (FileName root -> Bool) -> Tree root -> Tree root
  Filter out files and directories that do not satisfy a given predicate.

  Totality: total
  Visibility: export
sortBy : (FileName root -> FileName root -> Ordering) -> (FileName root -> FileName root -> Ordering) -> Tree root -> Tree root
  Sort the lists of files and directories using the given comparison functions

  Totality: total
  Visibility: export
sort : Tree root -> Tree root
  Sort the list of files and directories alphabetically

  Totality: total
  Visibility: export
explore : (root : Path) -> IO (Tree root)
  Exploring a filesystem from a given root to produce a tree

  Totality: total
  Visibility: export
depthFirst : (FileName root -> Lazy (IO a) -> IO a) -> Tree root -> IO a -> IO a
  Depth first traversal of all of the files in a tree

  Visibility: export
findFile : String -> Tree root -> IO (Maybe Path)
  Finding a file in a tree (depth first search)

  Visibility: export
print : Tree root -> IO ()
  Display a tree by printing it procedurally. Note that because directory
  trees contain suspended computations corresponding to their subtrees this
  has to be an `IO` function. We make it return Unit rather than a String
  because we do not want to assume that the tree is finite.

  Visibility: export
copyDir : HasIO io => Path -> Path -> io (Either FileError ())
  Copy a directory and its contents recursively
  Returns a FileError if the target directory already exists, or if any of
  the source files fail to be copied.

  Visibility: export

\ No newline at end of file
+
System.Directory.Tree(source)
Definitions
data FileName : Path -> Type
  A `Filename root` is anchored in `root`.
  We use a `data` type so that Idris can easily infer `root` when passing
  a `FileName` around. We do not use a `record` because we do not want to
  allow users to manufacture their own `FileName`.
  To get an absolute path, we need to append said filename to the root.

  Totality: total
  Visibility: export
  Constructor: 
MkFileName : String -> FileName root
fileName : FileName root -> String
  Project the string out of a `FileName`.

  Totality: total
  Visibility: export
toRelative : FileName root -> FileName (parse "")
  Totality: total
  Visibility: export
toFilePath : FileName root -> Path
  Convert a filename anchored in `root` to a filepath by appending the name
  to the root path.

  Totality: total
  Visibility: export
directoryExists : FileName root -> IO Bool
  Totality: total
  Visibility: export
SubTree : Path -> Type
  A `Tree root` is the representation of a directory tree anchored in `root`.
  Each directory contains a list of files and a list of subtrees waiting to be
  explored. The fact these subtrees are IO-bound means the subtrees will be
  lazily constructed on demand.

  Totality: total
  Visibility: public export
record Tree : Path -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkTree : List (FileName root) -> List (SubTree root) -> Tree root

  Projections:
  
.files : Tree root -> List (FileName root)
  
.subTrees : Tree root -> List (SubTree root)
.files : Tree root -> List (FileName root)
  Totality: total
  Visibility: public export
files : Tree root -> List (FileName root)
  Totality: total
  Visibility: public export
.subTrees : Tree root -> List (SubTree root)
  Totality: total
  Visibility: public export
subTrees : Tree root -> List (SubTree root)
  Totality: total
  Visibility: public export
emptyTree : Tree root
  An empty tree contains no files and has no sub-directories.

  Totality: total
  Visibility: export
toRelative : Tree root -> Tree (parse "")
  No run time information is changed,
  so we assert the identity.

  Totality: total
  Visibility: export
filter : (FileName root -> Bool) -> (FileName root -> Bool) -> Tree root -> Tree root
  Filter out files and directories that do not satisfy a given predicate.

  Totality: total
  Visibility: export
sortBy : (FileName root -> FileName root -> Ordering) -> (FileName root -> FileName root -> Ordering) -> Tree root -> Tree root
  Sort the lists of files and directories using the given comparison functions

  Totality: total
  Visibility: export
sort : Tree root -> Tree root
  Sort the list of files and directories alphabetically

  Totality: total
  Visibility: export
explore : (root : Path) -> IO (Tree root)
  Exploring a filesystem from a given root to produce a tree

  Totality: total
  Visibility: export
depthFirst : (FileName root -> Lazy (IO a) -> IO a) -> Tree root -> IO a -> IO a
  Depth first traversal of all of the files in a tree

  Visibility: export
findFile : String -> Tree root -> IO (Maybe Path)
  Finding a file in a tree (depth first search)

  Visibility: export
print : Tree root -> IO ()
  Display a tree by printing it procedurally. Note that because directory
  trees contain suspended computations corresponding to their subtrees this
  has to be an `IO` function. We make it return Unit rather than a String
  because we do not want to assume that the tree is finite.

  Visibility: export
copyDir : HasIO io => Path -> Path -> io (Either FileError ())
  Copy a directory and its contents recursively
  Returns a FileError if the target directory already exists, or if any of
  the source files fail to be copied.

  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/System.Future.html b/contrib/docs/System.Future.html
index 1bd0016606..b5dab6d144 100644
--- a/contrib/docs/System.Future.html
+++ b/contrib/docs/System.Future.html
@@ -61,4 +61,4 @@
 
 
 
-
System.Future(source)
Definitions
data Future : Type -> Type
  Totality: total
  Visibility: export
  Hints:
  
Applicative Future
  
Functor Future
  
Monad Future
fork : Lazy a -> Future a
  Totality: total
  Visibility: export
await : Future a -> a
  Totality: total
  Visibility: export
performFutureIO : HasIO io => Future (IO a) -> io (Future a)
  Totality: total
  Visibility: export
forkIO : HasIO io => IO a -> io (Future a)
  Totality: total
  Visibility: export

\ No newline at end of file
+
System.Future(source)
Definitions
data Future : Type -> Type
  Totality: total
  Visibility: export
  Hints:
  
Applicative Future
  
Functor Future
  
Monad Future
fork : Lazy a -> Future a
  Totality: total
  Visibility: export
await : Future a -> a
  Totality: total
  Visibility: export
performFutureIO : HasIO io => Future (IO a) -> io (Future a)
  Totality: total
  Visibility: export
forkIO : HasIO io => IO a -> io (Future a)
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/System.Path.html b/contrib/docs/System.Path.html
index 644aa076e0..07d84a7582 100644
--- a/contrib/docs/System.Path.html
+++ b/contrib/docs/System.Path.html
@@ -61,4 +61,4 @@
 
 
 
-
System.Path(source)
Definitions
dirSeparator : Char
  The character that separates directories in the path.

  Visibility: export
pathSeparator : Char
  The character that separates multiple paths.

  Visibility: export
data Volume : Type
  Windows path prefix.

  Totality: total
  Visibility: public export
  Constructors:
  
UNC : String -> String -> Volume
  Windows Uniform Naming Convention, consisting of server name and share
  directory.
  
  Example: `\\localhost\share`
  
Disk : Char -> Volume
  The drive.
  
  Example: `C:`

  Hints:
  
Eq Volume
  
Show Volume
data Body : Type
  A single body in path.

  Totality: total
  Visibility: public export
  Constructors:
  
CurDir : Body
  Represents ".".
  
ParentDir : Body
  Represents "..".
  
Normal : String -> Body
  Directory or file.

  Hints:
  
Eq Body
  
Show Body
record Path : Type
  A parsed cross-platform file system path.
  
  Use the function `parse` to constructs a Path from String, and use the
  function `show` to convert in reverse.
  
  Trailing separator is only used for display and is ignored when comparing
  paths.

  Totality: total
  Visibility: public export
  Constructor: 
MkPath : Maybe Volume -> Bool -> List Body -> Bool -> Path

  Projections:
  
.body : Path -> List Body
  Path bodies.
  
.hasRoot : Path -> Bool
  Whether the path contains root.
  
.hasTrailSep : Path -> Bool
  Whether the path terminates with a separator.
  
.volume : Path -> Maybe Volume
  Windows path prefix (only for Windows).

  Hints:
  
Eq Path
  
Show Path
.volume : Path -> Maybe Volume
  Windows path prefix (only for Windows).

  Visibility: public export
volume : Path -> Maybe Volume
  Windows path prefix (only for Windows).

  Visibility: public export
.hasRoot : Path -> Bool
  Whether the path contains root.

  Visibility: public export
hasRoot : Path -> Bool
  Whether the path contains root.

  Visibility: public export
.body : Path -> List Body
  Path bodies.

  Visibility: public export
body : Path -> List Body
  Path bodies.

  Visibility: public export
.hasTrailSep : Path -> Bool
  Whether the path terminates with a separator.

  Visibility: public export
hasTrailSep : Path -> Bool
  Whether the path terminates with a separator.

  Visibility: public export
emptyPath : Path
  An empty path, which represents "".

  Visibility: public export
tryParse : String -> Maybe Path
  Visibility: export
parse : String -> Path
  Parses a String into Path.
  
  The string is parsed as much as possible from left to right, and the invalid
  parts on the right is ignored.
  
  Some kind of invalid paths are accepted. The relax rules:
  
  - Both slash('/') and backslash('\\') are parsed as valid directory separator,
    regardless of the platform;
  - Any characters in the body in allowed, e.g., glob like "/root/*";
  - Verbatim prefix(`\\?\`) that disables the forward slash is ignored (for
    Windows only).
  - Repeated separators are ignored, therefore, "a/b" and "a//b" both have "a"
    and "b" as bodies.
  - "." in the body are removed, unless they are at the beginning of the path.
    For example, "a/./b", "a/b/", "a/b/." and "a/b" will have "a" and "b" as
    bodies, and "./a/b" will starts with `CurDir`.
  
  ```idris example
  parse "C:\\Windows/System32"
  parse "/usr/local/etc/*"
  ```

  Visibility: export
splitFileName : String -> (String, String)
  Visibility: export
splitExtensions : String -> (String, List String)
  Split a file name into a basename and a list of extensions.
  A leading dot is considered to be part of the basename.
  ```
  splitExtensions "Path.idr"           = ("Path", ["idr"])
  splitExtensions "file.latex.lidr"    = ("file", ["latex", "lidr"])
  splitExtensions ".hidden.latex.lidr" = (".hidden", ["latex", "lidr"])
  ```

  Visibility: export
isAbsolute : String -> Bool
  Returns true if the path is absolute.
  
  - On Unix, a path is absolute if it starts with the root, so `isAbsolute` and
    `hasRoot` are equivalent.
  
  - On Windows, a path is absolute if it starts with a disk and has root or
    starts with UNC. For example, `c:\\windows` is absolute, while `c:temp`
    and `\temp` are not.

  Visibility: export
isRelative : String -> Bool
  Returns true if the path is relative.

  Visibility: export
(/>) : Path -> String -> Path
  Appends the right path to the left path.
  
  If the path on the right is absolute, it replaces the left path.
  
  On Windows:
  
  - If the right path has a root but no volume (e.g., `\windows`), it replaces
    everything except for the volume (if any) of left.
  - If the right path has a volume but no root, it replaces left.
  
  ```idris example
  parse "/usr" /> "local/etc" == "/usr/local/etc"
  ```

  Visibility: export
  Fixity Declaration: infixl operator, level 5
(</>) : String -> String -> String
  Appends the right path to the left path.
  
  If the path on the right is absolute, it replaces the left path.
  
  On Windows:
  
  - If the right path has a root but no volume (e.g., `\windows`), it replaces
    everything except for the volume (if any) of left.
  - If the right path has a volume but no root, it replaces left.
  
  ```idris example
  "/usr" </> "local/etc" == "/usr/local/etc"
  ```

  Visibility: export
  Fixity Declaration: infixl operator, level 5
joinPath : List String -> String
  Joins path components into one.
  
  ```idris example
  joinPath ["/usr", "local/etc"] == "/usr/local/etc"
  ```

  Visibility: export
splitPath : String -> List String
  Splits path into components.
  
  ```idris example
  splitPath "/usr/local/etc" == ["/", "usr", "local", "etc"]
  splitPath "tmp/Foo.idr" == ["tmp", "Foo.idr"]
  ```

  Visibility: export
splitParent : String -> Maybe (String, String)
  Splits the path into parent and child.
  
  ```idris example
  splitParent "/usr/local/etc" == Just ("/usr/local", "etc")
  ```

  Visibility: export
parent : String -> Maybe String
  Returns the path without its final component, if there is one.
  
  Returns Nothing if the path terminates by a root or volume.

  Visibility: export
parents : String -> List String
  Returns the list of all parents of the path, longest first, self included.
  
  ```idris example
  parents "/etc/kernel" == ["/etc/kernel", "/etc", "/"]
  ```

  Visibility: export
isBaseOf : String -> String -> Bool
  Determines whether the base is one of the parents of target.
  
  Trailing separator is ignored.
  
  ```idris example
  "/etc" `isBaseOf` "/etc/kernel"
  ```

  Visibility: export
dropBase : String -> String -> Maybe String
  Returns a path that, when appended to base, yields target.
  
  Returns Nothing if the base is not a prefix of the target.

  Visibility: export
fileName : String -> Maybe String
  Returns the last body of the path.
  
  If the last body is a file, this is the file name;
  if it's a directory, this is the directory name;
  if it's ".", it recurses on the previous body;
  if it's "..", returns Nothing.

  Visibility: export
fileStem : String -> Maybe String
  Extracts the file name in the path without extension.
  
  The stem is:
  
  - Nothing, if there is no file name;
  - The entire file name if there is no embedded ".";
  - The entire file name if the file name begins with a "." and has no other ".";
  - Otherwise, the portion of the file name before the last ".".

  Visibility: export
extension : String -> Maybe String
  Extracts the extension of the file name in the path.
  
  The extension is:
  
  - Nothing, if there is no file name;
  - Nothing, if there is no embedded ".";
  - Nothing, if the file name begins with a "." and has no other ".";
  - Otherwise, the portion of the file name after the last ".".

  Visibility: export
extensions : String -> Maybe (List String)
  Extracts the list of extensions of the file name in the path.
  The returned value is:
  
  - Nothing, if there is no file name;
  - Just [], if there is no embedded ".";
  - Just [], if the filename begins with a "." and has no other ".";
  - Just es, the portions between the "."s (excluding a potential leading one).

  Visibility: export
setFileName : String -> String -> String
  Updates the file name in the path.
  
  If there is no file name, it appends the name to the path;
  otherwise, it appends the name to the parent of the path.

  Visibility: export
(<.>) : String -> String -> String
  Appends a extension to the path.
  
  If there is no file name, the path will not change;
  if the path has no extension, the extension will be appended;
  if the given extension is empty, the extension of the path will be dropped;
  otherwise, the extension will be replaced.
  
  ```idris example
  "/tmp/Foo" <.> "idr" == "/tmp/Foo.idr"
  ```

  Visibility: export
  Fixity Declarations:
  infixl operator, level 7
infixr operator, level 7
dropExtension : String -> String
  Drops the extension of the path.

  Visibility: export

\ No newline at end of file
+
System.Path(source)
Definitions
dirSeparator : Char
  The character that separates directories in the path.

  Visibility: export
pathSeparator : Char
  The character that separates multiple paths.

  Visibility: export
data Volume : Type
  Windows path prefix.

  Totality: total
  Visibility: public export
  Constructors:
  
UNC : String -> String -> Volume
  Windows Uniform Naming Convention, consisting of server name and share
  directory.
  
  Example: `\\localhost\share`
  
Disk : Char -> Volume
  The drive.
  
  Example: `C:`

  Hints:
  
Eq Volume
  
Show Volume
data Body : Type
  A single body in path.

  Totality: total
  Visibility: public export
  Constructors:
  
CurDir : Body
  Represents ".".
  
ParentDir : Body
  Represents "..".
  
Normal : String -> Body
  Directory or file.

  Hints:
  
Eq Body
  
Show Body
record Path : Type
  A parsed cross-platform file system path.
  
  Use the function `parse` to constructs a Path from String, and use the
  function `show` to convert in reverse.
  
  Trailing separator is only used for display and is ignored when comparing
  paths.

  Totality: total
  Visibility: public export
  Constructor: 
MkPath : Maybe Volume -> Bool -> List Body -> Bool -> Path

  Projections:
  
.body : Path -> List Body
  Path bodies.
  
.hasRoot : Path -> Bool
  Whether the path contains root.
  
.hasTrailSep : Path -> Bool
  Whether the path terminates with a separator.
  
.volume : Path -> Maybe Volume
  Windows path prefix (only for Windows).

  Hints:
  
Eq Path
  
Show Path
.volume : Path -> Maybe Volume
  Windows path prefix (only for Windows).

  Visibility: public export
volume : Path -> Maybe Volume
  Windows path prefix (only for Windows).

  Visibility: public export
.hasRoot : Path -> Bool
  Whether the path contains root.

  Visibility: public export
hasRoot : Path -> Bool
  Whether the path contains root.

  Visibility: public export
.body : Path -> List Body
  Path bodies.

  Visibility: public export
body : Path -> List Body
  Path bodies.

  Visibility: public export
.hasTrailSep : Path -> Bool
  Whether the path terminates with a separator.

  Visibility: public export
hasTrailSep : Path -> Bool
  Whether the path terminates with a separator.

  Visibility: public export
emptyPath : Path
  An empty path, which represents "".

  Visibility: public export
tryParse : String -> Maybe Path
  Visibility: export
parse : String -> Path
  Parses a String into Path.
  
  The string is parsed as much as possible from left to right, and the invalid
  parts on the right is ignored.
  
  Some kind of invalid paths are accepted. The relax rules:
  
  - Both slash('/') and backslash('\\') are parsed as valid directory separator,
    regardless of the platform;
  - Any characters in the body in allowed, e.g., glob like "/root/*";
  - Verbatim prefix(`\\?\`) that disables the forward slash is ignored (for
    Windows only).
  - Repeated separators are ignored, therefore, "a/b" and "a//b" both have "a"
    and "b" as bodies.
  - "." in the body are removed, unless they are at the beginning of the path.
    For example, "a/./b", "a/b/", "a/b/." and "a/b" will have "a" and "b" as
    bodies, and "./a/b" will starts with `CurDir`.
  
  ```idris example
  parse "C:\\Windows/System32"
  parse "/usr/local/etc/*"
  ```

  Visibility: export
splitFileName : String -> (String, String)
  Visibility: export
splitExtensions : String -> (String, List String)
  Split a file name into a basename and a list of extensions.
  A leading dot is considered to be part of the basename.
  ```
  splitExtensions "Path.idr"           = ("Path", ["idr"])
  splitExtensions "file.latex.lidr"    = ("file", ["latex", "lidr"])
  splitExtensions ".hidden.latex.lidr" = (".hidden", ["latex", "lidr"])
  ```

  Visibility: export
isAbsolute : String -> Bool
  Returns true if the path is absolute.
  
  - On Unix, a path is absolute if it starts with the root, so `isAbsolute` and
    `hasRoot` are equivalent.
  
  - On Windows, a path is absolute if it starts with a disk and has root or
    starts with UNC. For example, `c:\\windows` is absolute, while `c:temp`
    and `\temp` are not.

  Visibility: export
isRelative : String -> Bool
  Returns true if the path is relative.

  Visibility: export
(/>) : Path -> String -> Path
  Appends the right path to the left path.
  
  If the path on the right is absolute, it replaces the left path.
  
  On Windows:
  
  - If the right path has a root but no volume (e.g., `\windows`), it replaces
    everything except for the volume (if any) of left.
  - If the right path has a volume but no root, it replaces left.
  
  ```idris example
  parse "/usr" /> "local/etc" == "/usr/local/etc"
  ```

  Visibility: export
  Fixity Declaration: infixl operator, level 5
(</>) : String -> String -> String
  Appends the right path to the left path.
  
  If the path on the right is absolute, it replaces the left path.
  
  On Windows:
  
  - If the right path has a root but no volume (e.g., `\windows`), it replaces
    everything except for the volume (if any) of left.
  - If the right path has a volume but no root, it replaces left.
  
  ```idris example
  "/usr" </> "local/etc" == "/usr/local/etc"
  ```

  Visibility: export
  Fixity Declaration: infixl operator, level 5
joinPath : List String -> String
  Joins path components into one.
  
  ```idris example
  joinPath ["/usr", "local/etc"] == "/usr/local/etc"
  ```

  Visibility: export
splitPath : String -> List String
  Splits path into components.
  
  ```idris example
  splitPath "/usr/local/etc" == ["/", "usr", "local", "etc"]
  splitPath "tmp/Foo.idr" == ["tmp", "Foo.idr"]
  ```

  Visibility: export
splitParent : String -> Maybe (String, String)
  Splits the path into parent and child.
  
  ```idris example
  splitParent "/usr/local/etc" == Just ("/usr/local", "etc")
  ```

  Visibility: export
parent : String -> Maybe String
  Returns the path without its final component, if there is one.
  
  Returns Nothing if the path terminates by a root or volume.

  Visibility: export
parents : String -> List String
  Returns the list of all parents of the path, longest first, self included.
  
  ```idris example
  parents "/etc/kernel" == ["/etc/kernel", "/etc", "/"]
  ```

  Visibility: export
isBaseOf : String -> String -> Bool
  Determines whether the base is one of the parents of target.
  
  Trailing separator is ignored.
  
  ```idris example
  "/etc" `isBaseOf` "/etc/kernel"
  ```

  Visibility: export
dropBase : String -> String -> Maybe String
  Returns a path that, when appended to base, yields target.
  
  Returns Nothing if the base is not a prefix of the target.

  Visibility: export
fileName : String -> Maybe String
  Returns the last body of the path.
  
  If the last body is a file, this is the file name;
  if it's a directory, this is the directory name;
  if it's ".", it recurses on the previous body;
  if it's "..", returns Nothing.

  Visibility: export
fileStem : String -> Maybe String
  Extracts the file name in the path without extension.
  
  The stem is:
  
  - Nothing, if there is no file name;
  - The entire file name if there is no embedded ".";
  - The entire file name if the file name begins with a "." and has no other ".";
  - Otherwise, the portion of the file name before the last ".".

  Visibility: export
extension : String -> Maybe String
  Extracts the extension of the file name in the path.
  
  The extension is:
  
  - Nothing, if there is no file name;
  - Nothing, if there is no embedded ".";
  - Nothing, if the file name begins with a "." and has no other ".";
  - Otherwise, the portion of the file name after the last ".".

  Visibility: export
extensions : String -> Maybe (List String)
  Extracts the list of extensions of the file name in the path.
  The returned value is:
  
  - Nothing, if there is no file name;
  - Just [], if there is no embedded ".";
  - Just [], if the filename begins with a "." and has no other ".";
  - Just es, the portions between the "."s (excluding a potential leading one).

  Visibility: export
setFileName : String -> String -> String
  Updates the file name in the path.
  
  If there is no file name, it appends the name to the path;
  otherwise, it appends the name to the parent of the path.

  Visibility: export
(<.>) : String -> String -> String
  Appends a extension to the path.
  
  If there is no file name, the path will not change;
  if the path has no extension, the extension will be appended;
  if the given extension is empty, the extension of the path will be dropped;
  otherwise, the extension will be replaced.
  
  ```idris example
  "/tmp/Foo" <.> "idr" == "/tmp/Foo.idr"
  ```

  Visibility: export
  Fixity Declarations:
  infixl operator, level 7
infixr operator, level 7
dropExtension : String -> String
  Drops the extension of the path.

  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/System.Random.html b/contrib/docs/System.Random.html
index cb7401ef5a..9db64de8f6 100644
--- a/contrib/docs/System.Random.html
+++ b/contrib/docs/System.Random.html
@@ -61,4 +61,4 @@
 
 
 
-
System.Random(source)
Definitions
interface Random : Type -> Type
  Parameters: a
Methods:
  
randomIO : HasIO io => io a
  
randomRIO : HasIO io => (a, a) -> io a
  Takes a range (lo, hi), and returns a random value uniformly
  distributed in the closed interval [lo, hi]. It is unspecified what
  happens if lo > hi.

Implementations:
  
Random Int32
  
Random Double
randomIO : Random a => HasIO io => io a
  Visibility: public export
randomRIO : Random a => HasIO io => (a, a) -> io a
  Takes a range (lo, hi), and returns a random value uniformly
  distributed in the closed interval [lo, hi]. It is unspecified what
  happens if lo > hi.

  Visibility: public export
srand : Bits64 -> IO ()
  Sets the random seed

  Visibility: export
rndFin : HasIO io => (n : Nat) -> io (Fin (S n))
  Generate a random number in Fin (S `k`)
  
  Note that rndFin k takes values 0, 1, ..., k.

  Visibility: public export
rndSelect' : HasIO io => Vect (S k) a -> io a
  Select a random element from a vector

  Visibility: public export
rndSelect : HasIO io => (elems : List a) -> {auto 0 _ : NonEmpty elems} -> io a
  Select a random element from a non-empty list

  Visibility: public export

\ No newline at end of file
+
System.Random(source)
Definitions
interface Random : Type -> Type
  Parameters: a
Methods:
  
randomIO : HasIO io => io a
  
randomRIO : HasIO io => (a, a) -> io a
  Takes a range (lo, hi), and returns a random value uniformly
  distributed in the closed interval [lo, hi]. It is unspecified what
  happens if lo > hi.

Implementations:
  
Random Int32
  
Random Double
randomIO : Random a => HasIO io => io a
  Visibility: public export
randomRIO : Random a => HasIO io => (a, a) -> io a
  Takes a range (lo, hi), and returns a random value uniformly
  distributed in the closed interval [lo, hi]. It is unspecified what
  happens if lo > hi.

  Visibility: public export
srand : Bits64 -> IO ()
  Sets the random seed

  Visibility: export
rndFin : HasIO io => (n : Nat) -> io (Fin (S n))
  Generate a random number in Fin (S `k`)
  
  Note that rndFin k takes values 0, 1, ..., k.

  Visibility: public export
rndSelect' : HasIO io => Vect (S k) a -> io a
  Select a random element from a vector

  Visibility: public export
rndSelect : HasIO io => (elems : List a) -> {auto 0 _ : NonEmpty elems} -> io a
  Select a random element from a non-empty list

  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Text.Bounded.html b/contrib/docs/Text.Bounded.html
index 51ad1b7d03..9014b66e4f 100644
--- a/contrib/docs/Text.Bounded.html
+++ b/contrib/docs/Text.Bounded.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.Bounded(source)
Definitions
record Bounds : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkBounds : Int -> Int -> Int -> Int -> Bounds

  Projections:
  
.endCol : Bounds -> Int
  
.endLine : Bounds -> Int
  
.startCol : Bounds -> Int
  
.startLine : Bounds -> Int

  Hints:
  
Eq Bounds
  
Show Bounds
.startLine : Bounds -> Int
  Totality: total
  Visibility: public export
startLine : Bounds -> Int
  Totality: total
  Visibility: public export
.startCol : Bounds -> Int
  Totality: total
  Visibility: public export
startCol : Bounds -> Int
  Totality: total
  Visibility: public export
.endLine : Bounds -> Int
  Totality: total
  Visibility: public export
endLine : Bounds -> Int
  Totality: total
  Visibility: public export
.endCol : Bounds -> Int
  Totality: total
  Visibility: public export
endCol : Bounds -> Int
  Totality: total
  Visibility: public export
startBounds : Bounds -> (Int, Int)
  Totality: total
  Visibility: export
endBounds : Bounds -> (Int, Int)
  Totality: total
  Visibility: export
record WithBounds : Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkBounded : ty -> Bool -> Bounds -> WithBounds ty

  Projections:
  
.bounds : WithBounds ty -> Bounds
  
.isIrrelevant : WithBounds ty -> Bool
  
.val : WithBounds ty -> ty

  Hints:
  
Eq ty => Eq (WithBounds ty)
  
Foldable WithBounds
  
Functor WithBounds
  
Show ty => Show (WithBounds ty)
  
Traversable WithBounds
.val : WithBounds ty -> ty
  Totality: total
  Visibility: public export
val : WithBounds ty -> ty
  Totality: total
  Visibility: public export
.isIrrelevant : WithBounds ty -> Bool
  Totality: total
  Visibility: public export
isIrrelevant : WithBounds ty -> Bool
  Totality: total
  Visibility: public export
.bounds : WithBounds ty -> Bounds
  Totality: total
  Visibility: public export
bounds : WithBounds ty -> Bounds
  Totality: total
  Visibility: public export
start : WithBounds ty -> (Int, Int)
  Totality: total
  Visibility: export
end : WithBounds ty -> (Int, Int)
  Totality: total
  Visibility: export
irrelevantBounds : ty -> WithBounds ty
  Totality: total
  Visibility: export
removeIrrelevance : WithBounds ty -> WithBounds ty
  Totality: total
  Visibility: export
mergeBounds : WithBounds ty -> WithBounds ty' -> WithBounds ty'
  Totality: total
  Visibility: export
joinBounds : WithBounds (WithBounds ty) -> WithBounds ty
  Totality: total
  Visibility: export

\ No newline at end of file
+
Text.Bounded(source)
Definitions
record Bounds : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkBounds : Int -> Int -> Int -> Int -> Bounds

  Projections:
  
.endCol : Bounds -> Int
  
.endLine : Bounds -> Int
  
.startCol : Bounds -> Int
  
.startLine : Bounds -> Int

  Hints:
  
Eq Bounds
  
Show Bounds
.startLine : Bounds -> Int
  Totality: total
  Visibility: public export
startLine : Bounds -> Int
  Totality: total
  Visibility: public export
.startCol : Bounds -> Int
  Totality: total
  Visibility: public export
startCol : Bounds -> Int
  Totality: total
  Visibility: public export
.endLine : Bounds -> Int
  Totality: total
  Visibility: public export
endLine : Bounds -> Int
  Totality: total
  Visibility: public export
.endCol : Bounds -> Int
  Totality: total
  Visibility: public export
endCol : Bounds -> Int
  Totality: total
  Visibility: public export
startBounds : Bounds -> (Int, Int)
  Totality: total
  Visibility: export
endBounds : Bounds -> (Int, Int)
  Totality: total
  Visibility: export
record WithBounds : Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkBounded : ty -> Bool -> Bounds -> WithBounds ty

  Projections:
  
.bounds : WithBounds ty -> Bounds
  
.isIrrelevant : WithBounds ty -> Bool
  
.val : WithBounds ty -> ty

  Hints:
  
Eq ty => Eq (WithBounds ty)
  
Foldable WithBounds
  
Functor WithBounds
  
Show ty => Show (WithBounds ty)
  
Traversable WithBounds
.val : WithBounds ty -> ty
  Totality: total
  Visibility: public export
val : WithBounds ty -> ty
  Totality: total
  Visibility: public export
.isIrrelevant : WithBounds ty -> Bool
  Totality: total
  Visibility: public export
isIrrelevant : WithBounds ty -> Bool
  Totality: total
  Visibility: public export
.bounds : WithBounds ty -> Bounds
  Totality: total
  Visibility: public export
bounds : WithBounds ty -> Bounds
  Totality: total
  Visibility: public export
start : WithBounds ty -> (Int, Int)
  Totality: total
  Visibility: export
end : WithBounds ty -> (Int, Int)
  Totality: total
  Visibility: export
irrelevantBounds : ty -> WithBounds ty
  Totality: total
  Visibility: export
removeIrrelevance : WithBounds ty -> WithBounds ty
  Totality: total
  Visibility: export
mergeBounds : WithBounds ty -> WithBounds ty' -> WithBounds ty'
  Totality: total
  Visibility: export
joinBounds : WithBounds (WithBounds ty) -> WithBounds ty
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Text.Distance.Levenshtein.html b/contrib/docs/Text.Distance.Levenshtein.html
index 5af9894a40..fdc859a65f 100644
--- a/contrib/docs/Text.Distance.Levenshtein.html
+++ b/contrib/docs/Text.Distance.Levenshtein.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.Distance.Levenshtein(source)
Definitions
compute : HasIO io => String -> String -> io Nat
  Dynamic programming

  Totality: total
  Visibility: export

\ No newline at end of file
+
Text.Distance.Levenshtein(source)
Definitions
compute : HasIO io => String -> String -> io Nat
  Dynamic programming

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Text.Lexer.Core.html b/contrib/docs/Text.Lexer.Core.html
index 15a6fae7ef..3ab80af1c1 100644
--- a/contrib/docs/Text.Lexer.Core.html
+++ b/contrib/docs/Text.Lexer.Core.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.Lexer.Core(source)
Reexports
import public Control.Delayed
import public Text.Bounded
Definitions
data Recognise : Bool -> Type
  A language of token recognisers.
  @ consumes If `True`, this recogniser is guaranteed to consume at
             least one character of input when it succeeds.

  Totality: total
  Visibility: export
  Constructors:
  
Empty : Recognise False
  
Fail : Recognise c
  
Lookahead : Bool -> Recognise c -> Recognise False
  
Pred : (Char -> Bool) -> Recognise True
  
SeqEat : Recognise True -> Inf (Recognise e) -> Recognise True
  
SeqEmpty : Recognise e1 -> Recognise e2 -> Recognise (e1 || Delay e2)
  
SeqSame : Recognise e -> Recognise e -> Recognise e
  
Alt : Recognise e1 -> Recognise e2 -> Recognise (e1 && Delay e2)
Lexer : Type
  A token recogniser. Guaranteed to consume at least one character.

  Totality: total
  Visibility: public export
(<+>) : Recognise c1 -> inf c1 (Recognise c2) -> Recognise (c1 || Delay c2)
  Sequence two recognisers. If either consumes a character, the sequence
  is guaranteed to consume a character.

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 8
(<|>) : Recognise c1 -> Recognise c2 -> Recognise (c1 && Delay c2)
  Alternative recognisers. If both consume, the combination is guaranteed
  to consume a character.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 2
fail : Recognise c
  A recogniser that always fails.

  Totality: total
  Visibility: export
empty : Recognise False
  Recognise no input (doesn't consume any input)

  Totality: total
  Visibility: export
pred : (Char -> Bool) -> Lexer
  Recognise a character that matches a predicate

  Totality: total
  Visibility: export
expect : Recognise c -> Recognise False
  Positive lookahead. Never consumes input.

  Totality: total
  Visibility: export
reject : Recognise c -> Recognise False
  Negative lookahead. Never consumes input.

  Totality: total
  Visibility: export
concatMap : (a -> Recognise c) -> (xs : List a) -> Recognise (isCons xs && Delay c)
  Sequence the recognisers resulting from applying a function to each element
  of a list. The resulting recogniser will consume input if the produced
  recognisers consume and the list is non-empty.

  Totality: total
  Visibility: export
scan : Recognise c -> List Char -> List Char -> Maybe (List Char, List Char)
  Totality: total
  Visibility: export
TokenMap : Type -> Type
  A mapping from lexers to the tokens they produce.
  This is a list of pairs `(Lexer, String -> tokenType)`
  For each Lexer in the list, if a substring in the input matches, run
  the associated function to produce a token of type `tokenType`

  Totality: total
  Visibility: public export
lex : TokenMap a -> String -> (List (WithBounds a), (Int, (Int, String)))
  Given a mapping from lexers to token generating functions (the
  TokenMap a) and an input string, return a list of recognised tokens,
  and the line, column, and remainder of the input at the first point in the
  string where there are no recognised tokens.

  Totality: total
  Visibility: export
lexTo : (a -> Bool) -> TokenMap a -> String -> (List (WithBounds a), (Int, (Int, String)))
  Totality: total
  Visibility: export

\ No newline at end of file
+
Text.Lexer.Core(source)
Reexports
import public Control.Delayed
import public Text.Bounded
Definitions
data Recognise : Bool -> Type
  A language of token recognisers.
  @ consumes If `True`, this recogniser is guaranteed to consume at
             least one character of input when it succeeds.

  Totality: total
  Visibility: export
  Constructors:
  
Empty : Recognise False
  
Fail : Recognise c
  
Lookahead : Bool -> Recognise c -> Recognise False
  
Pred : (Char -> Bool) -> Recognise True
  
SeqEat : Recognise True -> Inf (Recognise e) -> Recognise True
  
SeqEmpty : Recognise e1 -> Recognise e2 -> Recognise (e1 || Delay e2)
  
SeqSame : Recognise e -> Recognise e -> Recognise e
  
Alt : Recognise e1 -> Recognise e2 -> Recognise (e1 && Delay e2)
Lexer : Type
  A token recogniser. Guaranteed to consume at least one character.

  Totality: total
  Visibility: public export
(<+>) : Recognise c1 -> inf c1 (Recognise c2) -> Recognise (c1 || Delay c2)
  Sequence two recognisers. If either consumes a character, the sequence
  is guaranteed to consume a character.

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 8
(<|>) : Recognise c1 -> Recognise c2 -> Recognise (c1 && Delay c2)
  Alternative recognisers. If both consume, the combination is guaranteed
  to consume a character.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 2
fail : Recognise c
  A recogniser that always fails.

  Totality: total
  Visibility: export
empty : Recognise False
  Recognise no input (doesn't consume any input)

  Totality: total
  Visibility: export
pred : (Char -> Bool) -> Lexer
  Recognise a character that matches a predicate

  Totality: total
  Visibility: export
expect : Recognise c -> Recognise False
  Positive lookahead. Never consumes input.

  Totality: total
  Visibility: export
reject : Recognise c -> Recognise False
  Negative lookahead. Never consumes input.

  Totality: total
  Visibility: export
concatMap : (a -> Recognise c) -> (xs : List a) -> Recognise (isCons xs && Delay c)
  Sequence the recognisers resulting from applying a function to each element
  of a list. The resulting recogniser will consume input if the produced
  recognisers consume and the list is non-empty.

  Totality: total
  Visibility: export
scan : Recognise c -> List Char -> List Char -> Maybe (List Char, List Char)
  Totality: total
  Visibility: export
TokenMap : Type -> Type
  A mapping from lexers to the tokens they produce.
  This is a list of pairs `(Lexer, String -> tokenType)`
  For each Lexer in the list, if a substring in the input matches, run
  the associated function to produce a token of type `tokenType`

  Totality: total
  Visibility: public export
lex : TokenMap a -> String -> (List (WithBounds a), (Int, (Int, String)))
  Given a mapping from lexers to token generating functions (the
  TokenMap a) and an input string, return a list of recognised tokens,
  and the line, column, and remainder of the input at the first point in the
  string where there are no recognised tokens.

  Totality: total
  Visibility: export
lexTo : (a -> Bool) -> TokenMap a -> String -> (List (WithBounds a), (Int, (Int, String)))
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Text.Lexer.Tokenizer.html b/contrib/docs/Text.Lexer.Tokenizer.html
index 1e9e6663ca..ca4bdec80b 100644
--- a/contrib/docs/Text.Lexer.Tokenizer.html
+++ b/contrib/docs/Text.Lexer.Tokenizer.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.Lexer.Tokenizer(source)
Reexports
import public Control.Delayed
import public Text.Bounded
Definitions
data Tokenizer : Type -> Type
  Description of a language's tokenization rule.

  Totality: total
  Visibility: export
  Constructors:
  
Match : Lexer -> (String -> tokenType) -> Tokenizer tokenType
  
Compose : Lexer -> (String -> tokenType) -> (String -> tag) -> Inf (tag -> Tokenizer tokenType) -> (tag -> Lexer) -> (String -> tokenType) -> Tokenizer tokenType
  
Alt : Tokenizer tokenType -> Lazy (Tokenizer tokenType) -> Tokenizer tokenType

  Hint: 
Functor Tokenizer
(<|>) : Tokenizer t -> Lazy (Tokenizer t) -> Tokenizer t
  Alternative tokenizer rules.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 2
match : Lexer -> (String -> a) -> Tokenizer a
  Match on a recogniser and cast the string to a token.

  Totality: total
  Visibility: export
compose : Lexer -> (String -> a) -> (String -> tag) -> Inf (tag -> Tokenizer a) -> (tag -> Lexer) -> (String -> a) -> Tokenizer a
  Compose other tokenizer. Language composition should be quoted between
  a begin lexer and a end lexer. The begin token can be used to generate
  the composition tokenizer and the end lexer.

  Totality: total
  Visibility: export
data StopReason : Type
  Stop reason why tokenizer can't make more progress.
  @ ComposeNotClosing carries the span of composition begin token in the
                      form of `(startLine, startCol), (endLine, endCol)`.

  Totality: total
  Visibility: public export
  Constructors:
  
EndInput : StopReason
  
NoRuleApply : StopReason
  
ComposeNotClosing : (Int, Int) -> (Int, Int) -> StopReason

  Hints:
  
Pretty StopReason
  
Show StopReason
lexTo : Lexer -> Tokenizer a -> String -> (List (WithBounds a), (StopReason, (Int, (Int, String))))
  Totality: total
  Visibility: export
lex : Tokenizer a -> String -> (List (WithBounds a), (StopReason, (Int, (Int, String))))
  Given a tokenizer and an input string, return a list of recognised tokens,
  and the line, column, and remainder of the input at the first point in the string
  where there are no recognised tokens.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Text.Lexer.Tokenizer(source)
Reexports
import public Control.Delayed
import public Text.Bounded
Definitions
data Tokenizer : Type -> Type
  Description of a language's tokenization rule.

  Totality: total
  Visibility: export
  Constructors:
  
Match : Lexer -> (String -> tokenType) -> Tokenizer tokenType
  
Compose : Lexer -> (String -> tokenType) -> (String -> tag) -> Inf (tag -> Tokenizer tokenType) -> (tag -> Lexer) -> (String -> tokenType) -> Tokenizer tokenType
  
Alt : Tokenizer tokenType -> Lazy (Tokenizer tokenType) -> Tokenizer tokenType

  Hint: 
Functor Tokenizer
(<|>) : Tokenizer t -> Lazy (Tokenizer t) -> Tokenizer t
  Alternative tokenizer rules.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 2
match : Lexer -> (String -> a) -> Tokenizer a
  Match on a recogniser and cast the string to a token.

  Totality: total
  Visibility: export
compose : Lexer -> (String -> a) -> (String -> tag) -> Inf (tag -> Tokenizer a) -> (tag -> Lexer) -> (String -> a) -> Tokenizer a
  Compose other tokenizer. Language composition should be quoted between
  a begin lexer and a end lexer. The begin token can be used to generate
  the composition tokenizer and the end lexer.

  Totality: total
  Visibility: export
data StopReason : Type
  Stop reason why tokenizer can't make more progress.
  @ ComposeNotClosing carries the span of composition begin token in the
                      form of `(startLine, startCol), (endLine, endCol)`.

  Totality: total
  Visibility: public export
  Constructors:
  
EndInput : StopReason
  
NoRuleApply : StopReason
  
ComposeNotClosing : (Int, Int) -> (Int, Int) -> StopReason

  Hints:
  
Pretty StopReason
  
Show StopReason
lexTo : Lexer -> Tokenizer a -> String -> (List (WithBounds a), (StopReason, (Int, (Int, String))))
  Totality: total
  Visibility: export
lex : Tokenizer a -> String -> (List (WithBounds a), (StopReason, (Int, (Int, String))))
  Given a tokenizer and an input string, return a list of recognised tokens,
  and the line, column, and remainder of the input at the first point in the string
  where there are no recognised tokens.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Text.Lexer.html b/contrib/docs/Text.Lexer.html
index aae08c4a97..2263d14439 100644
--- a/contrib/docs/Text.Lexer.html
+++ b/contrib/docs/Text.Lexer.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.Lexer(source)
Reexports
import public Text.Lexer.Core
import public Text.Quantity
import public Text.Token
Definitions
toTokenMap : List (Lexer, k) -> TokenMap (Token k)
  Totality: total
  Visibility: export
any : Lexer
  Recognise any character.
  /./

  Totality: total
  Visibility: export
opt : Lexer -> Recognise False
  Recognise a lexer or recognise no input. This is not guaranteed
  to consume input.
  /`l`?/

  Totality: total
  Visibility: export
non : Lexer -> Lexer
  Recognise any character if the sub-lexer `l` fails.
  /(?!`l`)./

  Totality: total
  Visibility: export
choiceMap : Foldable t => (a -> Recognise c) -> t a -> Recognise c
  Produce recognisers by applying a function to elements of a container, and
  recognise the first match. Consumes input if the function produces consuming
  recognisers. Fails if the container is empty.

  Totality: total
  Visibility: export
choice : Foldable t => t (Recognise c) -> Recognise c
  Recognise the first matching recogniser in a container. Consumes input if
  recognisers in the list consume. Fails if the container is empty.

  Totality: total
  Visibility: export
concat : (xs : List (Recognise c)) -> Recognise (isCons xs && Delay c)
  Sequence a list of recognisers. Guaranteed to consume input if the list is
  non-empty and the recognisers consume.

  Totality: total
  Visibility: export
is : Char -> Lexer
  Recognise a specific character.
  /[`x`]/

  Totality: total
  Visibility: export
isNot : Char -> Lexer
  Recognise anything but the given character.
  /[\^`x`]/

  Totality: total
  Visibility: export
like : Char -> Lexer
  Recognise a specific character (case-insensitive).
  /[`x`]/i

  Totality: total
  Visibility: export
notLike : Char -> Lexer
  Recognise anything but the given character (case-insensitive).
  /[\^`x`]/i

  Totality: total
  Visibility: export
exact : String -> Lexer
  Recognise a specific string.
  Fails if the string is empty.
  /`str`/

  Totality: total
  Visibility: export
approx : String -> Lexer
  Recognise a specific string (case-insensitive).
  Fails if the string is empty.
  /`str`/i

  Totality: total
  Visibility: export
oneOf : String -> Lexer
  Recognise any of the characters in the given string.
  /[`chars`]/

  Totality: total
  Visibility: export
range : Char -> Char -> Lexer
  Recognise a character range. Also works in reverse!
  /[`start`-`end`]/

  Totality: total
  Visibility: export
some : Lexer -> Lexer
  Recognise a sequence of at least one sub-lexers
  /`l`+/

  Totality: total
  Visibility: export
many : Lexer -> Recognise False
  Recognise a sequence of at zero or more sub-lexers. This is not
  guaranteed to consume input
  /`l`\*/

  Totality: total
  Visibility: export
someUntil : Recognise c -> Lexer -> Lexer
  Repeat the sub-lexer `l` one or more times until the lexer
  `stopBefore` is encountered. `stopBefore` will not be consumed.
  /((?!`stopBefore`)`l`)\+/

  Totality: total
  Visibility: export
manyUntil : Recognise c -> Lexer -> Recognise False
  Repeat the sub-lexer `l` zero or more times until the lexer
  `stopBefore` is encountered. `stopBefore` will not be consumed.
  Not guaranteed to consume input.
  /((?!`stopBefore`)`l`)\*/

  Totality: total
  Visibility: export
manyThen : Recognise c -> Lexer -> Recognise c
  Repeat the sub-lexer `l` zero or more times until the lexer
  `stopAfter` is encountered, and consume it. Guaranteed to
  consume if `stopAfter` consumes.
  /`l`\*?`stopAfter`/

  Totality: total
  Visibility: export
count : (q : Quantity) -> Lexer -> Recognise (isSucc (min q))
  Recognise a sub-lexer repeated as specified by `q`. Fails if `q` has
  `min` and `max` in the wrong order. Consumes input unless `min q` is zero.
  /`l`{`q`}/

  Totality: total
  Visibility: export
digit : Lexer
  Recognise a single digit 0-9
  /[0-9]/

  Totality: total
  Visibility: export
digits : Lexer
  Recognise one or more digits
  /[0-9]+/

  Totality: total
  Visibility: export
binDigit : Lexer
  Recognise a single binary digit
  /[0-1]/

  Totality: total
  Visibility: export
binDigits : Lexer
  Recognise one or more binary digits
  /[0-1]+/

  Totality: total
  Visibility: export
hexDigit : Lexer
  Recognise a single hexidecimal digit
  /[0-9A-Fa-f]/

  Totality: total
  Visibility: export
hexDigits : Lexer
  Recognise one or more hexidecimal digits
  /[0-9A-Fa-f]+/

  Totality: total
  Visibility: export
octDigit : Lexer
  Recognise a single octal digit
  /[0-8]/

  Totality: total
  Visibility: export
octDigits : Lexer
  Recognise one or more octal digits
  /[0-8]+/

  Totality: total
  Visibility: export
alpha : Lexer
  Recognise a single alpha character
  /[A-Za-z]/

  Totality: total
  Visibility: export
alphas : Lexer
  Recognise one or more alpha characters
  /[A-Za-z]+/

  Totality: total
  Visibility: export
lower : Lexer
  Recognise a lowercase alpha character
  /[a-z]/

  Totality: total
  Visibility: export
lowers : Lexer
  Recognise one or more lowercase alpha characters
  /[a-z]+/

  Totality: total
  Visibility: export
upper : Lexer
  Recognise an uppercase alpha character
  /[A-Z]/

  Totality: total
  Visibility: export
uppers : Lexer
  Recognise one or more uppercase alpha characters
  /[A-Z]+/

  Totality: total
  Visibility: export
alphaNum : Lexer
  Recognise an alphanumeric character
  /[A-Za-z0-9]/

  Totality: total
  Visibility: export
alphaNums : Lexer
  Recognise one or more alphanumeric characters
  /[A-Za-z0-9]+/

  Totality: total
  Visibility: export
space : Lexer
  Recognise a single whitespace character
  /\\s/

  Totality: total
  Visibility: export
spaces : Lexer
  Recognise one or more whitespace characters
  /\\s+/

  Totality: total
  Visibility: export
newline : Lexer
  Recognise a single newline sequence. Understands CRLF, CR, and LF
  /\\r\\n|[\\r\\n]/

  Totality: total
  Visibility: export
newlines : Lexer
  Recognise one or more newline sequences. Understands CRLF, CR, and LF
  /(\\r\\n|[\\r\\n])+)/

  Totality: total
  Visibility: export
symbol : Lexer
  Recognise a single non-whitespace, non-alphanumeric character
  /[\^\\sA-Za-z0-9]/

  Totality: total
  Visibility: export
symbols : Lexer
  Recognise one or more non-whitespace, non-alphanumeric characters
  /[\^\\sA-Za-z0-9]+/

  Totality: total
  Visibility: export
control : Lexer
  Totality: total
  Visibility: export
controls : Lexer
  Recognise one or more control characters
  /[\\x00-\\x1f\\x7f-\\x9f]+/

  Totality: total
  Visibility: export
surround : Lexer -> Lexer -> Lexer -> Lexer
  Recognise zero or more occurrences of a sub-lexer between
  delimiting lexers
  /`start`(`l`)\*?`end`/

  Totality: total
  Visibility: export
quote : Lexer -> Lexer -> Lexer
  Recognise zero or more occurrences of a sub-lexer surrounded
  by the same quote lexer on both sides (useful for strings)
  /`q`(`l`)\*?`q`/

  Totality: total
  Visibility: export
escape : Lexer -> Lexer -> Lexer
  Recognise an escape sub-lexer (often '\\') followed by
  another sub-lexer
  /[`esc`]`l`/

  Totality: total
  Visibility: export
stringLit : Lexer
  Recognise a string literal, including escaped characters.
  (Note: doesn't yet handle escape sequences such as \123)
  /"(\\\\.|.)\*?"/

  Totality: total
  Visibility: export
charLit : Lexer
  Recognise a character literal, including escaped characters.
  (Note: doesn't yet handle escape sequences such as \123)
  /'(\\\\.|[\^'])'/

  Totality: total
  Visibility: export
intLit : Lexer
  Recognise an integer literal (possibly with a '-' prefix)
  /-?[0-9]+/

  Totality: total
  Visibility: export
binLit : Lexer
  Recognise a binary literal, prefixed by "0b"
  /0b[0-1]+/

  Totality: total
  Visibility: export
hexLit : Lexer
  Recognise a hexidecimal literal, prefixed by "0x" or "0X"
  /0[Xx][0-9A-Fa-f]+/

  Totality: total
  Visibility: export
octLit : Lexer
  Recognise an octal literal, prefixed by "0o"
  /0o[0-9A-Fa-f]+/

  Totality: total
  Visibility: export
digitsUnderscoredLit : Lexer
  Totality: total
  Visibility: export
binUnderscoredLit : Lexer
  Totality: total
  Visibility: export
hexUnderscoredLit : Lexer
  Totality: total
  Visibility: export
octUnderscoredLit : Lexer
  Totality: total
  Visibility: export
lineComment : Lexer -> Lexer
  Recognise `start`, then recognise all input until a newline is encountered,
  and consume the newline. Will succeed if end-of-input is encountered before
  a newline.
  /`start`[\^\\r\\n]+(\\r\\n|[\\r\\n])?/

  Totality: total
  Visibility: export
blockComment : Lexer -> Lexer -> Lexer
  Recognise all input between `start` and `end` lexers.
  Supports balanced nesting.
  
  For block comments that don't support nesting (such as C-style comments),
  use `surround`

  Totality: total
  Visibility: export

\ No newline at end of file
+
Text.Lexer(source)
Reexports
import public Text.Lexer.Core
import public Text.Quantity
import public Text.Token
Definitions
toTokenMap : List (Lexer, k) -> TokenMap (Token k)
  Totality: total
  Visibility: export
any : Lexer
  Recognise any character.
  /./

  Totality: total
  Visibility: export
opt : Lexer -> Recognise False
  Recognise a lexer or recognise no input. This is not guaranteed
  to consume input.
  /`l`?/

  Totality: total
  Visibility: export
non : Lexer -> Lexer
  Recognise any character if the sub-lexer `l` fails.
  /(?!`l`)./

  Totality: total
  Visibility: export
choiceMap : Foldable t => (a -> Recognise c) -> t a -> Recognise c
  Produce recognisers by applying a function to elements of a container, and
  recognise the first match. Consumes input if the function produces consuming
  recognisers. Fails if the container is empty.

  Totality: total
  Visibility: export
choice : Foldable t => t (Recognise c) -> Recognise c
  Recognise the first matching recogniser in a container. Consumes input if
  recognisers in the list consume. Fails if the container is empty.

  Totality: total
  Visibility: export
concat : (xs : List (Recognise c)) -> Recognise (isCons xs && Delay c)
  Sequence a list of recognisers. Guaranteed to consume input if the list is
  non-empty and the recognisers consume.

  Totality: total
  Visibility: export
is : Char -> Lexer
  Recognise a specific character.
  /[`x`]/

  Totality: total
  Visibility: export
isNot : Char -> Lexer
  Recognise anything but the given character.
  /[\^`x`]/

  Totality: total
  Visibility: export
like : Char -> Lexer
  Recognise a specific character (case-insensitive).
  /[`x`]/i

  Totality: total
  Visibility: export
notLike : Char -> Lexer
  Recognise anything but the given character (case-insensitive).
  /[\^`x`]/i

  Totality: total
  Visibility: export
exact : String -> Lexer
  Recognise a specific string.
  Fails if the string is empty.
  /`str`/

  Totality: total
  Visibility: export
approx : String -> Lexer
  Recognise a specific string (case-insensitive).
  Fails if the string is empty.
  /`str`/i

  Totality: total
  Visibility: export
oneOf : String -> Lexer
  Recognise any of the characters in the given string.
  /[`chars`]/

  Totality: total
  Visibility: export
range : Char -> Char -> Lexer
  Recognise a character range. Also works in reverse!
  /[`start`-`end`]/

  Totality: total
  Visibility: export
some : Lexer -> Lexer
  Recognise a sequence of at least one sub-lexers
  /`l`+/

  Totality: total
  Visibility: export
many : Lexer -> Recognise False
  Recognise a sequence of at zero or more sub-lexers. This is not
  guaranteed to consume input
  /`l`\*/

  Totality: total
  Visibility: export
someUntil : Recognise c -> Lexer -> Lexer
  Repeat the sub-lexer `l` one or more times until the lexer
  `stopBefore` is encountered. `stopBefore` will not be consumed.
  /((?!`stopBefore`)`l`)\+/

  Totality: total
  Visibility: export
manyUntil : Recognise c -> Lexer -> Recognise False
  Repeat the sub-lexer `l` zero or more times until the lexer
  `stopBefore` is encountered. `stopBefore` will not be consumed.
  Not guaranteed to consume input.
  /((?!`stopBefore`)`l`)\*/

  Totality: total
  Visibility: export
manyThen : Recognise c -> Lexer -> Recognise c
  Repeat the sub-lexer `l` zero or more times until the lexer
  `stopAfter` is encountered, and consume it. Guaranteed to
  consume if `stopAfter` consumes.
  /`l`\*?`stopAfter`/

  Totality: total
  Visibility: export
count : (q : Quantity) -> Lexer -> Recognise (isSucc (min q))
  Recognise a sub-lexer repeated as specified by `q`. Fails if `q` has
  `min` and `max` in the wrong order. Consumes input unless `min q` is zero.
  /`l`{`q`}/

  Totality: total
  Visibility: export
digit : Lexer
  Recognise a single digit 0-9
  /[0-9]/

  Totality: total
  Visibility: export
digits : Lexer
  Recognise one or more digits
  /[0-9]+/

  Totality: total
  Visibility: export
binDigit : Lexer
  Recognise a single binary digit
  /[0-1]/

  Totality: total
  Visibility: export
binDigits : Lexer
  Recognise one or more binary digits
  /[0-1]+/

  Totality: total
  Visibility: export
hexDigit : Lexer
  Recognise a single hexidecimal digit
  /[0-9A-Fa-f]/

  Totality: total
  Visibility: export
hexDigits : Lexer
  Recognise one or more hexidecimal digits
  /[0-9A-Fa-f]+/

  Totality: total
  Visibility: export
octDigit : Lexer
  Recognise a single octal digit
  /[0-8]/

  Totality: total
  Visibility: export
octDigits : Lexer
  Recognise one or more octal digits
  /[0-8]+/

  Totality: total
  Visibility: export
alpha : Lexer
  Recognise a single alpha character
  /[A-Za-z]/

  Totality: total
  Visibility: export
alphas : Lexer
  Recognise one or more alpha characters
  /[A-Za-z]+/

  Totality: total
  Visibility: export
lower : Lexer
  Recognise a lowercase alpha character
  /[a-z]/

  Totality: total
  Visibility: export
lowers : Lexer
  Recognise one or more lowercase alpha characters
  /[a-z]+/

  Totality: total
  Visibility: export
upper : Lexer
  Recognise an uppercase alpha character
  /[A-Z]/

  Totality: total
  Visibility: export
uppers : Lexer
  Recognise one or more uppercase alpha characters
  /[A-Z]+/

  Totality: total
  Visibility: export
alphaNum : Lexer
  Recognise an alphanumeric character
  /[A-Za-z0-9]/

  Totality: total
  Visibility: export
alphaNums : Lexer
  Recognise one or more alphanumeric characters
  /[A-Za-z0-9]+/

  Totality: total
  Visibility: export
space : Lexer
  Recognise a single whitespace character
  /\\s/

  Totality: total
  Visibility: export
spaces : Lexer
  Recognise one or more whitespace characters
  /\\s+/

  Totality: total
  Visibility: export
newline : Lexer
  Recognise a single newline sequence. Understands CRLF, CR, and LF
  /\\r\\n|[\\r\\n]/

  Totality: total
  Visibility: export
newlines : Lexer
  Recognise one or more newline sequences. Understands CRLF, CR, and LF
  /(\\r\\n|[\\r\\n])+)/

  Totality: total
  Visibility: export
symbol : Lexer
  Recognise a single non-whitespace, non-alphanumeric character
  /[\^\\sA-Za-z0-9]/

  Totality: total
  Visibility: export
symbols : Lexer
  Recognise one or more non-whitespace, non-alphanumeric characters
  /[\^\\sA-Za-z0-9]+/

  Totality: total
  Visibility: export
control : Lexer
  Totality: total
  Visibility: export
controls : Lexer
  Recognise one or more control characters
  /[\\x00-\\x1f\\x7f-\\x9f]+/

  Totality: total
  Visibility: export
surround : Lexer -> Lexer -> Lexer -> Lexer
  Recognise zero or more occurrences of a sub-lexer between
  delimiting lexers
  /`start`(`l`)\*?`end`/

  Totality: total
  Visibility: export
quote : Lexer -> Lexer -> Lexer
  Recognise zero or more occurrences of a sub-lexer surrounded
  by the same quote lexer on both sides (useful for strings)
  /`q`(`l`)\*?`q`/

  Totality: total
  Visibility: export
escape : Lexer -> Lexer -> Lexer
  Recognise an escape sub-lexer (often '\\') followed by
  another sub-lexer
  /[`esc`]`l`/

  Totality: total
  Visibility: export
stringLit : Lexer
  Recognise a string literal, including escaped characters.
  (Note: doesn't yet handle escape sequences such as \123)
  /"(\\\\.|.)\*?"/

  Totality: total
  Visibility: export
charLit : Lexer
  Recognise a character literal, including escaped characters.
  (Note: doesn't yet handle escape sequences such as \123)
  /'(\\\\.|[\^'])'/

  Totality: total
  Visibility: export
intLit : Lexer
  Recognise an integer literal (possibly with a '-' prefix)
  /-?[0-9]+/

  Totality: total
  Visibility: export
binLit : Lexer
  Recognise a binary literal, prefixed by "0b"
  /0b[0-1]+/

  Totality: total
  Visibility: export
hexLit : Lexer
  Recognise a hexidecimal literal, prefixed by "0x" or "0X"
  /0[Xx][0-9A-Fa-f]+/

  Totality: total
  Visibility: export
octLit : Lexer
  Recognise an octal literal, prefixed by "0o"
  /0o[0-9A-Fa-f]+/

  Totality: total
  Visibility: export
digitsUnderscoredLit : Lexer
  Totality: total
  Visibility: export
binUnderscoredLit : Lexer
  Totality: total
  Visibility: export
hexUnderscoredLit : Lexer
  Totality: total
  Visibility: export
octUnderscoredLit : Lexer
  Totality: total
  Visibility: export
lineComment : Lexer -> Lexer
  Recognise `start`, then recognise all input until a newline is encountered,
  and consume the newline. Will succeed if end-of-input is encountered before
  a newline.
  /`start`[\^\\r\\n]+(\\r\\n|[\\r\\n])?/

  Totality: total
  Visibility: export
blockComment : Lexer -> Lexer -> Lexer
  Recognise all input between `start` and `end` lexers.
  Supports balanced nesting.
  
  For block comments that don't support nesting (such as C-style comments),
  use `surround`

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Text.Literate.html b/contrib/docs/Text.Literate.html
index f0022ec0c8..260b2992ee 100644
--- a/contrib/docs/Text.Literate.html
+++ b/contrib/docs/Text.Literate.html
@@ -84,4 +84,4 @@
 the markers within the document's main text: This will confuse the
 lexer.
 
-
Definitions
lines : String -> List1 String
  Totality: total
  Visibility: export
record LiterateError : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkLitErr : Int -> Int -> String -> LiterateError

  Projections:
  
.column : LiterateError -> Int
  
.input : LiterateError -> String
  
.line : LiterateError -> Int
.line : LiterateError -> Int
  Totality: total
  Visibility: public export
line : LiterateError -> Int
  Totality: total
  Visibility: public export
.column : LiterateError -> Int
  Totality: total
  Visibility: public export
column : LiterateError -> Int
  Totality: total
  Visibility: public export
.input : LiterateError -> String
  Totality: total
  Visibility: public export
input : LiterateError -> String
  Totality: total
  Visibility: public export
record LiterateStyle : Type
  Description of literate styles.
  
  A 'literate' style comprises of
  
  + a list of code block deliminators (`deliminators`);
  + a list of code line markers (`line_markers`); and
  + a list of known file extensions `file_extensions`.
  
  Some example specifications:
  
  + Bird Style
  
  ```
  MkLitStyle Nil [">"] [".lidr"]
  ```
  
  + Literate Haskell (for LaTeX)
  
  ```
  MkLitStyle [("\\begin{code}", "\\end{code}"),("\\begin{spec}","\\end{spec}")]
            Nil
            [".lhs", ".tex"]
  ```
  
  + OrgMode
  
  ```
  MkLitStyle [("#+BEGIN_SRC idris","#+END_SRC"), ("#+COMMENT idris","#+END_COMMENT")]
            ["#+IDRIS:"]
            [".org"]
  ```
  
  + Common Mark
  
  ```
  MkLitStyle [("```idris","```"), ("<!-- idris","--!>")]
            Nil
            [".md", ".markdown"]
  ```
  

  Totality: total
  Visibility: public export
  Constructor: 
MkLitStyle : List (String, String) -> List String -> List String -> LiterateStyle

  Projections:
  
.deliminators : LiterateStyle -> List (String, String)
  The pairs of start and end tags for code blocks.
  
.file_extensions : LiterateStyle -> List String
  Recognised file extensions. Not used by the module, but will be
  of use when connecting to code that reads in the original source
  files.
  
.line_markers : LiterateStyle -> List String
  Line markers that indicate a line contains code.
.deliminators : LiterateStyle -> List (String, String)
  The pairs of start and end tags for code blocks.

  Totality: total
  Visibility: public export
deliminators : LiterateStyle -> List (String, String)
  The pairs of start and end tags for code blocks.

  Totality: total
  Visibility: public export
.line_markers : LiterateStyle -> List String
  Line markers that indicate a line contains code.

  Totality: total
  Visibility: public export
line_markers : LiterateStyle -> List String
  Line markers that indicate a line contains code.

  Totality: total
  Visibility: public export
.file_extensions : LiterateStyle -> List String
  Recognised file extensions. Not used by the module, but will be
  of use when connecting to code that reads in the original source
  files.

  Totality: total
  Visibility: public export
file_extensions : LiterateStyle -> List String
  Recognised file extensions. Not used by the module, but will be
  of use when connecting to code that reads in the original source
  files.

  Totality: total
  Visibility: public export
extractCode : LiterateStyle -> String -> Either LiterateError String
  Given a 'literate specification' extract the code from the
  literate source file (`litStr`) that follows the presented style.
  
  @specification The literate specification to use.
  @litStr  The literate source file.
  
  Returns a `LiterateError` if the literate file contains malformed
  code blocks or code lines.
  

  Totality: total
  Visibility: export
unlit : LiterateStyle -> String -> Either LiterateError String
  Synonym for `extractCode`.

  Totality: total
  Visibility: export
isLiterateLine : LiterateStyle -> String -> (Maybe String, String)
  Is the provided line marked up using a line marker?
  
  If the line is suffixed by any one of the style's set of line
  markers then return length of literate line marker, and the code stripped from the line
  marker. Otherwise, return Nothing and the unmarked line.

  Totality: total
  Visibility: export
embedCode : LiterateStyle -> String -> String
  Given a 'literate specification' embed the given code using the
  literate style provided.
  
  If the style uses deliminators to denote code blocks use the first
  pair of deliminators in the style. Otherwise use first linemarker
  in the style. If there is **no style** return the presented code
  string unembedded.
  
  
  @specification The literate specification to use.
  @code  The code to embed,
  
  

  Totality: total
  Visibility: export
relit : LiterateStyle -> String -> String
  Synonm for `embedCode`

  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
lines : String -> List1 String
  Totality: total
  Visibility: export
record LiterateError : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkLitErr : Int -> Int -> String -> LiterateError

  Projections:
  
.column : LiterateError -> Int
  
.input : LiterateError -> String
  
.line : LiterateError -> Int
.line : LiterateError -> Int
  Totality: total
  Visibility: public export
line : LiterateError -> Int
  Totality: total
  Visibility: public export
.column : LiterateError -> Int
  Totality: total
  Visibility: public export
column : LiterateError -> Int
  Totality: total
  Visibility: public export
.input : LiterateError -> String
  Totality: total
  Visibility: public export
input : LiterateError -> String
  Totality: total
  Visibility: public export
record LiterateStyle : Type
  Description of literate styles.
  
  A 'literate' style comprises of
  
  + a list of code block deliminators (`deliminators`);
  + a list of code line markers (`line_markers`); and
  + a list of known file extensions `file_extensions`.
  
  Some example specifications:
  
  + Bird Style
  
  ```
  MkLitStyle Nil [">"] [".lidr"]
  ```
  
  + Literate Haskell (for LaTeX)
  
  ```
  MkLitStyle [("\\begin{code}", "\\end{code}"),("\\begin{spec}","\\end{spec}")]
            Nil
            [".lhs", ".tex"]
  ```
  
  + OrgMode
  
  ```
  MkLitStyle [("#+BEGIN_SRC idris","#+END_SRC"), ("#+COMMENT idris","#+END_COMMENT")]
            ["#+IDRIS:"]
            [".org"]
  ```
  
  + Common Mark
  
  ```
  MkLitStyle [("```idris","```"), ("<!-- idris","--!>")]
            Nil
            [".md", ".markdown"]
  ```
  

  Totality: total
  Visibility: public export
  Constructor: 
MkLitStyle : List (String, String) -> List String -> List String -> LiterateStyle

  Projections:
  
.deliminators : LiterateStyle -> List (String, String)
  The pairs of start and end tags for code blocks.
  
.file_extensions : LiterateStyle -> List String
  Recognised file extensions. Not used by the module, but will be
  of use when connecting to code that reads in the original source
  files.
  
.line_markers : LiterateStyle -> List String
  Line markers that indicate a line contains code.
.deliminators : LiterateStyle -> List (String, String)
  The pairs of start and end tags for code blocks.

  Totality: total
  Visibility: public export
deliminators : LiterateStyle -> List (String, String)
  The pairs of start and end tags for code blocks.

  Totality: total
  Visibility: public export
.line_markers : LiterateStyle -> List String
  Line markers that indicate a line contains code.

  Totality: total
  Visibility: public export
line_markers : LiterateStyle -> List String
  Line markers that indicate a line contains code.

  Totality: total
  Visibility: public export
.file_extensions : LiterateStyle -> List String
  Recognised file extensions. Not used by the module, but will be
  of use when connecting to code that reads in the original source
  files.

  Totality: total
  Visibility: public export
file_extensions : LiterateStyle -> List String
  Recognised file extensions. Not used by the module, but will be
  of use when connecting to code that reads in the original source
  files.

  Totality: total
  Visibility: public export
extractCode : LiterateStyle -> String -> Either LiterateError String
  Given a 'literate specification' extract the code from the
  literate source file (`litStr`) that follows the presented style.
  
  @specification The literate specification to use.
  @litStr  The literate source file.
  
  Returns a `LiterateError` if the literate file contains malformed
  code blocks or code lines.
  

  Totality: total
  Visibility: export
unlit : LiterateStyle -> String -> Either LiterateError String
  Synonym for `extractCode`.

  Totality: total
  Visibility: export
isLiterateLine : LiterateStyle -> String -> (Maybe String, String)
  Is the provided line marked up using a line marker?
  
  If the line is suffixed by any one of the style's set of line
  markers then return length of literate line marker, and the code stripped from the line
  marker. Otherwise, return Nothing and the unmarked line.

  Totality: total
  Visibility: export
embedCode : LiterateStyle -> String -> String
  Given a 'literate specification' embed the given code using the
  literate style provided.
  
  If the style uses deliminators to denote code blocks use the first
  pair of deliminators in the style. Otherwise use first linemarker
  in the style. If there is **no style** return the presented code
  string unembedded.
  
  
  @specification The literate specification to use.
  @code  The code to embed,
  
  

  Totality: total
  Visibility: export
relit : LiterateStyle -> String -> String
  Synonm for `embedCode`

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Text.Parser.Core.html b/contrib/docs/Text.Parser.Core.html
index c36aae3c01..3d99213cf3 100644
--- a/contrib/docs/Text.Parser.Core.html
+++ b/contrib/docs/Text.Parser.Core.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.Parser.Core(source)
Reexports
import public Control.Delayed
import public Text.Bounded
Definitions
data Grammar : Type -> Type -> Bool -> Type -> Type
  Description of a language's grammar. The `tok` parameter is the type
  of tokens, and the `consumes` flag is True if the language is guaranteed
  to be non-empty - that is, successfully parsing the language is guaranteed
  to consume some input.

  Totality: total
  Visibility: export
  Constructors:
  
Empty : ty -> Grammar state tok False ty
  
Terminal : String -> (tok -> Maybe a) -> Grammar state tok True a
  
NextIs : String -> (tok -> Bool) -> Grammar state tok False tok
  
EOF : Grammar state tok False ()
  
Fail : Maybe Bounds -> Bool -> String -> Grammar state tok c ty
  
Try : Grammar state tok c ty -> Grammar state tok c ty
  
Commit : Grammar state tok False ()
  
MustWork : Grammar state tok c a -> Grammar state tok c a
  
SeqEat : Grammar state tok True a -> Inf (a -> Grammar state tok c2 b) -> Grammar state tok True b
  
SeqEmpty : Grammar state tok c1 a -> (a -> Grammar state tok c2 b) -> Grammar state tok (c1 || Delay c2) b
  
ThenEat : Grammar state tok True () -> Inf (Grammar state tok c2 a) -> Grammar state tok True a
  
ThenEmpty : Grammar state tok c1 () -> Grammar state tok c2 a -> Grammar state tok (c1 || Delay c2) a
  
Alt : Grammar state tok c1 ty -> Lazy (Grammar state tok c2 ty) -> Grammar state tok (c1 && Delay c2) ty
  
Bounds : Grammar state tok c ty -> Grammar state tok c (WithBounds ty)
  
Position : Grammar state tok False Bounds
  
Act : state -> Grammar state tok False ()

  Hint: 
Functor (Grammar state tok c)
(>>=) : Grammar state tok c1 a -> inf c1 (a -> Grammar state tok c2 b) -> Grammar state tok (c1 || Delay c2) b
  Sequence two grammars. If either consumes some input, the sequence is
  guaranteed to consume some input. If the first one consumes input, the
  second is allowed to be recursive (because it means some input has been
  consumed and therefore the input is smaller)

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 1
(>>) : Grammar state tok c1 () -> inf c1 (Grammar state tok c2 a) -> Grammar state tok (c1 || Delay c2) a
  Sequence two grammars. If either consumes some input, the sequence is
  guaranteed to consume some input. If the first one consumes input, the
  second is allowed to be recursive (because it means some input has been
  consumed and therefore the input is smaller)

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
seq : Grammar state tok c1 a -> (a -> Grammar state tok c2 b) -> Grammar state tok (c1 || Delay c2) b
  Sequence two grammars. If either consumes some input, the sequence is
  guaranteed to consume input. This is an explicitly non-infinite version
  of `>>=`.

  Totality: total
  Visibility: export
join : Grammar state tok c1 (Grammar state tok c2 a) -> Grammar state tok (c1 || Delay c2) a
  Sequence a grammar followed by the grammar it returns.

  Totality: total
  Visibility: export
(<|>) : Grammar state tok c1 ty -> Lazy (Grammar state tok c2 ty) -> Grammar state tok (c1 && Delay c2) ty
  Give two alternative grammars. If both consume, the combination is
  guaranteed to consume.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 2
(<||>) : Grammar state tok c1 a -> Lazy (Grammar state tok c2 b) -> Grammar state tok (c1 && Delay c2) (Either a b)
  Take the tagged disjunction of two grammars. If both consume, the
  combination is guaranteed to consume.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 2
(<*>) : Grammar state tok c1 (a -> b) -> Grammar state tok c2 a -> Grammar state tok (c1 || Delay c2) b
  Sequence a grammar with value type `a -> b` and a grammar
  with value type `a`. If both succeed, apply the function
  from the first grammar to the value from the second grammar.
  Guaranteed to consume if either grammar consumes.

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 3
(<*) : Grammar state tok c1 a -> Grammar state tok c2 b -> Grammar state tok (c1 || Delay c2) a
  Sequence two grammars. If both succeed, use the value of the first one.
  Guaranteed to consume if either grammar consumes.

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 3
(*>) : Grammar state tok c1 a -> Grammar state tok c2 b -> Grammar state tok (c1 || Delay c2) b
  Sequence two grammars. If both succeed, use the value of the second one.
  Guaranteed to consume if either grammar consumes.

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 3
act : state -> Grammar state tok False ()
  Totality: total
  Visibility: export
mapToken : (a -> b) -> Grammar state b c ty -> Grammar state a c ty
  Produce a grammar that can parse a different type of token by providing a
  function converting the new token type into the original one.

  Totality: total
  Visibility: export
pure : ty -> Grammar state tok False ty
  Always succeed with the given value.

  Totality: total
  Visibility: export
nextIs : String -> (tok -> Bool) -> Grammar state tok False tok
  Check whether the next token satisfies a predicate

  Totality: total
  Visibility: export
peek : Grammar state tok False tok
  Look at the next token in the input

  Totality: total
  Visibility: export
terminal : String -> (tok -> Maybe a) -> Grammar state tok True a
  Succeeds if running the predicate on the next token returns Just x,
  returning x. Otherwise fails.

  Totality: total
  Visibility: export
fail : String -> Grammar state tok c ty
  Always fail with a message

  Totality: total
  Visibility: export
failLoc : Bounds -> String -> Grammar state tok c ty
  Always fail with a message and a location

  Totality: total
  Visibility: export
fatalError : String -> Grammar state tok c ty
  Fail with no possibility for recovery (i.e.
  no alternative parsing can succeed).

  Totality: total
  Visibility: export
fatalLoc : Bounds -> String -> Grammar state tok c ty
  Fail with no possibility for recovery (i.e.
  no alternative parsing can succeed).

  Totality: total
  Visibility: export
try : Grammar state tok c ty -> Grammar state tok c ty
  Catch a fatal error

  Totality: total
  Visibility: export
eof : Grammar state tok False ()
  Succeed if the input is empty

  Totality: total
  Visibility: export
commit : Grammar state tok False ()
  Commit to an alternative; if the current branch of an alternative
  fails to parse, no more branches will be tried

  Totality: total
  Visibility: export
mustWork : Grammar state tok c ty -> Grammar state tok c ty
  If the parser fails, treat it as a fatal error

  Totality: total
  Visibility: export
bounds : Grammar state tok c ty -> Grammar state tok c (WithBounds ty)
  Totality: total
  Visibility: export
position : Grammar state tok False Bounds
  Totality: total
  Visibility: export
data ParsingError : Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
Error : String -> Maybe Bounds -> ParsingError tok

  Hint: 
Show tok => Show (ParsingError tok)
parse : Grammar () tok c ty -> List (WithBounds tok) -> Either (List1 (ParsingError tok)) (ty, List (WithBounds tok))
  Parse a list of tokens according to the given grammar. If successful,
  returns a pair of the parse result and the unparsed tokens (the remaining
  input).

  Totality: total
  Visibility: export
parseWith : Monoid state => Grammar state tok c ty -> List (WithBounds tok) -> Either (List1 (ParsingError tok)) (state, (ty, List (WithBounds tok)))
  Totality: total
  Visibility: export

\ No newline at end of file
+
Text.Parser.Core(source)
Reexports
import public Control.Delayed
import public Text.Bounded
Definitions
data Grammar : Type -> Type -> Bool -> Type -> Type
  Description of a language's grammar. The `tok` parameter is the type
  of tokens, and the `consumes` flag is True if the language is guaranteed
  to be non-empty - that is, successfully parsing the language is guaranteed
  to consume some input.

  Totality: total
  Visibility: export
  Constructors:
  
Empty : ty -> Grammar state tok False ty
  
Terminal : String -> (tok -> Maybe a) -> Grammar state tok True a
  
NextIs : String -> (tok -> Bool) -> Grammar state tok False tok
  
EOF : Grammar state tok False ()
  
Fail : Maybe Bounds -> Bool -> String -> Grammar state tok c ty
  
Try : Grammar state tok c ty -> Grammar state tok c ty
  
Commit : Grammar state tok False ()
  
MustWork : Grammar state tok c a -> Grammar state tok c a
  
SeqEat : Grammar state tok True a -> Inf (a -> Grammar state tok c2 b) -> Grammar state tok True b
  
SeqEmpty : Grammar state tok c1 a -> (a -> Grammar state tok c2 b) -> Grammar state tok (c1 || Delay c2) b
  
ThenEat : Grammar state tok True () -> Inf (Grammar state tok c2 a) -> Grammar state tok True a
  
ThenEmpty : Grammar state tok c1 () -> Grammar state tok c2 a -> Grammar state tok (c1 || Delay c2) a
  
Alt : Grammar state tok c1 ty -> Lazy (Grammar state tok c2 ty) -> Grammar state tok (c1 && Delay c2) ty
  
Bounds : Grammar state tok c ty -> Grammar state tok c (WithBounds ty)
  
Position : Grammar state tok False Bounds
  
Act : state -> Grammar state tok False ()

  Hint: 
Functor (Grammar state tok c)
(>>=) : Grammar state tok c1 a -> inf c1 (a -> Grammar state tok c2 b) -> Grammar state tok (c1 || Delay c2) b
  Sequence two grammars. If either consumes some input, the sequence is
  guaranteed to consume some input. If the first one consumes input, the
  second is allowed to be recursive (because it means some input has been
  consumed and therefore the input is smaller)

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 1
(>>) : Grammar state tok c1 () -> inf c1 (Grammar state tok c2 a) -> Grammar state tok (c1 || Delay c2) a
  Sequence two grammars. If either consumes some input, the sequence is
  guaranteed to consume some input. If the first one consumes input, the
  second is allowed to be recursive (because it means some input has been
  consumed and therefore the input is smaller)

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
seq : Grammar state tok c1 a -> (a -> Grammar state tok c2 b) -> Grammar state tok (c1 || Delay c2) b
  Sequence two grammars. If either consumes some input, the sequence is
  guaranteed to consume input. This is an explicitly non-infinite version
  of `>>=`.

  Totality: total
  Visibility: export
join : Grammar state tok c1 (Grammar state tok c2 a) -> Grammar state tok (c1 || Delay c2) a
  Sequence a grammar followed by the grammar it returns.

  Totality: total
  Visibility: export
(<|>) : Grammar state tok c1 ty -> Lazy (Grammar state tok c2 ty) -> Grammar state tok (c1 && Delay c2) ty
  Give two alternative grammars. If both consume, the combination is
  guaranteed to consume.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 2
(<||>) : Grammar state tok c1 a -> Lazy (Grammar state tok c2 b) -> Grammar state tok (c1 && Delay c2) (Either a b)
  Take the tagged disjunction of two grammars. If both consume, the
  combination is guaranteed to consume.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 2
(<*>) : Grammar state tok c1 (a -> b) -> Grammar state tok c2 a -> Grammar state tok (c1 || Delay c2) b
  Sequence a grammar with value type `a -> b` and a grammar
  with value type `a`. If both succeed, apply the function
  from the first grammar to the value from the second grammar.
  Guaranteed to consume if either grammar consumes.

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 3
(<*) : Grammar state tok c1 a -> Grammar state tok c2 b -> Grammar state tok (c1 || Delay c2) a
  Sequence two grammars. If both succeed, use the value of the first one.
  Guaranteed to consume if either grammar consumes.

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 3
(*>) : Grammar state tok c1 a -> Grammar state tok c2 b -> Grammar state tok (c1 || Delay c2) b
  Sequence two grammars. If both succeed, use the value of the second one.
  Guaranteed to consume if either grammar consumes.

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 3
act : state -> Grammar state tok False ()
  Totality: total
  Visibility: export
mapToken : (a -> b) -> Grammar state b c ty -> Grammar state a c ty
  Produce a grammar that can parse a different type of token by providing a
  function converting the new token type into the original one.

  Totality: total
  Visibility: export
pure : ty -> Grammar state tok False ty
  Always succeed with the given value.

  Totality: total
  Visibility: export
nextIs : String -> (tok -> Bool) -> Grammar state tok False tok
  Check whether the next token satisfies a predicate

  Totality: total
  Visibility: export
peek : Grammar state tok False tok
  Look at the next token in the input

  Totality: total
  Visibility: export
terminal : String -> (tok -> Maybe a) -> Grammar state tok True a
  Succeeds if running the predicate on the next token returns Just x,
  returning x. Otherwise fails.

  Totality: total
  Visibility: export
fail : String -> Grammar state tok c ty
  Always fail with a message

  Totality: total
  Visibility: export
failLoc : Bounds -> String -> Grammar state tok c ty
  Always fail with a message and a location

  Totality: total
  Visibility: export
fatalError : String -> Grammar state tok c ty
  Fail with no possibility for recovery (i.e.
  no alternative parsing can succeed).

  Totality: total
  Visibility: export
fatalLoc : Bounds -> String -> Grammar state tok c ty
  Fail with no possibility for recovery (i.e.
  no alternative parsing can succeed).

  Totality: total
  Visibility: export
try : Grammar state tok c ty -> Grammar state tok c ty
  Catch a fatal error

  Totality: total
  Visibility: export
eof : Grammar state tok False ()
  Succeed if the input is empty

  Totality: total
  Visibility: export
commit : Grammar state tok False ()
  Commit to an alternative; if the current branch of an alternative
  fails to parse, no more branches will be tried

  Totality: total
  Visibility: export
mustWork : Grammar state tok c ty -> Grammar state tok c ty
  If the parser fails, treat it as a fatal error

  Totality: total
  Visibility: export
bounds : Grammar state tok c ty -> Grammar state tok c (WithBounds ty)
  Totality: total
  Visibility: export
position : Grammar state tok False Bounds
  Totality: total
  Visibility: export
data ParsingError : Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
Error : String -> Maybe Bounds -> ParsingError tok

  Hint: 
Show tok => Show (ParsingError tok)
parse : Grammar () tok c ty -> List (WithBounds tok) -> Either (List1 (ParsingError tok)) (ty, List (WithBounds tok))
  Parse a list of tokens according to the given grammar. If successful,
  returns a pair of the parse result and the unparsed tokens (the remaining
  input).

  Totality: total
  Visibility: export
parseWith : Monoid state => Grammar state tok c ty -> List (WithBounds tok) -> Either (List1 (ParsingError tok)) (state, (ty, List (WithBounds tok)))
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Text.Parser.Expression.html b/contrib/docs/Text.Parser.Expression.html
index bc8c4f043e..2af5223e7b 100644
--- a/contrib/docs/Text.Parser.Expression.html
+++ b/contrib/docs/Text.Parser.Expression.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.Parser.Expression(source)
Definitions
data Assoc : Type
  Totality: total
  Visibility: public export
  Constructors:
  
AssocNone : Assoc
  
AssocLeft : Assoc
  
AssocRight : Assoc
data Op : Type -> Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Prefix : Grammar state k True (a -> a) -> Op state k a
  
Postfix : Grammar state k True (a -> a) -> Op state k a
  
Infix : Grammar state k True (a -> a -> a) -> Assoc -> Op state k a
OperatorTable : Type -> Type -> Type -> Type
  Visibility: public export
buildExpressionParser : OperatorTable state k a -> Grammar state k True a -> Grammar state k True a
  Visibility: export

\ No newline at end of file
+
Text.Parser.Expression(source)
Definitions
data Assoc : Type
  Totality: total
  Visibility: public export
  Constructors:
  
AssocNone : Assoc
  
AssocLeft : Assoc
  
AssocRight : Assoc
data Op : Type -> Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Prefix : Grammar state k True (a -> a) -> Op state k a
  
Postfix : Grammar state k True (a -> a) -> Op state k a
  
Infix : Grammar state k True (a -> a -> a) -> Assoc -> Op state k a
OperatorTable : Type -> Type -> Type -> Type
  Visibility: public export
buildExpressionParser : OperatorTable state k a -> Grammar state k True a -> Grammar state k True a
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Text.Parser.html b/contrib/docs/Text.Parser.html
index f1be38ec57..2db4f2007a 100644
--- a/contrib/docs/Text.Parser.html
+++ b/contrib/docs/Text.Parser.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.Parser(source)
Reexports
import public Data.List1
import public Text.Parser.Core
import public Text.Quantity
import public Text.Token
Definitions
match : {auto {conArg:983} : TokenKind k} -> Eq k => (kind : k) -> Grammar state (Token k) True (TokType kind)
  Parse a terminal based on a kind of token.

  Totality: total
  Visibility: export
option : a -> Grammar state tok c a -> Grammar state tok False a
  Optionally parse a thing, with a default value if the grammar doesn't
  match. May match the empty input.

  Totality: total
  Visibility: export
optional : Grammar state tok c a -> Grammar state tok False (Maybe a)
  Optionally parse a thing.
  To provide a default value, use `option` instead.

  Totality: total
  Visibility: export
choose : Grammar state tok c1 a -> Grammar state tok c2 b -> Grammar state tok (c1 && Delay c2) (Either a b)
  Try to parse one thing or the other, producing a value that indicates
  which option succeeded. If both would succeed, the left option
  takes priority.

  Totality: total
  Visibility: export
choiceMap : (a -> Grammar state tok c b) -> Foldable t => t a -> Grammar state tok c b
  Produce a grammar by applying a function to each element of a container,
  then try each resulting grammar until the first one succeeds. Fails if the
  container is empty.

  Totality: total
  Visibility: export
choice : Foldable t => t (Grammar state tok c a) -> Grammar state tok c a
  Try each grammar in a container until the first one succeeds.
  Fails if the container is empty.

  Totality: total
  Visibility: export
some : Grammar state tok True a -> Grammar state tok True (List1 a)
  Parse one or more things

  Totality: total
  Visibility: export
many : Grammar state tok True a -> Grammar state tok False (List a)
  Parse zero or more things (may match the empty input)

  Totality: total
  Visibility: export
count : (q : Quantity) -> Grammar state tok True a -> Grammar state tok (isSucc (min q)) (List a)
  Parse `p`, repeated as specified by `q`, returning the list of values.

  Totality: total
  Visibility: export
someTill : Grammar state tok c e -> Grammar state tok True a -> Grammar state tok True (List1 a)
  Parse one or more instances of `p` until `end` succeeds, returning the
  list of values from `p`. Guaranteed to consume input.

  Totality: total
  Visibility: export
manyTill : Grammar state tok c e -> Grammar state tok True a -> Grammar state tok c (List a)
  Parse zero or more instances of `p` until `end` succeeds, returning the
  list of values from `p`. Guaranteed to consume input if `end` consumes.

  Totality: total
  Visibility: export
afterSome : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok True a
  Parse one or more instance of `skip` until `p` is encountered,
  returning its value.

  Totality: total
  Visibility: export
afterMany : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok c a
  Parse zero or more instance of `skip` until `p` is encountered,
  returning its value.

  Totality: total
  Visibility: export
sepBy1 : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok c (List1 a)
  Parse one or more things, each separated by another thing.

  Totality: total
  Visibility: export
sepBy : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok False (List a)
  Parse zero or more things, each separated by another thing. May
  match the empty input.

  Totality: total
  Visibility: export
sepEndBy1 : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok c (List1 a)
  Parse one or more instances of `p` separated by and optionally terminated by
  `sep`.

  Totality: total
  Visibility: export
sepEndBy : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok False (List a)
  Parse zero or more instances of `p`, separated by and optionally terminated
  by `sep`. Will not match a separator by itself.

  Totality: total
  Visibility: export
endBy1 : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok True (List1 a)
  Parse one or more instances of `p`, separated and terminated by `sep`.

  Totality: total
  Visibility: export
endBy : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok False (List a)
  Totality: total
  Visibility: export
between : Grammar state tok True l -> Grammar state tok True r -> Grammar state tok c a -> Grammar state tok True a
  Parse an instance of `p` that is between `left` and `right`.

  Totality: total
  Visibility: export
location : Grammar state token False (Int, Int)
  Totality: total
  Visibility: export
endLocation : Grammar state token False (Int, Int)
  Totality: total
  Visibility: export
column : Grammar state token False Int
  Totality: total
  Visibility: export
when : Bool -> Lazy (Grammar state token False ()) -> Grammar state token False ()
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Text.Parser(source)
Reexports
import public Data.List1
import public Text.Parser.Core
import public Text.Quantity
import public Text.Token
Definitions
match : {auto {conArg:983} : TokenKind k} -> Eq k => (kind : k) -> Grammar state (Token k) True (TokType kind)
  Parse a terminal based on a kind of token.

  Totality: total
  Visibility: export
option : a -> Grammar state tok c a -> Grammar state tok False a
  Optionally parse a thing, with a default value if the grammar doesn't
  match. May match the empty input.

  Totality: total
  Visibility: export
optional : Grammar state tok c a -> Grammar state tok False (Maybe a)
  Optionally parse a thing.
  To provide a default value, use `option` instead.

  Totality: total
  Visibility: export
choose : Grammar state tok c1 a -> Grammar state tok c2 b -> Grammar state tok (c1 && Delay c2) (Either a b)
  Try to parse one thing or the other, producing a value that indicates
  which option succeeded. If both would succeed, the left option
  takes priority.

  Totality: total
  Visibility: export
choiceMap : (a -> Grammar state tok c b) -> Foldable t => t a -> Grammar state tok c b
  Produce a grammar by applying a function to each element of a container,
  then try each resulting grammar until the first one succeeds. Fails if the
  container is empty.

  Totality: total
  Visibility: export
choice : Foldable t => t (Grammar state tok c a) -> Grammar state tok c a
  Try each grammar in a container until the first one succeeds.
  Fails if the container is empty.

  Totality: total
  Visibility: export
some : Grammar state tok True a -> Grammar state tok True (List1 a)
  Parse one or more things

  Totality: total
  Visibility: export
many : Grammar state tok True a -> Grammar state tok False (List a)
  Parse zero or more things (may match the empty input)

  Totality: total
  Visibility: export
count : (q : Quantity) -> Grammar state tok True a -> Grammar state tok (isSucc (min q)) (List a)
  Parse `p`, repeated as specified by `q`, returning the list of values.

  Totality: total
  Visibility: export
someTill : Grammar state tok c e -> Grammar state tok True a -> Grammar state tok True (List1 a)
  Parse one or more instances of `p` until `end` succeeds, returning the
  list of values from `p`. Guaranteed to consume input.

  Totality: total
  Visibility: export
manyTill : Grammar state tok c e -> Grammar state tok True a -> Grammar state tok c (List a)
  Parse zero or more instances of `p` until `end` succeeds, returning the
  list of values from `p`. Guaranteed to consume input if `end` consumes.

  Totality: total
  Visibility: export
afterSome : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok True a
  Parse one or more instance of `skip` until `p` is encountered,
  returning its value.

  Totality: total
  Visibility: export
afterMany : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok c a
  Parse zero or more instance of `skip` until `p` is encountered,
  returning its value.

  Totality: total
  Visibility: export
sepBy1 : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok c (List1 a)
  Parse one or more things, each separated by another thing.

  Totality: total
  Visibility: export
sepBy : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok False (List a)
  Parse zero or more things, each separated by another thing. May
  match the empty input.

  Totality: total
  Visibility: export
sepEndBy1 : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok c (List1 a)
  Parse one or more instances of `p` separated by and optionally terminated by
  `sep`.

  Totality: total
  Visibility: export
sepEndBy : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok False (List a)
  Parse zero or more instances of `p`, separated by and optionally terminated
  by `sep`. Will not match a separator by itself.

  Totality: total
  Visibility: export
endBy1 : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok True (List1 a)
  Parse one or more instances of `p`, separated and terminated by `sep`.

  Totality: total
  Visibility: export
endBy : Grammar state tok True s -> Grammar state tok c a -> Grammar state tok False (List a)
  Totality: total
  Visibility: export
between : Grammar state tok True l -> Grammar state tok True r -> Grammar state tok c a -> Grammar state tok True a
  Parse an instance of `p` that is between `left` and `right`.

  Totality: total
  Visibility: export
location : Grammar state token False (Int, Int)
  Totality: total
  Visibility: export
endLocation : Grammar state token False (Int, Int)
  Totality: total
  Visibility: export
column : Grammar state token False Int
  Totality: total
  Visibility: export
when : Bool -> Lazy (Grammar state token False ()) -> Grammar state token False ()
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Text.PrettyPrint.Prettyprinter.Doc.html b/contrib/docs/Text.PrettyPrint.Prettyprinter.Doc.html
index 814c2b3334..84a787b6d6 100644
--- a/contrib/docs/Text.PrettyPrint.Prettyprinter.Doc.html
+++ b/contrib/docs/Text.PrettyPrint.Prettyprinter.Doc.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.PrettyPrint.Prettyprinter.Doc(source)
Reexports
import public Data.List1
import public Data.String.Extra
Definitions
textSpaces : Int -> String
  Totality: total
  Visibility: export
data PageWidth : Type
  Maximum number of characters that fit in one line.

  Totality: total
  Visibility: public export
  Constructors:
  
AvailablePerLine : Int -> Double -> PageWidth
  The `Int` is the number of characters, including whitespace, that fit in a line.
  The `Double` is the ribbon, the fraction of the toal page width that can be printed on.
  
Unbounded : PageWidth
  The layouters should not introduce line breaks.
data FusionDepth : Type
  Fusion depth parameter.

  Totality: total
  Visibility: public export
  Constructors:
  
Shallow : FusionDepth
  Do not dive deep into nested documents.
  
Deep : FusionDepth
  Recurse into all parts of the `Doc`. May impact performace.
data Doc : Type -> Type
  This data type represents pretty documents that have
  been annotated with an arbitrary data type `ann`.

  Totality: total
  Visibility: public export
  Constructors:
  
Empty : Doc ann
  
Chara : Char -> Doc ann
  
Text : Int -> String -> Doc ann
  
Line : Doc ann
  
FlatAlt : Lazy (Doc ann) -> Lazy (Doc ann) -> Doc ann
  
Cat : Doc ann -> Doc ann -> Doc ann
  
Nest : Int -> Doc ann -> Doc ann
  
Union : Lazy (Doc ann) -> Lazy (Doc ann) -> Doc ann
  
Column : (Int -> Doc ann) -> Doc ann
  
WithPageWidth : (PageWidth -> Doc ann) -> Doc ann
  
Nesting : (Int -> Doc ann) -> Doc ann
  
Annotated : ann -> Doc ann -> Doc ann

  Hints:
  
FromString (Doc ann)
  
Functor Doc
  
Monoid (Doc ann)
  
Semigroup (Doc ann)
  
Show (Doc ann)
column : (Int -> Doc ann) -> Doc ann
  Layout a document depending on which column it starts at.

  Totality: total
  Visibility: export
nest : Int -> Doc ann -> Doc ann
  Lays out a document with the current nesting level increased by `i`.

  Totality: total
  Visibility: export
nesting : (Int -> Doc ann) -> Doc ann
  Layout a document depending on the current nesting level.

  Totality: total
  Visibility: export
width : Doc ann -> (Int -> Doc ann) -> Doc ann
  Lays out a document, and makes the column width of it available to a function.

  Totality: total
  Visibility: export
pageWidth : (PageWidth -> Doc ann) -> Doc ann
  Layout a document depending on the page width, if one has been specified.

  Totality: total
  Visibility: export
align : Doc ann -> Doc ann
  Lays out a document with the nesting level set to the current column.

  Totality: total
  Visibility: export
hang : Int -> Doc ann -> Doc ann
  Lays out a document with a nesting level set to the current column plus `i`.
  Negative values are allowed, and decrease the nesting level accordingly.

  Totality: total
  Visibility: export
spaces : Int -> Doc ann
  Insert a number of spaces.

  Totality: total
  Visibility: export
indent : Int -> Doc ann -> Doc ann
  Indents a document with `i` spaces, starting from the current cursor position.

  Totality: total
  Visibility: export
fill : Int -> Doc ann -> Doc ann
  Lays out a document. It then appends spaces until the width is equal to `i`.
  If the width is already larger, nothing is appended.

  Totality: total
  Visibility: export
(<++>) : Doc ann -> Doc ann -> Doc ann
  Concatenates two documents with a space in between.

  Totality: total
  Visibility: export
  Fixity Declarations:
  infix operator, level 5
infixr operator, level 5
infixr operator, level 6
emptyDoc : Doc ann
  The empty document behaves like `pretty ""`, so it has a height of 1.

  Totality: total
  Visibility: export
softline : Doc ann
  Behaves like `space` if the resulting output fits the page, otherwise like `line`.

  Totality: total
  Visibility: export
softline' : Doc ann
  Like `softline`, but behaves like `neutral` if the resulting output does not fit
  on the page.

  Totality: total
  Visibility: export
hardline : Doc ann
  A line break, even when grouped.

  Totality: total
  Visibility: export
group : Doc ann -> Doc ann
  Tries laying out a document into a single line by removing the contained
  line breaks; if this does not fit the page, or has an `hardline`, the document
  is laid out without changes.

  Totality: total
  Visibility: export
flatAlt : Lazy (Doc ann) -> Lazy (Doc ann) -> Doc ann
  By default renders the first document, When grouped renders the second, with
  the first as fallback when there is not enough space.

  Totality: total
  Visibility: export
line : Doc ann
  Advances to the next line and indents to the current nesting level.

  Totality: total
  Visibility: export
line' : Doc ann
  Like `line`, but behaves like `neutral` if the line break is undone by `group`.

  Totality: total
  Visibility: export
fillBreak : Int -> Doc ann -> Doc ann
  First lays out the document. It then appends spaces until the width is equal to `i`.
  If the width is already larger than `i`, the nesting level is decreased by `i`
  and a line is appended.

  Totality: total
  Visibility: export
concatWith : (Doc ann -> Doc ann -> Doc ann) -> List (Doc ann) -> Doc ann
  Concatenate all documents element-wise with a binary function.

  Totality: total
  Visibility: export
hsep : List (Doc ann) -> Doc ann
  Concatenates all documents horizontally with `(<++>)`.

  Totality: total
  Visibility: export
vsep : List (Doc ann) -> Doc ann
  Concatenates all documents above each other. If a `group` undoes the line breaks,
  the documents are separated with a space instead.

  Totality: total
  Visibility: export
fillSep : List (Doc ann) -> Doc ann
  Concatenates the documents horizontally with `(<++>)` as long as it fits the page,
  then inserts a line and continues.

  Totality: total
  Visibility: export
sep : List (Doc ann) -> Doc ann
  Tries laying out the documents separated with spaces and if this does not fit,
  separates them with newlines.

  Totality: total
  Visibility: export
hcat : List (Doc ann) -> Doc ann
  Concatenates all documents horizontally with `(<+>)`.

  Totality: total
  Visibility: export
vcat : List (Doc ann) -> Doc ann
  Vertically concatenates the documents. If it is grouped, the line breaks are removed.

  Totality: total
  Visibility: export
fillCat : List (Doc ann) -> Doc ann
  Concatenates documents horizontally with `(<+>)` as log as it fits the page, then
  inserts a line and continues.

  Totality: total
  Visibility: export
cat : List (Doc ann) -> Doc ann
  Tries laying out the documents separated with nothing, and if it does not fit the page,
  separates them with newlines.

  Totality: total
  Visibility: export
punctuate : Doc ann -> List (Doc ann) -> List (Doc ann)
  Appends `p` to all but the last document.

  Totality: total
  Visibility: export
plural : Num amount => Eq amount => doc -> doc -> amount -> doc
  Totality: total
  Visibility: export
enclose : Doc ann -> Doc ann -> Doc ann -> Doc ann
  Encloses the document between two other documents using `(<+>)`.

  Totality: total
  Visibility: export
surround : Doc ann -> Doc ann -> Doc ann -> Doc ann
  Reordering of `encloses`.
  Example: concatWith (surround (pretty ".")) [pretty "Text", pretty "PrettyPrint", pretty "Doc"]
           Text.PrettyPrint.Doc

  Totality: total
  Visibility: export
encloseSep : Doc ann -> Doc ann -> Doc ann -> List (Doc ann) -> Doc ann
  Concatenates the documents separated by `s` and encloses the resulting document by `l` and `r`.

  Totality: total
  Visibility: export
annotate : ann -> Doc ann -> Doc ann
  Adds an annotation to a document.

  Totality: total
  Visibility: export
alterAnnotations : (ann -> List ann') -> Doc ann -> Doc ann'
  Changes the annotations of a document. Individual annotations can be removed,
  changed, or replaced by multiple ones.

  Totality: total
  Visibility: export
unAnnotate : Doc ann -> Doc xxx
  Removes all annotations.

  Totality: total
  Visibility: export
reAnnotate : (ann -> ann') -> Doc ann -> Doc ann'
  Changes the annotations of a document.

  Totality: total
  Visibility: export
interface Pretty : Type -> Type
  Overloaded converison to `Doc`.

  Parameters: a
Methods:
  
pretty : a -> Doc ann
  
prettyPrec : Prec -> a -> Doc ann

Implementations:
  
Pretty String
  
Pretty a => Pretty (List a)
  
Pretty a => Pretty (List1 a)
  
Pretty ()
  
Pretty Bool
  
Pretty Char
  
Pretty Nat
  
Pretty Int
  
Pretty Integer
  
Pretty Double
  
Pretty Bits8
  
Pretty Bits16
  
Pretty Bits32
  
Pretty Bits64
  
Pretty Int8
  
Pretty Int16
  
Pretty Int32
  
Pretty Int64
  
(Pretty a, Pretty b) => Pretty (a, b)
  
Pretty a => Pretty (Maybe a)
  
Pretty StopReason
pretty : Pretty a => a -> Doc ann
  Totality: total
  Visibility: public export
prettyPrec : Pretty a => Prec -> a -> Doc ann
  Totality: total
  Visibility: public export
list : List (Doc ann) -> Doc ann
  Variant of `encloseSep` with braces and comma as separator.

  Totality: total
  Visibility: export
tupled : List (Doc ann) -> Doc ann
  Variant of `encloseSep` with parentheses and comma as separator.

  Totality: total
  Visibility: export
fuse : FusionDepth -> Doc ann -> Doc ann
  Combines text nodes so they can be rendered more efficiently.

  Totality: total
  Visibility: export
data SimpleDocStream : Type -> Type
  This data type represents laid out documents and is used by the display functions.

  Totality: total
  Visibility: public export
  Constructors:
  
SEmpty : SimpleDocStream ann
  
SChar : Char -> Lazy (SimpleDocStream ann) -> SimpleDocStream ann
  
SText : Int -> String -> Lazy (SimpleDocStream ann) -> SimpleDocStream ann
  
SLine : Int -> SimpleDocStream ann -> SimpleDocStream ann
  
SAnnPush : ann -> SimpleDocStream ann -> SimpleDocStream ann
  
SAnnPop : SimpleDocStream ann -> SimpleDocStream ann

  Hint: 
Functor SimpleDocStream
alterAnnotationsS : (ann -> Maybe ann') -> SimpleDocStream ann -> SimpleDocStream ann'
  Changes the annotation of a document to a different annotation or none.

  Totality: total
  Visibility: export
unAnnotateS : SimpleDocStream ann -> SimpleDocStream xxx
  Removes all annotations.

  Totality: total
  Visibility: export
reAnnotateS : (ann -> ann') -> SimpleDocStream ann -> SimpleDocStream ann'
  Changes the annotation of a document.

  Totality: total
  Visibility: export
collectAnnotations : Monoid m => (ann -> m) -> SimpleDocStream ann -> m
  Collects all annotations from a document.

  Totality: total
  Visibility: export
traverse : Applicative f => (ann -> f ann') -> SimpleDocStream ann -> f (SimpleDocStream ann')
  Transform a document based on its annotations.

  Totality: total
  Visibility: export
removeTrailingWhitespace : SimpleDocStream ann -> SimpleDocStream ann
  Removes all trailing space characters.

  Totality: total
  Visibility: export
FittingPredicate : Type -> Type
  Totality: total
  Visibility: public export
defaultPageWidth : PageWidth
  Totality: total
  Visibility: export
record LayoutOptions : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkLayoutOptions : PageWidth -> LayoutOptions

  Projection: 
.layoutPageWidth : LayoutOptions -> PageWidth
.layoutPageWidth : LayoutOptions -> PageWidth
  Totality: total
  Visibility: public export
layoutPageWidth : LayoutOptions -> PageWidth
  Totality: total
  Visibility: public export
defaultLayoutOptions : LayoutOptions
  Totality: total
  Visibility: export
layoutWadlerLeijen : FittingPredicate ann -> PageWidth -> Doc ann -> SimpleDocStream ann
  The Wadler/Leijen layout algorithm.

  Totality: total
  Visibility: export
layoutUnbounded : Doc ann -> SimpleDocStream ann
  Layout a document with unbounded page width.

  Totality: total
  Visibility: export
layoutPretty : LayoutOptions -> Doc ann -> SimpleDocStream ann
  The default layout algorithm.

  Totality: total
  Visibility: export
layoutSmart : LayoutOptions -> Doc ann -> SimpleDocStream ann
  Layout algorithm with more lookahead than layoutPretty.

  Totality: total
  Visibility: export
layoutCompact : Doc ann -> SimpleDocStream ann
  Lays out the document without adding any indentation. This layouter is very fast.

  Totality: total
  Visibility: export
renderShow : SimpleDocStream ann -> String -> String
  Totality: total
  Visibility: export

\ No newline at end of file
+
Text.PrettyPrint.Prettyprinter.Doc(source)
Reexports
import public Data.List1
import public Data.String.Extra
Definitions
textSpaces : Int -> String
  Totality: total
  Visibility: export
data PageWidth : Type
  Maximum number of characters that fit in one line.

  Totality: total
  Visibility: public export
  Constructors:
  
AvailablePerLine : Int -> Double -> PageWidth
  The `Int` is the number of characters, including whitespace, that fit in a line.
  The `Double` is the ribbon, the fraction of the toal page width that can be printed on.
  
Unbounded : PageWidth
  The layouters should not introduce line breaks.
data FusionDepth : Type
  Fusion depth parameter.

  Totality: total
  Visibility: public export
  Constructors:
  
Shallow : FusionDepth
  Do not dive deep into nested documents.
  
Deep : FusionDepth
  Recurse into all parts of the `Doc`. May impact performace.
data Doc : Type -> Type
  This data type represents pretty documents that have
  been annotated with an arbitrary data type `ann`.

  Totality: total
  Visibility: public export
  Constructors:
  
Empty : Doc ann
  
Chara : Char -> Doc ann
  
Text : Int -> String -> Doc ann
  
Line : Doc ann
  
FlatAlt : Lazy (Doc ann) -> Lazy (Doc ann) -> Doc ann
  
Cat : Doc ann -> Doc ann -> Doc ann
  
Nest : Int -> Doc ann -> Doc ann
  
Union : Lazy (Doc ann) -> Lazy (Doc ann) -> Doc ann
  
Column : (Int -> Doc ann) -> Doc ann
  
WithPageWidth : (PageWidth -> Doc ann) -> Doc ann
  
Nesting : (Int -> Doc ann) -> Doc ann
  
Annotated : ann -> Doc ann -> Doc ann

  Hints:
  
FromString (Doc ann)
  
Functor Doc
  
Monoid (Doc ann)
  
Semigroup (Doc ann)
  
Show (Doc ann)
column : (Int -> Doc ann) -> Doc ann
  Layout a document depending on which column it starts at.

  Totality: total
  Visibility: export
nest : Int -> Doc ann -> Doc ann
  Lays out a document with the current nesting level increased by `i`.

  Totality: total
  Visibility: export
nesting : (Int -> Doc ann) -> Doc ann
  Layout a document depending on the current nesting level.

  Totality: total
  Visibility: export
width : Doc ann -> (Int -> Doc ann) -> Doc ann
  Lays out a document, and makes the column width of it available to a function.

  Totality: total
  Visibility: export
pageWidth : (PageWidth -> Doc ann) -> Doc ann
  Layout a document depending on the page width, if one has been specified.

  Totality: total
  Visibility: export
align : Doc ann -> Doc ann
  Lays out a document with the nesting level set to the current column.

  Totality: total
  Visibility: export
hang : Int -> Doc ann -> Doc ann
  Lays out a document with a nesting level set to the current column plus `i`.
  Negative values are allowed, and decrease the nesting level accordingly.

  Totality: total
  Visibility: export
spaces : Int -> Doc ann
  Insert a number of spaces.

  Totality: total
  Visibility: export
indent : Int -> Doc ann -> Doc ann
  Indents a document with `i` spaces, starting from the current cursor position.

  Totality: total
  Visibility: export
fill : Int -> Doc ann -> Doc ann
  Lays out a document. It then appends spaces until the width is equal to `i`.
  If the width is already larger, nothing is appended.

  Totality: total
  Visibility: export
(<++>) : Doc ann -> Doc ann -> Doc ann
  Concatenates two documents with a space in between.

  Totality: total
  Visibility: export
  Fixity Declarations:
  infix operator, level 5
infixr operator, level 5
infixr operator, level 6
emptyDoc : Doc ann
  The empty document behaves like `pretty ""`, so it has a height of 1.

  Totality: total
  Visibility: export
softline : Doc ann
  Behaves like `space` if the resulting output fits the page, otherwise like `line`.

  Totality: total
  Visibility: export
softline' : Doc ann
  Like `softline`, but behaves like `neutral` if the resulting output does not fit
  on the page.

  Totality: total
  Visibility: export
hardline : Doc ann
  A line break, even when grouped.

  Totality: total
  Visibility: export
group : Doc ann -> Doc ann
  Tries laying out a document into a single line by removing the contained
  line breaks; if this does not fit the page, or has an `hardline`, the document
  is laid out without changes.

  Totality: total
  Visibility: export
flatAlt : Lazy (Doc ann) -> Lazy (Doc ann) -> Doc ann
  By default renders the first document, When grouped renders the second, with
  the first as fallback when there is not enough space.

  Totality: total
  Visibility: export
line : Doc ann
  Advances to the next line and indents to the current nesting level.

  Totality: total
  Visibility: export
line' : Doc ann
  Like `line`, but behaves like `neutral` if the line break is undone by `group`.

  Totality: total
  Visibility: export
fillBreak : Int -> Doc ann -> Doc ann
  First lays out the document. It then appends spaces until the width is equal to `i`.
  If the width is already larger than `i`, the nesting level is decreased by `i`
  and a line is appended.

  Totality: total
  Visibility: export
concatWith : (Doc ann -> Doc ann -> Doc ann) -> List (Doc ann) -> Doc ann
  Concatenate all documents element-wise with a binary function.

  Totality: total
  Visibility: export
hsep : List (Doc ann) -> Doc ann
  Concatenates all documents horizontally with `(<++>)`.

  Totality: total
  Visibility: export
vsep : List (Doc ann) -> Doc ann
  Concatenates all documents above each other. If a `group` undoes the line breaks,
  the documents are separated with a space instead.

  Totality: total
  Visibility: export
fillSep : List (Doc ann) -> Doc ann
  Concatenates the documents horizontally with `(<++>)` as long as it fits the page,
  then inserts a line and continues.

  Totality: total
  Visibility: export
sep : List (Doc ann) -> Doc ann
  Tries laying out the documents separated with spaces and if this does not fit,
  separates them with newlines.

  Totality: total
  Visibility: export
hcat : List (Doc ann) -> Doc ann
  Concatenates all documents horizontally with `(<+>)`.

  Totality: total
  Visibility: export
vcat : List (Doc ann) -> Doc ann
  Vertically concatenates the documents. If it is grouped, the line breaks are removed.

  Totality: total
  Visibility: export
fillCat : List (Doc ann) -> Doc ann
  Concatenates documents horizontally with `(<+>)` as log as it fits the page, then
  inserts a line and continues.

  Totality: total
  Visibility: export
cat : List (Doc ann) -> Doc ann
  Tries laying out the documents separated with nothing, and if it does not fit the page,
  separates them with newlines.

  Totality: total
  Visibility: export
punctuate : Doc ann -> List (Doc ann) -> List (Doc ann)
  Appends `p` to all but the last document.

  Totality: total
  Visibility: export
plural : Num amount => Eq amount => doc -> doc -> amount -> doc
  Totality: total
  Visibility: export
enclose : Doc ann -> Doc ann -> Doc ann -> Doc ann
  Encloses the document between two other documents using `(<+>)`.

  Totality: total
  Visibility: export
surround : Doc ann -> Doc ann -> Doc ann -> Doc ann
  Reordering of `encloses`.
  Example: concatWith (surround (pretty ".")) [pretty "Text", pretty "PrettyPrint", pretty "Doc"]
           Text.PrettyPrint.Doc

  Totality: total
  Visibility: export
encloseSep : Doc ann -> Doc ann -> Doc ann -> List (Doc ann) -> Doc ann
  Concatenates the documents separated by `s` and encloses the resulting document by `l` and `r`.

  Totality: total
  Visibility: export
annotate : ann -> Doc ann -> Doc ann
  Adds an annotation to a document.

  Totality: total
  Visibility: export
alterAnnotations : (ann -> List ann') -> Doc ann -> Doc ann'
  Changes the annotations of a document. Individual annotations can be removed,
  changed, or replaced by multiple ones.

  Totality: total
  Visibility: export
unAnnotate : Doc ann -> Doc xxx
  Removes all annotations.

  Totality: total
  Visibility: export
reAnnotate : (ann -> ann') -> Doc ann -> Doc ann'
  Changes the annotations of a document.

  Totality: total
  Visibility: export
interface Pretty : Type -> Type
  Overloaded converison to `Doc`.

  Parameters: a
Methods:
  
pretty : a -> Doc ann
  
prettyPrec : Prec -> a -> Doc ann

Implementations:
  
Pretty String
  
Pretty a => Pretty (List a)
  
Pretty a => Pretty (List1 a)
  
Pretty ()
  
Pretty Bool
  
Pretty Char
  
Pretty Nat
  
Pretty Int
  
Pretty Integer
  
Pretty Double
  
Pretty Bits8
  
Pretty Bits16
  
Pretty Bits32
  
Pretty Bits64
  
Pretty Int8
  
Pretty Int16
  
Pretty Int32
  
Pretty Int64
  
(Pretty a, Pretty b) => Pretty (a, b)
  
Pretty a => Pretty (Maybe a)
  
Pretty StopReason
pretty : Pretty a => a -> Doc ann
  Totality: total
  Visibility: public export
prettyPrec : Pretty a => Prec -> a -> Doc ann
  Totality: total
  Visibility: public export
list : List (Doc ann) -> Doc ann
  Variant of `encloseSep` with braces and comma as separator.

  Totality: total
  Visibility: export
tupled : List (Doc ann) -> Doc ann
  Variant of `encloseSep` with parentheses and comma as separator.

  Totality: total
  Visibility: export
fuse : FusionDepth -> Doc ann -> Doc ann
  Combines text nodes so they can be rendered more efficiently.

  Totality: total
  Visibility: export
data SimpleDocStream : Type -> Type
  This data type represents laid out documents and is used by the display functions.

  Totality: total
  Visibility: public export
  Constructors:
  
SEmpty : SimpleDocStream ann
  
SChar : Char -> Lazy (SimpleDocStream ann) -> SimpleDocStream ann
  
SText : Int -> String -> Lazy (SimpleDocStream ann) -> SimpleDocStream ann
  
SLine : Int -> SimpleDocStream ann -> SimpleDocStream ann
  
SAnnPush : ann -> SimpleDocStream ann -> SimpleDocStream ann
  
SAnnPop : SimpleDocStream ann -> SimpleDocStream ann

  Hint: 
Functor SimpleDocStream
alterAnnotationsS : (ann -> Maybe ann') -> SimpleDocStream ann -> SimpleDocStream ann'
  Changes the annotation of a document to a different annotation or none.

  Totality: total
  Visibility: export
unAnnotateS : SimpleDocStream ann -> SimpleDocStream xxx
  Removes all annotations.

  Totality: total
  Visibility: export
reAnnotateS : (ann -> ann') -> SimpleDocStream ann -> SimpleDocStream ann'
  Changes the annotation of a document.

  Totality: total
  Visibility: export
collectAnnotations : Monoid m => (ann -> m) -> SimpleDocStream ann -> m
  Collects all annotations from a document.

  Totality: total
  Visibility: export
traverse : Applicative f => (ann -> f ann') -> SimpleDocStream ann -> f (SimpleDocStream ann')
  Transform a document based on its annotations.

  Totality: total
  Visibility: export
removeTrailingWhitespace : SimpleDocStream ann -> SimpleDocStream ann
  Removes all trailing space characters.

  Totality: total
  Visibility: export
FittingPredicate : Type -> Type
  Totality: total
  Visibility: public export
defaultPageWidth : PageWidth
  Totality: total
  Visibility: export
record LayoutOptions : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkLayoutOptions : PageWidth -> LayoutOptions

  Projection: 
.layoutPageWidth : LayoutOptions -> PageWidth
.layoutPageWidth : LayoutOptions -> PageWidth
  Totality: total
  Visibility: public export
layoutPageWidth : LayoutOptions -> PageWidth
  Totality: total
  Visibility: public export
defaultLayoutOptions : LayoutOptions
  Totality: total
  Visibility: export
layoutWadlerLeijen : FittingPredicate ann -> PageWidth -> Doc ann -> SimpleDocStream ann
  The Wadler/Leijen layout algorithm.

  Totality: total
  Visibility: export
layoutUnbounded : Doc ann -> SimpleDocStream ann
  Layout a document with unbounded page width.

  Totality: total
  Visibility: export
layoutPretty : LayoutOptions -> Doc ann -> SimpleDocStream ann
  The default layout algorithm.

  Totality: total
  Visibility: export
layoutSmart : LayoutOptions -> Doc ann -> SimpleDocStream ann
  Layout algorithm with more lookahead than layoutPretty.

  Totality: total
  Visibility: export
layoutCompact : Doc ann -> SimpleDocStream ann
  Lays out the document without adding any indentation. This layouter is very fast.

  Totality: total
  Visibility: export
renderShow : SimpleDocStream ann -> String -> String
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Text.PrettyPrint.Prettyprinter.Render.HTML.html b/contrib/docs/Text.PrettyPrint.Prettyprinter.Render.HTML.html
index a2e4ff9dd3..f1f383695a 100644
--- a/contrib/docs/Text.PrettyPrint.Prettyprinter.Render.HTML.html
+++ b/contrib/docs/Text.PrettyPrint.Prettyprinter.Render.HTML.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.PrettyPrint.Prettyprinter.Render.HTML(source)
Definitions
htmlEscape : String -> String
  Visibility: export

\ No newline at end of file
+
Text.PrettyPrint.Prettyprinter.Render.HTML(source)
Definitions
htmlEscape : String -> String
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Text.PrettyPrint.Prettyprinter.Render.String.html b/contrib/docs/Text.PrettyPrint.Prettyprinter.Render.String.html
index 752ac76969..de5e568bc3 100644
--- a/contrib/docs/Text.PrettyPrint.Prettyprinter.Render.String.html
+++ b/contrib/docs/Text.PrettyPrint.Prettyprinter.Render.String.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.PrettyPrint.Prettyprinter.Render.String(source)
Definitions
renderString : SimpleDocStream ann -> String
  Totality: total
  Visibility: export
renderIO : SimpleDocStream ann -> IO ()
  Totality: total
  Visibility: export
putDoc : Doc ann -> IO ()
  Prettyprints a document to standard output, using default options.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Text.PrettyPrint.Prettyprinter.Render.String(source)
Definitions
renderString : SimpleDocStream ann -> String
  Totality: total
  Visibility: export
renderIO : SimpleDocStream ann -> IO ()
  Totality: total
  Visibility: export
putDoc : Doc ann -> IO ()
  Prettyprints a document to standard output, using default options.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Text.PrettyPrint.Prettyprinter.Render.Terminal.html b/contrib/docs/Text.PrettyPrint.Prettyprinter.Render.Terminal.html
index 5849b90b09..1939d9b2be 100644
--- a/contrib/docs/Text.PrettyPrint.Prettyprinter.Render.Terminal.html
+++ b/contrib/docs/Text.PrettyPrint.Prettyprinter.Render.Terminal.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.PrettyPrint.Prettyprinter.Render.Terminal(source)
Reexports
import public Control.ANSI
Definitions
AnsiStyle : Type
  Visibility: public export
color : Color -> AnsiStyle
  Visibility: export
bgColor : Color -> AnsiStyle
  Visibility: export
bold : AnsiStyle
  Visibility: export
italic : AnsiStyle
  Visibility: export
underline : AnsiStyle
  Visibility: export
strike : AnsiStyle
  Visibility: export
renderString : SimpleDocStream AnsiStyle -> String
  Visibility: export
renderIO : SimpleDocStream AnsiStyle -> IO ()
  Visibility: export
putDoc : Doc AnsiStyle -> IO ()
  Visibility: export

\ No newline at end of file
+
Text.PrettyPrint.Prettyprinter.Render.Terminal(source)
Reexports
import public Control.ANSI
Definitions
AnsiStyle : Type
  Visibility: public export
color : Color -> AnsiStyle
  Visibility: export
bgColor : Color -> AnsiStyle
  Visibility: export
bold : AnsiStyle
  Visibility: export
italic : AnsiStyle
  Visibility: export
underline : AnsiStyle
  Visibility: export
strike : AnsiStyle
  Visibility: export
renderString : SimpleDocStream AnsiStyle -> String
  Visibility: export
renderIO : SimpleDocStream AnsiStyle -> IO ()
  Visibility: export
putDoc : Doc AnsiStyle -> IO ()
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Text.PrettyPrint.Prettyprinter.SimpleDocTree.html b/contrib/docs/Text.PrettyPrint.Prettyprinter.SimpleDocTree.html
index 32faee59f4..06c01e80ca 100644
--- a/contrib/docs/Text.PrettyPrint.Prettyprinter.SimpleDocTree.html
+++ b/contrib/docs/Text.PrettyPrint.Prettyprinter.SimpleDocTree.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.PrettyPrint.Prettyprinter.SimpleDocTree(source)
Definitions
data SimpleDocTree : Type -> Type
  Tree-like structure more suitable for rendering to a structured
  format such as HTML.

  Totality: total
  Visibility: public export
  Constructors:
  
STEmpty : SimpleDocTree ann
  
STChar : Char -> SimpleDocTree ann
  
STText : Int -> String -> SimpleDocTree ann
  
STLine : Int -> SimpleDocTree ann
  
STAnn : ann -> SimpleDocTree ann -> SimpleDocTree ann
  
STConcat : List (SimpleDocTree ann) -> SimpleDocTree ann
alterAnnotationsST : (ann -> List ann') -> SimpleDocTree ann -> SimpleDocTree ann'
  Changes the annotation of a document, or none at all.

  Totality: total
  Visibility: export
reAnnotateST : (ann -> ann') -> SimpleDocTree ann -> SimpleDocTree ann'
  Changes the annotation of a document.

  Totality: total
  Visibility: export
unAnnotateST : SimpleDocTree ann -> SimpleDocTree xxx
  Removes all annotations.

  Totality: total
  Visibility: export
collectAnnotations : Monoid m => (ann -> m) -> SimpleDocTree ann -> m
  Collects all annotations from a document.

  Totality: total
  Visibility: export
traverse : Applicative f => (ann -> f ann') -> SimpleDocTree ann -> f (SimpleDocTree ann')
  Transform a document based on its annotations.

  Totality: total
  Visibility: export
fromStream : SimpleDocStream ann -> SimpleDocTree ann
  Totality: total
  Visibility: export

\ No newline at end of file
+
Text.PrettyPrint.Prettyprinter.SimpleDocTree(source)
Definitions
data SimpleDocTree : Type -> Type
  Tree-like structure more suitable for rendering to a structured
  format such as HTML.

  Totality: total
  Visibility: public export
  Constructors:
  
STEmpty : SimpleDocTree ann
  
STChar : Char -> SimpleDocTree ann
  
STText : Int -> String -> SimpleDocTree ann
  
STLine : Int -> SimpleDocTree ann
  
STAnn : ann -> SimpleDocTree ann -> SimpleDocTree ann
  
STConcat : List (SimpleDocTree ann) -> SimpleDocTree ann
alterAnnotationsST : (ann -> List ann') -> SimpleDocTree ann -> SimpleDocTree ann'
  Changes the annotation of a document, or none at all.

  Totality: total
  Visibility: export
reAnnotateST : (ann -> ann') -> SimpleDocTree ann -> SimpleDocTree ann'
  Changes the annotation of a document.

  Totality: total
  Visibility: export
unAnnotateST : SimpleDocTree ann -> SimpleDocTree xxx
  Removes all annotations.

  Totality: total
  Visibility: export
collectAnnotations : Monoid m => (ann -> m) -> SimpleDocTree ann -> m
  Collects all annotations from a document.

  Totality: total
  Visibility: export
traverse : Applicative f => (ann -> f ann') -> SimpleDocTree ann -> f (SimpleDocTree ann')
  Transform a document based on its annotations.

  Totality: total
  Visibility: export
fromStream : SimpleDocStream ann -> SimpleDocTree ann
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Text.PrettyPrint.Prettyprinter.Symbols.html b/contrib/docs/Text.PrettyPrint.Prettyprinter.Symbols.html
index aaaf8242f1..285656ccff 100644
--- a/contrib/docs/Text.PrettyPrint.Prettyprinter.Symbols.html
+++ b/contrib/docs/Text.PrettyPrint.Prettyprinter.Symbols.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.PrettyPrint.Prettyprinter.Symbols(source)
Definitions
squote : Doc ann
  Totality: total
  Visibility: export
dquote : Doc ann
  Totality: total
  Visibility: export
lparen : Doc ann
  Totality: total
  Visibility: export
rparen : Doc ann
  Totality: total
  Visibility: export
langle : Doc ann
  Totality: total
  Visibility: export
rangle : Doc ann
  Totality: total
  Visibility: export
lbracket : Doc ann
  Totality: total
  Visibility: export
rbracket : Doc ann
  Totality: total
  Visibility: export
lbrace : Doc ann
  Totality: total
  Visibility: export
rbrace : Doc ann
  Totality: total
  Visibility: export
semi : Doc ann
  Totality: total
  Visibility: export
colon : Doc ann
  Totality: total
  Visibility: export
comma : Doc ann
  Totality: total
  Visibility: export
space : Doc ann
  Totality: total
  Visibility: export
dot : Doc ann
  Totality: total
  Visibility: export
slash : Doc ann
  Totality: total
  Visibility: export
backslash : Doc ann
  Totality: total
  Visibility: export
equals : Doc ann
  Totality: total
  Visibility: export
pipe : Doc ann
  Totality: total
  Visibility: export
squotes : Doc ann -> Doc ann
  Totality: total
  Visibility: export
dquotes : Doc ann -> Doc ann
  Totality: total
  Visibility: export
parens : Doc ann -> Doc ann
  Totality: total
  Visibility: export
parenthesise : Bool -> Doc ann -> Doc ann
  Totality: total
  Visibility: export
angles : Doc ann -> Doc ann
  Totality: total
  Visibility: export
brackets : {default lbracket _ : Doc ann} -> {default rbracket _ : Doc ann} -> Doc ann -> Doc ann
  Totality: total
  Visibility: export
braces : Doc ann -> Doc ann
  Totality: total
  Visibility: export

\ No newline at end of file
+
Text.PrettyPrint.Prettyprinter.Symbols(source)
Definitions
squote : Doc ann
  Totality: total
  Visibility: export
dquote : Doc ann
  Totality: total
  Visibility: export
lparen : Doc ann
  Totality: total
  Visibility: export
rparen : Doc ann
  Totality: total
  Visibility: export
langle : Doc ann
  Totality: total
  Visibility: export
rangle : Doc ann
  Totality: total
  Visibility: export
lbracket : Doc ann
  Totality: total
  Visibility: export
rbracket : Doc ann
  Totality: total
  Visibility: export
lbrace : Doc ann
  Totality: total
  Visibility: export
rbrace : Doc ann
  Totality: total
  Visibility: export
semi : Doc ann
  Totality: total
  Visibility: export
colon : Doc ann
  Totality: total
  Visibility: export
comma : Doc ann
  Totality: total
  Visibility: export
space : Doc ann
  Totality: total
  Visibility: export
dot : Doc ann
  Totality: total
  Visibility: export
slash : Doc ann
  Totality: total
  Visibility: export
backslash : Doc ann
  Totality: total
  Visibility: export
equals : Doc ann
  Totality: total
  Visibility: export
pipe : Doc ann
  Totality: total
  Visibility: export
squotes : Doc ann -> Doc ann
  Totality: total
  Visibility: export
dquotes : Doc ann -> Doc ann
  Totality: total
  Visibility: export
parens : Doc ann -> Doc ann
  Totality: total
  Visibility: export
parenthesise : Bool -> Doc ann -> Doc ann
  Totality: total
  Visibility: export
angles : Doc ann -> Doc ann
  Totality: total
  Visibility: export
brackets : {default lbracket _ : Doc ann} -> {default rbracket _ : Doc ann} -> Doc ann -> Doc ann
  Totality: total
  Visibility: export
braces : Doc ann -> Doc ann
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Text.PrettyPrint.Prettyprinter.Util.html b/contrib/docs/Text.PrettyPrint.Prettyprinter.Util.html
index 257d2fe854..11a6d10b8d 100644
--- a/contrib/docs/Text.PrettyPrint.Prettyprinter.Util.html
+++ b/contrib/docs/Text.PrettyPrint.Prettyprinter.Util.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.PrettyPrint.Prettyprinter.Util(source)
Definitions
words : String -> List (Doc ann)
  Split an input into word-sized `Doc`.

  Totality: total
  Visibility: export
reflow : String -> Doc ann
  Insert soft linebreaks between words, so that text is broken into multiple
  lines when it exceeds the available width.

  Totality: total
  Visibility: export
putDocW : Nat -> Doc ann -> IO ()
  Renders a document with a certain width.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Text.PrettyPrint.Prettyprinter.Util(source)
Definitions
words : String -> List (Doc ann)
  Split an input into word-sized `Doc`.

  Totality: total
  Visibility: export
reflow : String -> Doc ann
  Insert soft linebreaks between words, so that text is broken into multiple
  lines when it exceeds the available width.

  Totality: total
  Visibility: export
putDocW : Nat -> Doc ann -> IO ()
  Renders a document with a certain width.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/contrib/docs/Text.PrettyPrint.Prettyprinter.html b/contrib/docs/Text.PrettyPrint.Prettyprinter.html
index 774ff14809..f73004934f 100644
--- a/contrib/docs/Text.PrettyPrint.Prettyprinter.html
+++ b/contrib/docs/Text.PrettyPrint.Prettyprinter.html
@@ -66,4 +66,4 @@
 
 [1] https://hackage.haskell.org/package/prettyprinter
 [2] https://hackage.haskell.org/package/prettyprinter-ansi-terminal
-
Reexports
import public Text.PrettyPrint.Prettyprinter.Doc
import public Text.PrettyPrint.Prettyprinter.Symbols
\ No newline at end of file
+
Reexports
import public Text.PrettyPrint.Prettyprinter.Doc
import public Text.PrettyPrint.Prettyprinter.Symbols
\ No newline at end of file
diff --git a/contrib/docs/Text.Quantity.html b/contrib/docs/Text.Quantity.html
index adb2992de5..829635bb4c 100644
--- a/contrib/docs/Text.Quantity.html
+++ b/contrib/docs/Text.Quantity.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.Quantity(source)
Definitions
record Quantity : Type
  Totality: total
  Visibility: public export
  Constructor: 
Qty : Nat -> Maybe Nat -> Quantity

  Projections:
  
.max : Quantity -> Maybe Nat
  
.min : Quantity -> Nat

  Hint: 
Show Quantity
.min : Quantity -> Nat
  Totality: total
  Visibility: public export
min : Quantity -> Nat
  Totality: total
  Visibility: public export
.max : Quantity -> Maybe Nat
  Totality: total
  Visibility: public export
max : Quantity -> Maybe Nat
  Totality: total
  Visibility: public export
between : Nat -> Nat -> Quantity
  Totality: total
  Visibility: public export
atLeast : Nat -> Quantity
  Totality: total
  Visibility: public export
atMost : Nat -> Quantity
  Totality: total
  Visibility: public export
exactly : Nat -> Quantity
  Totality: total
  Visibility: public export
inOrder : Quantity -> Bool
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Text.Quantity(source)
Definitions
record Quantity : Type
  Totality: total
  Visibility: public export
  Constructor: 
Qty : Nat -> Maybe Nat -> Quantity

  Projections:
  
.max : Quantity -> Maybe Nat
  
.min : Quantity -> Nat

  Hint: 
Show Quantity
.min : Quantity -> Nat
  Totality: total
  Visibility: public export
min : Quantity -> Nat
  Totality: total
  Visibility: public export
.max : Quantity -> Maybe Nat
  Totality: total
  Visibility: public export
max : Quantity -> Maybe Nat
  Totality: total
  Visibility: public export
between : Nat -> Nat -> Quantity
  Totality: total
  Visibility: public export
atLeast : Nat -> Quantity
  Totality: total
  Visibility: public export
atMost : Nat -> Quantity
  Totality: total
  Visibility: public export
exactly : Nat -> Quantity
  Totality: total
  Visibility: public export
inOrder : Quantity -> Bool
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/docs/Text.Token.html b/contrib/docs/Text.Token.html
index f2fd9bb408..918828ef84 100644
--- a/contrib/docs/Text.Token.html
+++ b/contrib/docs/Text.Token.html
@@ -61,4 +61,4 @@
 
 
 
-
Text.Token(source)
Definitions
interface TokenKind : Type -> Type
  For a type `kind`, specify a way of converting the recognised
  string into a value.
  
  ```idris example
  data SimpleKind = SKString | SKInt | SKComma
  
  TokenKind SimpleKind where
    TokType SKString = String
    TokType SKInt = Int
    TokType SKComma = ()
  
    tokValue SKString x = x
    tokValue SKInt x = cast x
    tokValue SKComma x = ()
  ```

  Parameters: k
Methods:
  
TokType : k -> Type
  The type that a token of this kind converts to.
  
tokValue : (kind : k) -> String -> TokType kind
  Convert a recognised string into a value. The type is determined
  by the kind of token.

Implementations:
  
TokenKind PathTokenKind
  
TokenKind JSONStringTokenKind
  
TokenKind JSONTokenKind
TokType : TokenKind k => k -> Type
  The type that a token of this kind converts to.

  Totality: total
  Visibility: public export
tokValue : {auto __con : TokenKind k} -> (kind : k) -> String -> TokType kind
  Convert a recognised string into a value. The type is determined
  by the kind of token.

  Totality: total
  Visibility: public export
record Token : Type -> Type
  A token of a particular kind and the text that was recognised.

  Totality: total
  Visibility: public export
  Constructor: 
Tok : k -> String -> Token k

  Projections:
  
.kind : Token k -> k
  
.text : Token k -> String
.kind : Token k -> k
  Totality: total
  Visibility: public export
kind : Token k -> k
  Totality: total
  Visibility: public export
.text : Token k -> String
  Totality: total
  Visibility: public export
text : Token k -> String
  Totality: total
  Visibility: public export
value : {auto {conArg:962} : TokenKind k} -> (t : Token k) -> TokType (kind t)
  Get the value of a `Token k`. The resulting type depends upon
  the kind of token.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Text.Token(source)
Definitions
interface TokenKind : Type -> Type
  For a type `kind`, specify a way of converting the recognised
  string into a value.
  
  ```idris example
  data SimpleKind = SKString | SKInt | SKComma
  
  TokenKind SimpleKind where
    TokType SKString = String
    TokType SKInt = Int
    TokType SKComma = ()
  
    tokValue SKString x = x
    tokValue SKInt x = cast x
    tokValue SKComma x = ()
  ```

  Parameters: k
Methods:
  
TokType : k -> Type
  The type that a token of this kind converts to.
  
tokValue : (kind : k) -> String -> TokType kind
  Convert a recognised string into a value. The type is determined
  by the kind of token.

Implementations:
  
TokenKind PathTokenKind
  
TokenKind JSONStringTokenKind
  
TokenKind JSONTokenKind
TokType : TokenKind k => k -> Type
  The type that a token of this kind converts to.

  Totality: total
  Visibility: public export
tokValue : {auto __con : TokenKind k} -> (kind : k) -> String -> TokType kind
  Convert a recognised string into a value. The type is determined
  by the kind of token.

  Totality: total
  Visibility: public export
record Token : Type -> Type
  A token of a particular kind and the text that was recognised.

  Totality: total
  Visibility: public export
  Constructor: 
Tok : k -> String -> Token k

  Projections:
  
.kind : Token k -> k
  
.text : Token k -> String
.kind : Token k -> k
  Totality: total
  Visibility: public export
kind : Token k -> k
  Totality: total
  Visibility: public export
.text : Token k -> String
  Totality: total
  Visibility: public export
text : Token k -> String
  Totality: total
  Visibility: public export
value : {auto {conArg:962} : TokenKind k} -> (t : Token k) -> TokType (kind t)
  Get the value of a `Token k`. The resulting type depends upon
  the kind of token.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/contrib/index.html b/contrib/index.html
index 904a300a3e..f043b35ec8 100644
--- a/contrib/index.html
+++ b/contrib/index.html
@@ -61,4 +61,4 @@
 
 
 
-
Package contrib - Namespaces

\ No newline at end of file
+
Package contrib - Namespaces

\ No newline at end of file
diff --git a/linear/docs/Control.Linear.LIO.html b/linear/docs/Control.Linear.LIO.html
index 39ee4d06df..94e9d31d28 100644
--- a/linear/docs/Control.Linear.LIO.html
+++ b/linear/docs/Control.Linear.LIO.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Linear.LIO(source)
Definitions
interface LinearBind : (Type -> Type) -> Type
  Like `Monad`, but the action and continuation must be run exactly once
  to ensure that the computation is linear.

  Parameters: io
Methods:
  
bindL : (1 _ : io a) -> (1 _ : (a -> io b)) -> io b

Implementation: 
LinearBind IO
bindL : LinearBind io => (1 _ : io a) -> (1 _ : (a -> io b)) -> io b
  Visibility: public export
data Usage : Type
  Required usage on the result value of a computation

  Totality: total
  Visibility: public export
  Constructors:
  
None : Usage
  
Linear : Usage
  
Unrestricted : Usage
fromInteger : (x : Integer) -> Either (x = 0) (x = 1) => Usage
  Visibility: public export
0 ContType : (Type -> Type) -> Usage -> Usage -> Type -> Type -> Type
  Visibility: public export
data L : (Type -> Type) -> {default Unrestricted _ : Usage} -> Type -> Type
  A wrapper which allows operations to state the multiplicity of the value
  they return. For example, `L IO {use=1} File` is an IO operation which
  returns a file that must be used exactly once.

  Totality: total
  Visibility: export
  Constructors:
  
Pure0 : (0 _ : a) -> L io a
  
Pure1 : (1 _ : a) -> L io a
  
PureW : a -> L io a
  
Action : (1 _ : io a) -> L io a
  
Bind : (1 _ : L io a) -> (1 _ : ContType io u_act u_k a b) -> L io b

  Hints:
  
Applicative io => Applicative (L io)
  
Functor io => Functor (L io)
  
(LinearBind io, HasLinearIO io) => HasLinearIO (L io)
  
(Applicative m, LinearBind m) => Monad (L m)
L0 : (Type -> Type) -> Type -> Type
  Visibility: public export
L1 : (Type -> Type) -> Type -> Type
  Visibility: public export
run : Applicative io => LinearBind io => (1 _ : L io a) -> io a
  Run a linear program exactly once, with unrestricted return value in the
  underlying context

  Visibility: export
(>>=) : LinearBind io => (1 _ : L io a) -> (1 _ : ContType io u_act u_k a b) -> L io b
  Visibility: export
  Fixity Declaration: infixl operator, level 1
delay : (1 _ : L io b) -> ContType io u_act u_k () b
  Visibility: export
(>>) : LinearBind io => (1 _ : L io ()) -> (1 _ : L io b) -> L io b
  Visibility: export
  Fixity Declaration: infixl operator, level 1
pure0 : (0 _ : a) -> L io a
  Visibility: export
pure1 : (1 _ : a) -> L io a
  Visibility: export
LinearIO : (Type -> Type) -> Type
  Visibility: public export

\ No newline at end of file
+
Control.Linear.LIO(source)
Definitions
interface LinearBind : (Type -> Type) -> Type
  Like `Monad`, but the action and continuation must be run exactly once
  to ensure that the computation is linear.

  Parameters: io
Methods:
  
bindL : (1 _ : io a) -> (1 _ : (a -> io b)) -> io b

Implementation: 
LinearBind IO
bindL : LinearBind io => (1 _ : io a) -> (1 _ : (a -> io b)) -> io b
  Visibility: public export
data Usage : Type
  Required usage on the result value of a computation

  Totality: total
  Visibility: public export
  Constructors:
  
None : Usage
  
Linear : Usage
  
Unrestricted : Usage
fromInteger : (x : Integer) -> Either (x = 0) (x = 1) => Usage
  Visibility: public export
0 ContType : (Type -> Type) -> Usage -> Usage -> Type -> Type -> Type
  Visibility: public export
data L : (Type -> Type) -> {default Unrestricted _ : Usage} -> Type -> Type
  A wrapper which allows operations to state the multiplicity of the value
  they return. For example, `L IO {use=1} File` is an IO operation which
  returns a file that must be used exactly once.

  Totality: total
  Visibility: export
  Constructors:
  
Pure0 : (0 _ : a) -> L io a
  
Pure1 : (1 _ : a) -> L io a
  
PureW : a -> L io a
  
Action : (1 _ : io a) -> L io a
  
Bind : (1 _ : L io a) -> (1 _ : ContType io u_act u_k a b) -> L io b

  Hints:
  
Applicative io => Applicative (L io)
  
Functor io => Functor (L io)
  
(LinearBind io, HasLinearIO io) => HasLinearIO (L io)
  
(Applicative m, LinearBind m) => Monad (L m)
L0 : (Type -> Type) -> Type -> Type
  Visibility: public export
L1 : (Type -> Type) -> Type -> Type
  Visibility: public export
run : Applicative io => LinearBind io => (1 _ : L io a) -> io a
  Run a linear program exactly once, with unrestricted return value in the
  underlying context

  Visibility: export
(>>=) : LinearBind io => (1 _ : L io a) -> (1 _ : ContType io u_act u_k a b) -> L io b
  Visibility: export
  Fixity Declaration: infixl operator, level 1
delay : (1 _ : L io b) -> ContType io u_act u_k () b
  Visibility: export
(>>) : LinearBind io => (1 _ : L io ()) -> (1 _ : L io b) -> L io b
  Visibility: export
  Fixity Declaration: infixl operator, level 1
pure0 : (0 _ : a) -> L io a
  Visibility: export
pure1 : (1 _ : a) -> L io a
  Visibility: export
LinearIO : (Type -> Type) -> Type
  Visibility: public export

\ No newline at end of file
diff --git a/linear/docs/Data.Linear.Bifunctor.html b/linear/docs/Data.Linear.Bifunctor.html
index 2779a4e430..52e70f415d 100644
--- a/linear/docs/Data.Linear.Bifunctor.html
+++ b/linear/docs/Data.Linear.Bifunctor.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Linear.Bifunctor(source)
Definitions
bimap : (a -@ x) -@ ((b -@ y) -@ (LPair a b -@ LPair x y))
  A linear bimap on linear pairs.
  There is no general Bifunctor interface because it would not be implementable with
  The same type signature consistently, for example LEither does not consume both
  `f` and `g` linearly.

  Totality: total
  Visibility: public export
mapFst : (a -@ x) -@ (LPair a b -@ LPair x b)
  Totality: total
  Visibility: public export
mapSnd : (b -@ y) -@ (LPair a b -@ LPair a y)
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Linear.Bifunctor(source)
Definitions
bimap : (a -@ x) -@ ((b -@ y) -@ (LPair a b -@ LPair x y))
  A linear bimap on linear pairs.
  There is no general Bifunctor interface because it would not be implementable with
  The same type signature consistently, for example LEither does not consume both
  `f` and `g` linearly.

  Totality: total
  Visibility: public export
mapFst : (a -@ x) -@ (LPair a b -@ LPair x b)
  Totality: total
  Visibility: public export
mapSnd : (b -@ y) -@ (LPair a b -@ LPair a y)
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/linear/docs/Data.Linear.Copies.html b/linear/docs/Data.Linear.Copies.html
index 75f7da887e..f080c364e8 100644
--- a/linear/docs/Data.Linear.Copies.html
+++ b/linear/docs/Data.Linear.Copies.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Linear.Copies(source)
Definitions
data Copies : Nat -> (0 _ : a) -> Type
  Carries multiple linear copies of the same value. Usage: m `Copies` x
  reads as "m copies of value x". This data structure is necessary to implement
  algorithms that rely on linearity but also interact with Nat indicies, like
  Vect and Fin.
  This datastructure can be found in the paper "How to Take the Inverse of a Type" by
  Daniel Marshall and Dominic Orchard where it's described as an exponent operator

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : 0 `Copies` x
  
(::) : (1 x : a) -> (1 _ : n `Copies` x) -> S n `Copies` x

  Fixity Declaration: infix operator, level 1
splitAt : (1 m : Nat) -> ((m + n) `Copies` x) -@ LPair (m `Copies` x) (n `Copies` x)
  Split copies into two

  Totality: total
  Visibility: export
(++) : (m `Copies` x) -@ ((n `Copies` x) -@ ((m + n) `Copies` x))
  Combine multiple copies into one

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 7
unzip : (m `Copies` (x # y)) -@ LPair (m `Copies` x) (m `Copies` y)
  Copies of pairs are like pairs of copies

  Totality: total
  Visibility: export
pure : (x : a) -> n `Copies` x
  Totality: total
  Visibility: export
(<*>) : (m `Copies` f) -@ ((m `Copies` x) -@ (m `Copies` f x))
  Applies m copies of a linear function to m arguments, resulting in m copies
  of the result.

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 3
(<$>) : (f : a -@ b) -> (m `Copies` x) -@ (m `Copies` f x)
  Apply f to `m` copies of `x`, resulting in `m` copies of `f x`.
  
  Note that this is not quite `pure f <*> xs` because we don't actually
  need to know `m` to be able to define `(<$>)` as we can proceed by
  induction on xs.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 4
zip : (m `Copies` x) -@ ((m `Copies` y) -@ (m `Copies` (x # y)))
  Combine copies of two values into a pair of copies

  Totality: total
  Visibility: export
extract : (1 `Copies` x) -@ a
  If we have a single copy, we can extract its value

  Totality: total
  Visibility: export
pair : (2 `Copies` x) -@ LPair a a
  Extract 2 copies into a linear pair

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Linear.Copies(source)
Definitions
data Copies : Nat -> (0 _ : a) -> Type
  Carries multiple linear copies of the same value. Usage: m `Copies` x
  reads as "m copies of value x". This data structure is necessary to implement
  algorithms that rely on linearity but also interact with Nat indicies, like
  Vect and Fin.
  This datastructure can be found in the paper "How to Take the Inverse of a Type" by
  Daniel Marshall and Dominic Orchard where it's described as an exponent operator

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : 0 `Copies` x
  
(::) : (1 x : a) -> (1 _ : n `Copies` x) -> S n `Copies` x

  Fixity Declaration: infix operator, level 1
splitAt : (1 m : Nat) -> ((m + n) `Copies` x) -@ LPair (m `Copies` x) (n `Copies` x)
  Split copies into two

  Totality: total
  Visibility: export
(++) : (m `Copies` x) -@ ((n `Copies` x) -@ ((m + n) `Copies` x))
  Combine multiple copies into one

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 7
unzip : (m `Copies` (x # y)) -@ LPair (m `Copies` x) (m `Copies` y)
  Copies of pairs are like pairs of copies

  Totality: total
  Visibility: export
pure : (x : a) -> n `Copies` x
  Totality: total
  Visibility: export
(<*>) : (m `Copies` f) -@ ((m `Copies` x) -@ (m `Copies` f x))
  Applies m copies of a linear function to m arguments, resulting in m copies
  of the result.

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 3
(<$>) : (f : a -@ b) -> (m `Copies` x) -@ (m `Copies` f x)
  Apply f to `m` copies of `x`, resulting in `m` copies of `f x`.
  
  Note that this is not quite `pure f <*> xs` because we don't actually
  need to know `m` to be able to define `(<$>)` as we can proceed by
  induction on xs.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 4
zip : (m `Copies` x) -@ ((m `Copies` y) -@ (m `Copies` (x # y)))
  Combine copies of two values into a pair of copies

  Totality: total
  Visibility: export
extract : (1 `Copies` x) -@ a
  If we have a single copy, we can extract its value

  Totality: total
  Visibility: export
pair : (2 `Copies` x) -@ LPair a a
  Extract 2 copies into a linear pair

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/linear/docs/Data.Linear.Interface.html b/linear/docs/Data.Linear.Interface.html
index c489de60ed..93b55d5737 100644
--- a/linear/docs/Data.Linear.Interface.html
+++ b/linear/docs/Data.Linear.Interface.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Linear.Interface(source)
Reexports
import public Data.Linear.Copies
Definitions
interface Consumable : Type -> Type
  An interface for consumable types

  Parameters: a
Methods:
  
consume : a -@ ()

Implementations:
  
Consumable Void
  
Consumable ()
  
Consumable Bool
  
Consumable ((!*) a)
  
Consumable Int
consume : Consumable a => a -@ ()
  Totality: total
  Visibility: public export
seq : Consumable a => a -@ (b -@ b)
  We can sequentially compose a computation returning a value that is
  consumable with another computation. This is done by first consuming
  the result of the first computation and then returning the second one.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 5
interface Duplicable : Type -> Type
  Parameters: a
Methods:
  
duplicate : (1 v : a) -> 2 `Copies` v

Implementations:
  
Duplicable Void
  
Duplicable ()
  
Duplicable Bool
  
Duplicable ((!*) a)
duplicate : Duplicable a => (1 v : a) -> 2 `Copies` v
  Totality: total
  Visibility: public export
interface Comonoid : Type -> Type
  Comonoid is the dual of Monoid, it can consume a value linearly and duplicate a value linearly
  `comult` returns a pair instead of 2 copies, because we do not guarantee that the two values
  are identical, unlike with `duplicate`. For example if we build a comonoid out of a group, with
  comult returning both the element given and its inverse:
  comult x = x # inverse x
  It is not necessarily the case that x equals its inverse. For example the finite groupe of size
  3, has 1 and 2 as inverses of each other wrt to addition, but are not the same.

  Parameters: a
Methods:
  
counit : a -@ ()
  
comult : a -@ LPair a a

Implementation: 
Comonoid ((!*) a)
counit : Comonoid a => a -@ ()
  Totality: total
  Visibility: public export
comult : Comonoid a => a -@ LPair a a
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Linear.Interface(source)
Reexports
import public Data.Linear.Copies
Definitions
interface Consumable : Type -> Type
  An interface for consumable types

  Parameters: a
Methods:
  
consume : a -@ ()

Implementations:
  
Consumable Void
  
Consumable ()
  
Consumable Bool
  
Consumable ((!*) a)
  
Consumable Int
consume : Consumable a => a -@ ()
  Totality: total
  Visibility: public export
seq : Consumable a => a -@ (b -@ b)
  We can sequentially compose a computation returning a value that is
  consumable with another computation. This is done by first consuming
  the result of the first computation and then returning the second one.

  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 5
interface Duplicable : Type -> Type
  Parameters: a
Methods:
  
duplicate : (1 v : a) -> 2 `Copies` v

Implementations:
  
Duplicable Void
  
Duplicable ()
  
Duplicable Bool
  
Duplicable ((!*) a)
duplicate : Duplicable a => (1 v : a) -> 2 `Copies` v
  Totality: total
  Visibility: public export
interface Comonoid : Type -> Type
  Comonoid is the dual of Monoid, it can consume a value linearly and duplicate a value linearly
  `comult` returns a pair instead of 2 copies, because we do not guarantee that the two values
  are identical, unlike with `duplicate`. For example if we build a comonoid out of a group, with
  comult returning both the element given and its inverse:
  comult x = x # inverse x
  It is not necessarily the case that x equals its inverse. For example the finite groupe of size
  3, has 1 and 2 as inverses of each other wrt to addition, but are not the same.

  Parameters: a
Methods:
  
counit : a -@ ()
  
comult : a -@ LPair a a

Implementation: 
Comonoid ((!*) a)
counit : Comonoid a => a -@ ()
  Totality: total
  Visibility: public export
comult : Comonoid a => a -@ LPair a a
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/linear/docs/Data.Linear.LEither.html b/linear/docs/Data.Linear.LEither.html
index 04974f173d..9e152fbfa7 100644
--- a/linear/docs/Data.Linear.LEither.html
+++ b/linear/docs/Data.Linear.LEither.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Linear.LEither(source)
Definitions
data LEither : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Left : a -@ LEither a b
  
Right : b -@ LEither a b

  Hints:
  
(Consumable a, Consumable b) => Consumable (LEither a b)
  
(Duplicable a, Duplicable b) => Duplicable (LEither a b)

\ No newline at end of file
+
Data.Linear.LEither(source)
Definitions
data LEither : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Left : a -@ LEither a b
  
Right : b -@ LEither a b

  Hints:
  
(Consumable a, Consumable b) => Consumable (LEither a b)
  
(Duplicable a, Duplicable b) => Duplicable (LEither a b)

\ No newline at end of file
diff --git a/linear/docs/Data.Linear.LList.html b/linear/docs/Data.Linear.LList.html
index 533faac5e8..331927f17d 100644
--- a/linear/docs/Data.Linear.LList.html
+++ b/linear/docs/Data.Linear.LList.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Linear.LList(source)
Definitions
data LList : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : LList a
  
(::) : a -@ (LList a -@ LList a)

  Hints:
  
Consumable a => Consumable (LList a)
  
Duplicable a => Duplicable (LList a)
length : Consumable a => LList a -@ LNat
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Linear.LList(source)
Definitions
data LList : Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : LList a
  
(::) : a -@ (LList a -@ LList a)

  Hints:
  
Consumable a => Consumable (LList a)
  
Duplicable a => Duplicable (LList a)
length : Consumable a => LList a -@ LNat
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/linear/docs/Data.Linear.LMaybe.html b/linear/docs/Data.Linear.LMaybe.html
index ab5472adc4..3e252e22b4 100644
--- a/linear/docs/Data.Linear.LMaybe.html
+++ b/linear/docs/Data.Linear.LMaybe.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Linear.LMaybe(source)
Definitions
data LMaybe : Type -> Type
  Linear version of Maybe

  Totality: total
  Visibility: public export
  Constructors:
  
Nothing : LMaybe a
  
Just : a -@ LMaybe a

  Hints:
  
Consumable a => Consumable (LMaybe a)
  
Duplicable a => Duplicable (LMaybe a)
(<$>) : a -@ b -> LMaybe a -@ LMaybe b
  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 4

\ No newline at end of file
+
Data.Linear.LMaybe(source)
Definitions
data LMaybe : Type -> Type
  Linear version of Maybe

  Totality: total
  Visibility: public export
  Constructors:
  
Nothing : LMaybe a
  
Just : a -@ LMaybe a

  Hints:
  
Consumable a => Consumable (LMaybe a)
  
Duplicable a => Duplicable (LMaybe a)
(<$>) : a -@ b -> LMaybe a -@ LMaybe b
  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 4

\ No newline at end of file
diff --git a/linear/docs/Data.Linear.LNat.html b/linear/docs/Data.Linear.LNat.html
index 0150102550..346509b3fd 100644
--- a/linear/docs/Data.Linear.LNat.html
+++ b/linear/docs/Data.Linear.LNat.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Linear.LNat(source)
Definitions
data LNat : Type
  Linear Nat

  Totality: total
  Visibility: public export
  Constructors:
  
Zero : LNat
  
Succ : LNat -@ LNat

  Hints:
  
Consumable LNat
  
Duplicable LNat
0 toNat : LNat -@ Nat
  Convert a linear nat to an unrestricted Nat, only usable at the type level
  because we canot call `S` with an argument that is expected to be used exactly once

  Totality: total
  Visibility: public export
add : LNat -@ (LNat -@ LNat)
  Add two linear numbers

  Totality: total
  Visibility: export
mult : (1 n : LNat) -> (0 l : LNat) -> {auto 1 _ : toNat n `Copies` l} -> LNat
  Multiply two linear numbers

  Totality: total
  Visibility: export
square : (1 v : LNat) -> {auto 1 _ : toNat v `Copies` v} -> LNat
  Square a linear number

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Linear.LNat(source)
Definitions
data LNat : Type
  Linear Nat

  Totality: total
  Visibility: public export
  Constructors:
  
Zero : LNat
  
Succ : LNat -@ LNat

  Hints:
  
Consumable LNat
  
Duplicable LNat
0 toNat : LNat -@ Nat
  Convert a linear nat to an unrestricted Nat, only usable at the type level
  because we canot call `S` with an argument that is expected to be used exactly once

  Totality: total
  Visibility: public export
add : LNat -@ (LNat -@ LNat)
  Add two linear numbers

  Totality: total
  Visibility: export
mult : (1 n : LNat) -> (0 l : LNat) -> {auto 1 _ : toNat n `Copies` l} -> LNat
  Multiply two linear numbers

  Totality: total
  Visibility: export
square : (1 v : LNat) -> {auto 1 _ : toNat v `Copies` v} -> LNat
  Square a linear number

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/linear/docs/Data.Linear.LVect.html b/linear/docs/Data.Linear.LVect.html
index 03c133a2a0..563edc6fbc 100644
--- a/linear/docs/Data.Linear.LVect.html
+++ b/linear/docs/Data.Linear.LVect.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Linear.LVect(source)
Definitions
data LVect : Nat -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : LVect 0 a
  
(::) : a -@ (LVect n a -@ LVect (S n) a)

  Hints:
  
Consumable a => Consumable (LVect n a)
  
Duplicable a => Duplicable (LVect n a)
lookup : Fin (S n) -@ (LVect (S n) a -@ LPair a (LVect n a))
  Totality: total
  Visibility: export
insertAt : Fin (S n) -@ (a -@ (LVect n a -@ LVect (S n) a))
  Totality: total
  Visibility: export
uncurry : (a -@ (b -@ c)) -@ (LPair a b -@ c)
  Totality: total
  Visibility: export
lookupInsertAtIdentity : (k : Fin (S n)) -> (vs : LVect (S n) a) -> uncurry (insertAt k) (lookup k vs) = vs
  Totality: total
  Visibility: export
insertAtLookupIdentity : (k : Fin (S n)) -> (w : a) -> (vs : LVect n a) -> lookup k (insertAt k w vs) = w # vs
  Totality: total
  Visibility: export
(<$>) : a -@ b -> LVect n a -@ LVect n b
  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 4
pure : a -> LVect n a
  Totality: total
  Visibility: export
(<*>) : LVect n (a -@ b) -@ (LVect n a -@ LVect n b)
  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 3
zip : LVect n a -@ (LVect n b -@ LVect n (LPair a b))
  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 6
unzip : LVect n (LPair a b) -@ LPair (LVect n a) (LVect n b)
  Totality: total
  Visibility: export
splitAt : (1 m : Nat) -> LVect (m + n) a -@ LPair (LVect m a) (LVect n a)
  Totality: total
  Visibility: export
(++) : LVect m a -@ (LVect n a -@ LVect (m + n) a)
  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 7
lfoldr : (0 p : (Nat -> Type)) -> a -@ (p n -@ p (S n)) -> p 0 -@ (LVect n a -@ p n)
  Totality: total
  Visibility: export
lfoldl : (0 p : (Nat -> Type)) -> a -@ (p n -@ p (S n)) -> p 0 -@ (LVect n a -@ p n)
  Totality: total
  Visibility: export
reverse : LVect m a -@ LVect m a
  Totality: total
  Visibility: export
map : (0 f : a -@ b) -> {auto 1 _ : n `Copies` f} -> LVect n a -@ LVect n b
  Map a linear vector

  Totality: total
  Visibility: export
length : Consumable a => LVect n a -@ LNat
  Extract all

  Totality: total
  Visibility: export
foldl : (0 f : acc -@ (a -@ acc)) -> {auto 1 _ : n `Copies` f} -> acc -@ (LVect n a -@ acc)
  Fold a linear vector.

  Totality: total
  Visibility: export
replicate : (1 n : LNat) -> (0 v : a) -> {auto 1 _ : toNat n `Copies` v} -> LVect (toNat n) a
  Totality: total
  Visibility: export
(>>=) : LVect n a -@ ((0 f : a -@ LVect m b) -> LVect (n * m) b)
  Bind a linear vector.

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 1
copiesToVect : (n `Copies` v) -@ LVect n a
  Extract all the copies into a vector of the same length as the number of copies.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Linear.LVect(source)
Definitions
data LVect : Nat -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : LVect 0 a
  
(::) : a -@ (LVect n a -@ LVect (S n) a)

  Hints:
  
Consumable a => Consumable (LVect n a)
  
Duplicable a => Duplicable (LVect n a)
lookup : Fin (S n) -@ (LVect (S n) a -@ LPair a (LVect n a))
  Totality: total
  Visibility: export
insertAt : Fin (S n) -@ (a -@ (LVect n a -@ LVect (S n) a))
  Totality: total
  Visibility: export
uncurry : (a -@ (b -@ c)) -@ (LPair a b -@ c)
  Totality: total
  Visibility: export
lookupInsertAtIdentity : (k : Fin (S n)) -> (vs : LVect (S n) a) -> uncurry (insertAt k) (lookup k vs) = vs
  Totality: total
  Visibility: export
insertAtLookupIdentity : (k : Fin (S n)) -> (w : a) -> (vs : LVect n a) -> lookup k (insertAt k w vs) = w # vs
  Totality: total
  Visibility: export
(<$>) : a -@ b -> LVect n a -@ LVect n b
  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 4
pure : a -> LVect n a
  Totality: total
  Visibility: export
(<*>) : LVect n (a -@ b) -@ (LVect n a -@ LVect n b)
  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 3
zip : LVect n a -@ (LVect n b -@ LVect n (LPair a b))
  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 6
unzip : LVect n (LPair a b) -@ LPair (LVect n a) (LVect n b)
  Totality: total
  Visibility: export
splitAt : (1 m : Nat) -> LVect (m + n) a -@ LPair (LVect m a) (LVect n a)
  Totality: total
  Visibility: export
(++) : LVect m a -@ (LVect n a -@ LVect (m + n) a)
  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 7
lfoldr : (0 p : (Nat -> Type)) -> a -@ (p n -@ p (S n)) -> p 0 -@ (LVect n a -@ p n)
  Totality: total
  Visibility: export
lfoldl : (0 p : (Nat -> Type)) -> a -@ (p n -@ p (S n)) -> p 0 -@ (LVect n a -@ p n)
  Totality: total
  Visibility: export
reverse : LVect m a -@ LVect m a
  Totality: total
  Visibility: export
map : (0 f : a -@ b) -> {auto 1 _ : n `Copies` f} -> LVect n a -@ LVect n b
  Map a linear vector

  Totality: total
  Visibility: export
length : Consumable a => LVect n a -@ LNat
  Extract all

  Totality: total
  Visibility: export
foldl : (0 f : acc -@ (a -@ acc)) -> {auto 1 _ : n `Copies` f} -> acc -@ (LVect n a -@ acc)
  Fold a linear vector.

  Totality: total
  Visibility: export
replicate : (1 n : LNat) -> (0 v : a) -> {auto 1 _ : toNat n `Copies` v} -> LVect (toNat n) a
  Totality: total
  Visibility: export
(>>=) : LVect n a -@ ((0 f : a -@ LVect m b) -> LVect (n * m) b)
  Bind a linear vector.

  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 1
copiesToVect : (n `Copies` v) -@ LVect n a
  Extract all the copies into a vector of the same length as the number of copies.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/linear/docs/Data.Linear.List.LQuantifiers.html b/linear/docs/Data.Linear.List.LQuantifiers.html
index 0895d2dbff..90d9d72d49 100644
--- a/linear/docs/Data.Linear.List.LQuantifiers.html
+++ b/linear/docs/Data.Linear.List.LQuantifiers.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Linear.List.LQuantifiers(source)
Definitions
data LAll : (a -> Type) -> List a -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : LAll p []
  
(::) : p x -@ (LAll p xs -@ LAll p (x :: xs))

\ No newline at end of file
+
Data.Linear.List.LQuantifiers(source)
Definitions
data LAll : (a -> Type) -> List a -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : LAll p []
  
(::) : p x -@ (LAll p xs -@ LAll p (x :: xs))

\ No newline at end of file
diff --git a/linear/docs/Data.Linear.Notation.html b/linear/docs/Data.Linear.Notation.html
index 3fd4de5cc4..afad47255f 100644
--- a/linear/docs/Data.Linear.Notation.html
+++ b/linear/docs/Data.Linear.Notation.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Linear.Notation(source)
Definitions
(-@) : Type -> Type -> Type
  Infix notation for linear implication

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 0
id : a -@ a
  Linear identity function

  Totality: total
  Visibility: public export
(.) : (b -@ c) -@ ((a -@ b) -@ (a -@ c))
  Linear function composition

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 9
record (!*) : Type -> Type
  Prefix notation for the linear unrestricted modality

  Totality: total
  Visibility: public export
  Constructor: 
MkBang : a -> (!*) a

  Projection: 
.unrestricted : (!*) a -> a

  Hints:
  
Comonoid ((!*) a)
  
Consumable ((!*) a)
  
Duplicable ((!*) a)

  Fixity Declaration: prefix operator, level 5
.unrestricted : (!*) a -> a
  Totality: total
  Visibility: public export
unrestricted : (!*) a -> a
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Linear.Notation(source)
Definitions
(-@) : Type -> Type -> Type
  Infix notation for linear implication

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 0
id : a -@ a
  Linear identity function

  Totality: total
  Visibility: public export
(.) : (b -@ c) -@ ((a -@ b) -@ (a -@ c))
  Linear function composition

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 9
record (!*) : Type -> Type
  Prefix notation for the linear unrestricted modality

  Totality: total
  Visibility: public export
  Constructor: 
MkBang : a -> (!*) a

  Projection: 
.unrestricted : (!*) a -> a

  Hints:
  
Comonoid ((!*) a)
  
Consumable ((!*) a)
  
Duplicable ((!*) a)

  Fixity Declaration: prefix operator, level 5
.unrestricted : (!*) a -> a
  Totality: total
  Visibility: public export
unrestricted : (!*) a -> a
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/linear/docs/Data.Linear.html b/linear/docs/Data.Linear.html
index 2e8e53d2a0..686cd66e66 100644
--- a/linear/docs/Data.Linear.html
+++ b/linear/docs/Data.Linear.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Linear(source)
Reexports
import public Data.Linear.Notation as Data.Linear
import public Data.Linear.Interface as Data.Linear
import public Data.Linear.Copies as Data.Linear

\ No newline at end of file
+
Data.Linear(source)
Reexports
import public Data.Linear.Notation as Data.Linear
import public Data.Linear.Interface as Data.Linear
import public Data.Linear.Copies as Data.Linear

\ No newline at end of file
diff --git a/linear/index.html b/linear/index.html
index 178b997f68..727f9ba4f1 100644
--- a/linear/index.html
+++ b/linear/index.html
@@ -61,4 +61,4 @@
 
 
 
-
Package linear - Namespaces

\ No newline at end of file
+
Package linear - Namespaces

\ No newline at end of file
diff --git a/network/docs/Control.Linear.Network.html b/network/docs/Control.Linear.Network.html
index fc82226064..df86836d22 100644
--- a/network/docs/Control.Linear.Network.html
+++ b/network/docs/Control.Linear.Network.html
@@ -61,4 +61,4 @@
 
 
 
-
Control.Linear.Network(source)
Reexports
import public Data.Either
import public Data.Maybe
import public Network.Socket.Data
Definitions
data SocketState : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Ready : SocketState
  
Bound : SocketState
  
Listening : SocketState
  
Open : SocketState
  
Closed : SocketState
data Action : SocketState -> Type
  Define the domain of SocketState transitions.
  Label every such transition.

  Totality: total
  Visibility: public export
  Constructors:
  
Bind : Action Ready
  
Listen : Action Bound
  
Accept : Action Listening
  
Connect : Action Ready
  
Send : Action Open
  
Receive : Action Open
  
Close : Action st
data Socket : SocketState -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkSocket : Socket -> Socket st
Next : Action st -> Bool -> Type
  For every label of a SocketState transition
  and a success value of the transition,
  define its result.

  Visibility: public export
newSocket : LinearIO io => SocketFamily -> SocketType -> ProtocolNumber -> ((1 _ : Socket Ready) -> L io ()) -> (SocketError -> L io ()) -> L io ()
  Visibility: export
close : LinearIO io => (1 _ : Socket st) -> L1 io (Socket Closed)
  Visibility: export
done : LinearIO io => (1 _ : Socket Closed) -> L io ()
  Visibility: export
bind : LinearIO io => (1 _ : Socket Ready) -> Maybe SocketAddress -> Port -> L1 io (Res (Maybe SocketError) (\res => Next Bind (isNothing res)))
  Visibility: export
connect : LinearIO io => (1 _ : Socket Ready) -> SocketAddress -> Port -> L1 io (Res (Maybe SocketError) (\res => Next Connect (isNothing res)))
  Visibility: export
listen : LinearIO io => (1 _ : Socket Bound) -> L1 io (Res (Maybe SocketError) (\res => Next Listen (isNothing res)))
  Visibility: export
accept : LinearIO io => (1 _ : Socket Listening) -> L1 io (Res (Maybe SocketError) (\res => Next Accept (isNothing res)))
  Visibility: export
send : LinearIO io => (1 _ : Socket Open) -> String -> L1 io (Res (Maybe SocketError) (\res => Next Send (isNothing res)))
  Visibility: export
recv : LinearIO io => (1 _ : Socket Open) -> ByteLength -> L1 io (Res (Either SocketError (String, ResultCode)) (\res => Next Receive (isRight res)))
  Visibility: export
recvAll : LinearIO io => (1 _ : Socket Open) -> L1 io (Res (Either SocketError String) (\res => Next Receive (isRight res)))
  Visibility: export
sendBytes : LinearIO io => (1 _ : Socket Open) -> List Bits8 -> L1 io (Res (Maybe SocketError) (\res => Next Send (isNothing res)))
  Visibility: export
recvBytes : LinearIO io => (1 _ : Socket Open) -> ByteLength -> L1 io (Res (Either SocketError (List Bits8)) (\res => Next Receive (isRight res)))
  Visibility: export
recvAllBytes : LinearIO io => (1 _ : Socket Open) -> L1 io (Res (Either SocketError (List Bits8)) (\res => Next Receive (isRight res)))
  Visibility: export

\ No newline at end of file
+
Control.Linear.Network(source)
Reexports
import public Data.Either
import public Data.Maybe
import public Network.Socket.Data
Definitions
data SocketState : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Ready : SocketState
  
Bound : SocketState
  
Listening : SocketState
  
Open : SocketState
  
Closed : SocketState
data Action : SocketState -> Type
  Define the domain of SocketState transitions.
  Label every such transition.

  Totality: total
  Visibility: public export
  Constructors:
  
Bind : Action Ready
  
Listen : Action Bound
  
Accept : Action Listening
  
Connect : Action Ready
  
Send : Action Open
  
Receive : Action Open
  
Close : Action st
data Socket : SocketState -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkSocket : Socket -> Socket st
Next : Action st -> Bool -> Type
  For every label of a SocketState transition
  and a success value of the transition,
  define its result.

  Visibility: public export
newSocket : LinearIO io => SocketFamily -> SocketType -> ProtocolNumber -> ((1 _ : Socket Ready) -> L io ()) -> (SocketError -> L io ()) -> L io ()
  Visibility: export
close : LinearIO io => (1 _ : Socket st) -> L1 io (Socket Closed)
  Visibility: export
done : LinearIO io => (1 _ : Socket Closed) -> L io ()
  Visibility: export
bind : LinearIO io => (1 _ : Socket Ready) -> Maybe SocketAddress -> Port -> L1 io (Res (Maybe SocketError) (\res => Next Bind (isNothing res)))
  Visibility: export
connect : LinearIO io => (1 _ : Socket Ready) -> SocketAddress -> Port -> L1 io (Res (Maybe SocketError) (\res => Next Connect (isNothing res)))
  Visibility: export
listen : LinearIO io => (1 _ : Socket Bound) -> L1 io (Res (Maybe SocketError) (\res => Next Listen (isNothing res)))
  Visibility: export
accept : LinearIO io => (1 _ : Socket Listening) -> L1 io (Res (Maybe SocketError) (\res => Next Accept (isNothing res)))
  Visibility: export
send : LinearIO io => (1 _ : Socket Open) -> String -> L1 io (Res (Maybe SocketError) (\res => Next Send (isNothing res)))
  Visibility: export
recv : LinearIO io => (1 _ : Socket Open) -> ByteLength -> L1 io (Res (Either SocketError (String, ResultCode)) (\res => Next Receive (isRight res)))
  Visibility: export
recvAll : LinearIO io => (1 _ : Socket Open) -> L1 io (Res (Either SocketError String) (\res => Next Receive (isRight res)))
  Visibility: export
sendBytes : LinearIO io => (1 _ : Socket Open) -> List Bits8 -> L1 io (Res (Maybe SocketError) (\res => Next Send (isNothing res)))
  Visibility: export
recvBytes : LinearIO io => (1 _ : Socket Open) -> ByteLength -> L1 io (Res (Either SocketError (List Bits8)) (\res => Next Receive (isRight res)))
  Visibility: export
recvAllBytes : LinearIO io => (1 _ : Socket Open) -> L1 io (Res (Either SocketError (List Bits8)) (\res => Next Receive (isRight res)))
  Visibility: export

\ No newline at end of file
diff --git a/network/docs/Network.FFI.html b/network/docs/Network.FFI.html
index 9372d4b59f..603927e580 100644
--- a/network/docs/Network.FFI.html
+++ b/network/docs/Network.FFI.html
@@ -64,4 +64,4 @@
 
Network.FFI(source)
FFI binding to the low-Level C Sockets bindings for Idris.
 
 Modified (C) The Idris Community, 2020
-
Definitions
prim__idrnet_socket : Int -> Int -> Int -> PrimIO Int
prim__idrnet_close : SocketDescriptor -> PrimIO Int
prim__idrnet_bind : SocketDescriptor -> Int -> Int -> String -> Port -> PrimIO Int
prim__idrnet_connect : SocketDescriptor -> Int -> Int -> String -> Port -> PrimIO Int
prim__idrnet_listen : SocketDescriptor -> Int -> PrimIO Int
prim__idrnet_fdopen : Int -> String -> PrimIO AnyPtr
prim__idrnet_sockaddr_family : AnyPtr -> PrimIO Int
prim__idrnet_sockaddr_ipv4 : AnyPtr -> PrimIO String
prim__idrnet_sockaddr_unix : AnyPtr -> PrimIO String
prim__idrnet_sockaddr_ipv4_port : AnyPtr -> PrimIO Int
prim__idrnet_sockaddr_port : SocketDescriptor -> PrimIO Int
prim__idrnet_create_sockaddr : PrimIO AnyPtr
prim__idrnet_accept : SocketDescriptor -> AnyPtr -> PrimIO Int
prim__idrnet_send : SocketDescriptor -> String -> PrimIO Int
prim__idrnet_send_bytes : SocketDescriptor -> Buffer -> Int -> Bits32 -> PrimIO Int
prim__idrnet_send_buf : SocketDescriptor -> AnyPtr -> Int -> PrimIO Int
prim__idrnet_recv : SocketDescriptor -> Int -> PrimIO AnyPtr
prim__idrnet_recv_bytes : SocketDescriptor -> Buffer -> Int -> Int -> PrimIO Int
prim__idrnet_recv_buf : SocketDescriptor -> AnyPtr -> Int -> PrimIO Int
prim__idrnet_sendto : SocketDescriptor -> String -> String -> Port -> Int -> PrimIO Int
prim__idrnet_sendto_buf : SocketDescriptor -> AnyPtr -> Int -> String -> Port -> Int -> PrimIO Int
prim__idrnet_recvfrom : SocketDescriptor -> Int -> PrimIO AnyPtr
prim__idrnet_recvfrom_buf : SocketDescriptor -> AnyPtr -> Int -> PrimIO AnyPtr
prim__idrnet_get_recv_res : AnyPtr -> PrimIO Int
prim__idrnet_get_recv_payload : AnyPtr -> PrimIO String
prim__idrnet_free_recv_struct : AnyPtr -> PrimIO ()
prim__idrnet_get_recvfrom_res : AnyPtr -> PrimIO Int
prim__idrnet_get_recvfrom_payload : AnyPtr -> PrimIO String
prim__idrnet_get_recvfrom_sockaddr : AnyPtr -> PrimIO AnyPtr
prim__idrnet_free_recvfrom_struct : AnyPtr -> PrimIO ()
prim__idrnet_geteagain : PrimIO Int
prim__idrnet_errno : PrimIO Int
prim__idrnet_peek : AnyPtr -> Int -> PrimIO Int
prim__idrnet_poke : AnyPtr -> Int -> Int -> PrimIO ()

\ No newline at end of file
+
Definitions
prim__idrnet_socket : Int -> Int -> Int -> PrimIO Int
prim__idrnet_close : SocketDescriptor -> PrimIO Int
prim__idrnet_bind : SocketDescriptor -> Int -> Int -> String -> Port -> PrimIO Int
prim__idrnet_connect : SocketDescriptor -> Int -> Int -> String -> Port -> PrimIO Int
prim__idrnet_listen : SocketDescriptor -> Int -> PrimIO Int
prim__idrnet_fdopen : Int -> String -> PrimIO AnyPtr
prim__idrnet_sockaddr_family : AnyPtr -> PrimIO Int
prim__idrnet_sockaddr_ipv4 : AnyPtr -> PrimIO String
prim__idrnet_sockaddr_unix : AnyPtr -> PrimIO String
prim__idrnet_sockaddr_ipv4_port : AnyPtr -> PrimIO Int
prim__idrnet_sockaddr_port : SocketDescriptor -> PrimIO Int
prim__idrnet_create_sockaddr : PrimIO AnyPtr
prim__idrnet_accept : SocketDescriptor -> AnyPtr -> PrimIO Int
prim__idrnet_send : SocketDescriptor -> String -> PrimIO Int
prim__idrnet_send_bytes : SocketDescriptor -> Buffer -> Int -> Bits32 -> PrimIO Int
prim__idrnet_send_buf : SocketDescriptor -> AnyPtr -> Int -> PrimIO Int
prim__idrnet_recv : SocketDescriptor -> Int -> PrimIO AnyPtr
prim__idrnet_recv_bytes : SocketDescriptor -> Buffer -> Int -> Int -> PrimIO Int
prim__idrnet_recv_buf : SocketDescriptor -> AnyPtr -> Int -> PrimIO Int
prim__idrnet_sendto : SocketDescriptor -> String -> String -> Port -> Int -> PrimIO Int
prim__idrnet_sendto_buf : SocketDescriptor -> AnyPtr -> Int -> String -> Port -> Int -> PrimIO Int
prim__idrnet_recvfrom : SocketDescriptor -> Int -> PrimIO AnyPtr
prim__idrnet_recvfrom_buf : SocketDescriptor -> AnyPtr -> Int -> PrimIO AnyPtr
prim__idrnet_get_recv_res : AnyPtr -> PrimIO Int
prim__idrnet_get_recv_payload : AnyPtr -> PrimIO String
prim__idrnet_free_recv_struct : AnyPtr -> PrimIO ()
prim__idrnet_get_recvfrom_res : AnyPtr -> PrimIO Int
prim__idrnet_get_recvfrom_payload : AnyPtr -> PrimIO String
prim__idrnet_get_recvfrom_sockaddr : AnyPtr -> PrimIO AnyPtr
prim__idrnet_free_recvfrom_struct : AnyPtr -> PrimIO ()
prim__idrnet_geteagain : PrimIO Int
prim__idrnet_errno : PrimIO Int
prim__idrnet_peek : AnyPtr -> Int -> PrimIO Int
prim__idrnet_poke : AnyPtr -> Int -> Int -> PrimIO ()

\ No newline at end of file
diff --git a/network/docs/Network.Socket.Data.html b/network/docs/Network.Socket.Data.html
index 38237827f8..d4ad97a585 100644
--- a/network/docs/Network.Socket.Data.html
+++ b/network/docs/Network.Socket.Data.html
@@ -66,4 +66,4 @@
 
 Original (C) SimonJF, MIT Licensed, 2014
 Modified (C) The Idris Community, 2015, 2016, 2019
-
Definitions
ByteLength : Type
  Visibility: public export
ResultCode : Type
  Visibility: public export
ProtocolNumber : Type
  Protocol Number.
  
  Generally good enough to just set it to 0.

  Visibility: public export
SocketError : Type
  SocketError: Error thrown by a socket operation

  Visibility: public export
SocketDescriptor : Type
  SocketDescriptor: Native C Socket Descriptor

  Visibility: public export
Port : Type
  Visibility: public export
BACKLOG : Int
  Backlog used within listen() call -- number of incoming calls

  Visibility: export
EAGAIN : Int
  Visibility: export
getErrno : HasIO io => io SocketError
  Visibility: export
nullPtr : HasIO io => AnyPtr -> io Bool
  Visibility: export
interface ToCode : Type -> Type
  Parameters: a
Methods:
  
toCode : a -> Int

Implementations:
  
ToCode SocketFamily
  
ToCode SocketType
toCode : ToCode a => a -> Int
  Visibility: public export
data SocketFamily : Type
  Socket Families
  
  The ones that people might actually use. We're not going to need US
  Government proprietary ones.

  Totality: total
  Visibility: public export
  Constructors:
  
AF_UNSPEC : SocketFamily
  Unspecified
  
AF_UNIX : SocketFamily
  Unix type sockets
  
AF_INET : SocketFamily
  IP / UDP etc. IPv4
  
AF_INET6 : SocketFamily
   IP / UDP etc. IPv6

  Hints:
  
Show SocketFamily
  
ToCode SocketFamily
getSocketFamily : Int -> Maybe SocketFamily
  Visibility: export
data SocketType : Type
  Socket Types.

  Totality: total
  Visibility: public export
  Constructors:
  
NotASocket : SocketType
  Not a socket, used in certain operations
  
Stream : SocketType
  TCP
  
Datagram : SocketType
  UDP
  
RawSocket : SocketType
  Raw sockets

  Hints:
  
Show SocketType
  
ToCode SocketType
data SocketAddress : Type
  Network Addresses

  Totality: total
  Visibility: public export
  Constructors:
  
IPv4Addr : Int -> Int -> Int -> Int -> SocketAddress
  
IPv6Addr : SocketAddress
  Not implemented (yet)
  
Hostname : String -> SocketAddress
  
InvalidAddress : SocketAddress
  Used when there's a parse error

  Hint: 
Show SocketAddress
parseIPv4 : String -> SocketAddress
  Parses a textual representation of an IPv4 address into a SocketAddress

  Visibility: export
record UDPRecvData : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkUDPRecvData : SocketAddress -> Port -> String -> Int -> UDPRecvData

  Projections:
  
.data_len : UDPRecvData -> Int
  
.recv_data : UDPRecvData -> String
  
.remote_addr : UDPRecvData -> SocketAddress
  
.remote_port : UDPRecvData -> Port
.remote_addr : UDPRecvData -> SocketAddress
  Visibility: public export
remote_addr : UDPRecvData -> SocketAddress
  Visibility: public export
.remote_port : UDPRecvData -> Port
  Visibility: public export
remote_port : UDPRecvData -> Port
  Visibility: public export
.recv_data : UDPRecvData -> String
  Visibility: public export
recv_data : UDPRecvData -> String
  Visibility: public export
.data_len : UDPRecvData -> Int
  Visibility: public export
data_len : UDPRecvData -> Int
  Visibility: public export
record UDPAddrInfo : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkUDPAddrInfo : SocketAddress -> Port -> UDPAddrInfo

  Projections:
  
.remote_addr : UDPAddrInfo -> SocketAddress
  
.remote_port : UDPAddrInfo -> Port
.remote_addr : UDPAddrInfo -> SocketAddress
  Visibility: public export
remote_addr : UDPAddrInfo -> SocketAddress
  Visibility: public export
.remote_port : UDPAddrInfo -> Port
  Visibility: public export
remote_port : UDPAddrInfo -> Port
  Visibility: public export
record Socket : Type
  The metadata about a socket

  Totality: total
  Visibility: public export
  Constructor: 
MkSocket : SocketDescriptor -> SocketFamily -> SocketType -> ProtocolNumber -> Socket

  Projections:
  
.descriptor : Socket -> SocketDescriptor
  
.family : Socket -> SocketFamily
  
.protocolNumber : Socket -> ProtocolNumber
  
.socketType : Socket -> SocketType
.descriptor : Socket -> SocketDescriptor
  Visibility: public export
descriptor : Socket -> SocketDescriptor
  Visibility: public export
.family : Socket -> SocketFamily
  Visibility: public export
family : Socket -> SocketFamily
  Visibility: public export
.socketType : Socket -> SocketType
  Visibility: public export
socketType : Socket -> SocketType
  Visibility: public export
.protocolNumber : Socket -> ProtocolNumber
  Visibility: public export
protocolNumber : Socket -> ProtocolNumber
  Visibility: public export

\ No newline at end of file
+
Definitions
ByteLength : Type
  Visibility: public export
ResultCode : Type
  Visibility: public export
ProtocolNumber : Type
  Protocol Number.
  
  Generally good enough to just set it to 0.

  Visibility: public export
SocketError : Type
  SocketError: Error thrown by a socket operation

  Visibility: public export
SocketDescriptor : Type
  SocketDescriptor: Native C Socket Descriptor

  Visibility: public export
Port : Type
  Visibility: public export
BACKLOG : Int
  Backlog used within listen() call -- number of incoming calls

  Visibility: export
EAGAIN : Int
  Visibility: export
getErrno : HasIO io => io SocketError
  Visibility: export
nullPtr : HasIO io => AnyPtr -> io Bool
  Visibility: export
interface ToCode : Type -> Type
  Parameters: a
Methods:
  
toCode : a -> Int

Implementations:
  
ToCode SocketFamily
  
ToCode SocketType
toCode : ToCode a => a -> Int
  Visibility: public export
data SocketFamily : Type
  Socket Families
  
  The ones that people might actually use. We're not going to need US
  Government proprietary ones.

  Totality: total
  Visibility: public export
  Constructors:
  
AF_UNSPEC : SocketFamily
  Unspecified
  
AF_UNIX : SocketFamily
  Unix type sockets
  
AF_INET : SocketFamily
  IP / UDP etc. IPv4
  
AF_INET6 : SocketFamily
   IP / UDP etc. IPv6

  Hints:
  
Show SocketFamily
  
ToCode SocketFamily
getSocketFamily : Int -> Maybe SocketFamily
  Visibility: export
data SocketType : Type
  Socket Types.

  Totality: total
  Visibility: public export
  Constructors:
  
NotASocket : SocketType
  Not a socket, used in certain operations
  
Stream : SocketType
  TCP
  
Datagram : SocketType
  UDP
  
RawSocket : SocketType
  Raw sockets

  Hints:
  
Show SocketType
  
ToCode SocketType
data SocketAddress : Type
  Network Addresses

  Totality: total
  Visibility: public export
  Constructors:
  
IPv4Addr : Int -> Int -> Int -> Int -> SocketAddress
  
IPv6Addr : SocketAddress
  Not implemented (yet)
  
Hostname : String -> SocketAddress
  
InvalidAddress : SocketAddress
  Used when there's a parse error

  Hint: 
Show SocketAddress
parseIPv4 : String -> SocketAddress
  Parses a textual representation of an IPv4 address into a SocketAddress

  Visibility: export
record UDPRecvData : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkUDPRecvData : SocketAddress -> Port -> String -> Int -> UDPRecvData

  Projections:
  
.data_len : UDPRecvData -> Int
  
.recv_data : UDPRecvData -> String
  
.remote_addr : UDPRecvData -> SocketAddress
  
.remote_port : UDPRecvData -> Port
.remote_addr : UDPRecvData -> SocketAddress
  Visibility: public export
remote_addr : UDPRecvData -> SocketAddress
  Visibility: public export
.remote_port : UDPRecvData -> Port
  Visibility: public export
remote_port : UDPRecvData -> Port
  Visibility: public export
.recv_data : UDPRecvData -> String
  Visibility: public export
recv_data : UDPRecvData -> String
  Visibility: public export
.data_len : UDPRecvData -> Int
  Visibility: public export
data_len : UDPRecvData -> Int
  Visibility: public export
record UDPAddrInfo : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkUDPAddrInfo : SocketAddress -> Port -> UDPAddrInfo

  Projections:
  
.remote_addr : UDPAddrInfo -> SocketAddress
  
.remote_port : UDPAddrInfo -> Port
.remote_addr : UDPAddrInfo -> SocketAddress
  Visibility: public export
remote_addr : UDPAddrInfo -> SocketAddress
  Visibility: public export
.remote_port : UDPAddrInfo -> Port
  Visibility: public export
remote_port : UDPAddrInfo -> Port
  Visibility: public export
record Socket : Type
  The metadata about a socket

  Totality: total
  Visibility: public export
  Constructor: 
MkSocket : SocketDescriptor -> SocketFamily -> SocketType -> ProtocolNumber -> Socket

  Projections:
  
.descriptor : Socket -> SocketDescriptor
  
.family : Socket -> SocketFamily
  
.protocolNumber : Socket -> ProtocolNumber
  
.socketType : Socket -> SocketType
.descriptor : Socket -> SocketDescriptor
  Visibility: public export
descriptor : Socket -> SocketDescriptor
  Visibility: public export
.family : Socket -> SocketFamily
  Visibility: public export
family : Socket -> SocketFamily
  Visibility: public export
.socketType : Socket -> SocketType
  Visibility: public export
socketType : Socket -> SocketType
  Visibility: public export
.protocolNumber : Socket -> ProtocolNumber
  Visibility: public export
protocolNumber : Socket -> ProtocolNumber
  Visibility: public export

\ No newline at end of file
diff --git a/network/docs/Network.Socket.Raw.html b/network/docs/Network.Socket.Raw.html
index 72729e9772..9e7f35e2f9 100644
--- a/network/docs/Network.Socket.Raw.html
+++ b/network/docs/Network.Socket.Raw.html
@@ -66,4 +66,4 @@
 
 Original (C) SimonJF, MIT Licensed, 2014
 Modified (C) The Idris Community, 2015, 2016
-
Reexports
import public Network.Socket.Data
Definitions
data RecvStructPtr : Type
  Totality: total
  Visibility: public export
  Constructor: 
RSPtr : AnyPtr -> RecvStructPtr
data RecvfromStructPtr : Type
  Totality: total
  Visibility: public export
  Constructor: 
RFPtr : AnyPtr -> RecvfromStructPtr
data BufPtr : Type
  Totality: total
  Visibility: public export
  Constructor: 
BPtr : AnyPtr -> BufPtr
data SockaddrPtr : Type
  Totality: total
  Visibility: public export
  Constructor: 
SAPtr : AnyPtr -> SockaddrPtr
sock_poke : HasIO io => BufPtr -> Int -> Int -> io ()
  Put a value in a buffer

  Visibility: export
sock_peek : HasIO io => BufPtr -> Int -> io Int
  Take a value from a buffer

  Visibility: export
sock_free : HasIO io => BufPtr -> io ()
  Frees a given pointer

  Visibility: export
sockaddr_free : HasIO io => SockaddrPtr -> io ()
  Visibility: export
sock_alloc : HasIO io => ByteLength -> io BufPtr
  Allocates an amount of memory given by the ByteLength parameter.
  
  Used to allocate a mutable pointer to be given to the Recv functions.

  Visibility: export
getSockPort : HasIO io => Socket -> io Port
  Retrieves the port the given socket is bound to

  Visibility: export
getSockAddr : HasIO io => SockaddrPtr -> io SocketAddress
  Retrieves a socket address from a sockaddr pointer

  Visibility: export
freeRecvStruct : HasIO io => RecvStructPtr -> io ()
  Visibility: export
freeRecvfromStruct : HasIO io => RecvfromStructPtr -> io ()
  Utility to extract data.

  Visibility: export
sendBuf : HasIO io => Socket -> BufPtr -> ByteLength -> io (Either SocketError ResultCode)
  Sends the data in a given memory location
  
  Returns on failure a `SocketError`
  Returns on success the `ResultCode`
  
  @sock The socket on which to send the message.
  @ptr  The location containing the data to send.
  @len  How much of the data to send.

  Visibility: export
recvBuf : HasIO io => Socket -> BufPtr -> ByteLength -> io (Either SocketError ResultCode)
  Receive data from a given memory location.
  
  Returns on failure a `SocketError`
  Returns on success the `ResultCode`
  
  @sock The socket on which to receive the message.
  @ptr  The location containing the data to receive.
  @len  How much of the data to receive.

  Visibility: export
sendToBuf : HasIO io => Socket -> SocketAddress -> Port -> BufPtr -> ByteLength -> io (Either SocketError ResultCode)
  Send a message stored in some buffer.
  
  Returns on failure a `SocketError`
  Returns on success the `ResultCode`
  
  @sock The socket on which to send the message.
  @addr Address of the recipient.
  @port The port on which to send the message.
  @ptr  A Pointer to the buffer containing the message.
  @len  The size of the message.

  Visibility: export
foreignGetRecvfromPayload : HasIO io => RecvfromStructPtr -> io String
  Utility function to get the payload of the sent message as a `String`.

  Visibility: export
foreignGetRecvfromAddr : HasIO io => RecvfromStructPtr -> io SocketAddress
  Utility function to return senders socket address.

  Visibility: export
foreignGetRecvfromPort : HasIO io => RecvfromStructPtr -> io Port
  Utility function to return sender's IPV4 port.

  Visibility: export
recvFromBuf : HasIO io => Socket -> BufPtr -> ByteLength -> io (Either SocketError (UDPAddrInfo, ResultCode))
  Receive a message placed on a 'known' buffer.
  
  Returns on failure a `SocketError`.
  Returns on success a pair of
  + `UDPAddrInfo` :: The address of the sender.
  + `Int`         :: Result value from underlying function.
  
  @sock The channel on which to receive.
  @ptr  Pointer to the buffer to place the message.
  @len  Size of the expected message.
  

  Visibility: export

\ No newline at end of file
+
Reexports
import public Network.Socket.Data
Definitions
data RecvStructPtr : Type
  Totality: total
  Visibility: public export
  Constructor: 
RSPtr : AnyPtr -> RecvStructPtr
data RecvfromStructPtr : Type
  Totality: total
  Visibility: public export
  Constructor: 
RFPtr : AnyPtr -> RecvfromStructPtr
data BufPtr : Type
  Totality: total
  Visibility: public export
  Constructor: 
BPtr : AnyPtr -> BufPtr
data SockaddrPtr : Type
  Totality: total
  Visibility: public export
  Constructor: 
SAPtr : AnyPtr -> SockaddrPtr
sock_poke : HasIO io => BufPtr -> Int -> Int -> io ()
  Put a value in a buffer

  Visibility: export
sock_peek : HasIO io => BufPtr -> Int -> io Int
  Take a value from a buffer

  Visibility: export
sock_free : HasIO io => BufPtr -> io ()
  Frees a given pointer

  Visibility: export
sockaddr_free : HasIO io => SockaddrPtr -> io ()
  Visibility: export
sock_alloc : HasIO io => ByteLength -> io BufPtr
  Allocates an amount of memory given by the ByteLength parameter.
  
  Used to allocate a mutable pointer to be given to the Recv functions.

  Visibility: export
getSockPort : HasIO io => Socket -> io Port
  Retrieves the port the given socket is bound to

  Visibility: export
getSockAddr : HasIO io => SockaddrPtr -> io SocketAddress
  Retrieves a socket address from a sockaddr pointer

  Visibility: export
freeRecvStruct : HasIO io => RecvStructPtr -> io ()
  Visibility: export
freeRecvfromStruct : HasIO io => RecvfromStructPtr -> io ()
  Utility to extract data.

  Visibility: export
sendBuf : HasIO io => Socket -> BufPtr -> ByteLength -> io (Either SocketError ResultCode)
  Sends the data in a given memory location
  
  Returns on failure a `SocketError`
  Returns on success the `ResultCode`
  
  @sock The socket on which to send the message.
  @ptr  The location containing the data to send.
  @len  How much of the data to send.

  Visibility: export
recvBuf : HasIO io => Socket -> BufPtr -> ByteLength -> io (Either SocketError ResultCode)
  Receive data from a given memory location.
  
  Returns on failure a `SocketError`
  Returns on success the `ResultCode`
  
  @sock The socket on which to receive the message.
  @ptr  The location containing the data to receive.
  @len  How much of the data to receive.

  Visibility: export
sendToBuf : HasIO io => Socket -> SocketAddress -> Port -> BufPtr -> ByteLength -> io (Either SocketError ResultCode)
  Send a message stored in some buffer.
  
  Returns on failure a `SocketError`
  Returns on success the `ResultCode`
  
  @sock The socket on which to send the message.
  @addr Address of the recipient.
  @port The port on which to send the message.
  @ptr  A Pointer to the buffer containing the message.
  @len  The size of the message.

  Visibility: export
foreignGetRecvfromPayload : HasIO io => RecvfromStructPtr -> io String
  Utility function to get the payload of the sent message as a `String`.

  Visibility: export
foreignGetRecvfromAddr : HasIO io => RecvfromStructPtr -> io SocketAddress
  Utility function to return senders socket address.

  Visibility: export
foreignGetRecvfromPort : HasIO io => RecvfromStructPtr -> io Port
  Utility function to return sender's IPV4 port.

  Visibility: export
recvFromBuf : HasIO io => Socket -> BufPtr -> ByteLength -> io (Either SocketError (UDPAddrInfo, ResultCode))
  Receive a message placed on a 'known' buffer.
  
  Returns on failure a `SocketError`.
  Returns on success a pair of
  + `UDPAddrInfo` :: The address of the sender.
  + `Int`         :: Result value from underlying function.
  
  @sock The channel on which to receive.
  @ptr  Pointer to the buffer to place the message.
  @len  Size of the expected message.
  

  Visibility: export

\ No newline at end of file
diff --git a/network/docs/Network.Socket.html b/network/docs/Network.Socket.html
index c9e6500758..a64dfbd920 100644
--- a/network/docs/Network.Socket.html
+++ b/network/docs/Network.Socket.html
@@ -65,4 +65,4 @@
 
 Original (C) SimonJF, MIT Licensed, 2014
 Modified (C) The Idris Community, 2015, 2016, 2019
-
Reexports
import public Network.Socket.Data
Definitions
socket : HasIO io => SocketFamily -> SocketType -> ProtocolNumber -> io (Either SocketError Socket)
  Creates a UNIX socket with the given family, socket type and protocol
  number. Returns either a socket or an error.

  Visibility: export
close : HasIO io => Socket -> io ()
  Close a socket

  Visibility: export
bind : HasIO io => Socket -> Maybe SocketAddress -> Port -> io Int
  Binds a socket to the given socket address and port.
  Returns 0 on success, an error code otherwise.

  Visibility: export
connect : HasIO io => Socket -> SocketAddress -> Port -> io ResultCode
  Connects to a given address and port.
  Returns 0 on success, and an error number on error.

  Visibility: export
listen : HasIO io => Socket -> io Int
  Listens on a bound socket.
  
  @sock The socket to listen on.

  Visibility: export
accept : HasIO io => Socket -> io (Either SocketError (Socket, SocketAddress))
  Accept a connection on the provided socket.
  
  Returns on failure a `SocketError`
  Returns on success a pairing of:
  + `Socket`        :: The socket representing the connection.
  + `SocketAddress` :: The
  
  @sock The socket used to establish connection.

  Visibility: export
send : HasIO io => Socket -> String -> io (Either SocketError ResultCode)
  Send data on the specified socket.
  
  Returns on failure a `SocketError`.
  Returns on success the `ResultCode`.
  
  @sock The socket on which to send the message.
  @msg  The data to send.

  Visibility: export
recv : HasIO io => Socket -> ByteLength -> io (Either SocketError (String, ResultCode))
  Receive data on the specified socket.
  
  Returns on failure a `SocketError`
  Returns on success a pairing of:
  + `String`     :: The payload.
  + `ResultCode` :: The result of the underlying function.
  
  @sock The socket on which to receive the message.
  @len  How much of the data to receive.

  Visibility: export
recvAll : HasIO io => Socket -> io (Either SocketError String)
  Receive all the remaining data on the specified socket.
  
  Returns on failure a `SocketError`
  Returns on success the payload `String`
  
  @sock The socket on which to receive the message.

  Visibility: export
sendTo : HasIO io => Socket -> SocketAddress -> Port -> String -> io (Either SocketError ByteLength)
  Send a message.
  
  Returns on failure a `SocketError`
  Returns on success the `ResultCode`
  
  @sock The socket on which to send the message.
  @addr Address of the recipient.
  @port The port on which to send the message.
  @msg  The message to send.

  Visibility: export
recvFrom : HasIO io => Socket -> ByteLength -> io (Either SocketError (UDPAddrInfo, (String, ResultCode)))
  Receive a message.
  
  Returns on failure a `SocketError`.
  Returns on success a triple of
  + `UDPAddrInfo` :: The address of the sender.
  + `String`      :: The payload.
  + `Int`         :: Result value from underlying function.
  
  @sock The channel on which to receive.
  @len  Size of the expected message.
  

  Visibility: export
sendBytes : HasIO m => Socket -> List Bits8 -> m (Either SocketError Int)
  Send data on the specified socket.
  
  Returns on failure a `SocketError`.
  Returns on success the number of bytes sent.
  
  @sock   The socket on which to send the message.
  @bytes  The data to send.

  Visibility: export
recvBytes : HasIO m => Socket -> ByteLength -> m (Either SocketError (List Bits8))
  Receive data on the specified socket.
  
  Returns on failure a `SocketError`
  Returns on success a pairing of:
  + `List Bits8` :: The payload.
  + `ResultCode` :: The result of the underlying function.
  
  @sock     The socket on which to receive the message.
  @max_size How much of the data to receive at most.

  Visibility: export
recvAllBytes : HasIO io => Socket -> io (Either SocketError (List Bits8))
  Receive all the remaining data on the specified socket.
  
  Returns on failure a `SocketError`
  Returns on success the payload `List Bits8`
  
  @sock The socket on which to receive the message.

  Visibility: export

\ No newline at end of file
+
Reexports
import public Network.Socket.Data
Definitions
socket : HasIO io => SocketFamily -> SocketType -> ProtocolNumber -> io (Either SocketError Socket)
  Creates a UNIX socket with the given family, socket type and protocol
  number. Returns either a socket or an error.

  Visibility: export
close : HasIO io => Socket -> io ()
  Close a socket

  Visibility: export
bind : HasIO io => Socket -> Maybe SocketAddress -> Port -> io Int
  Binds a socket to the given socket address and port.
  Returns 0 on success, an error code otherwise.

  Visibility: export
connect : HasIO io => Socket -> SocketAddress -> Port -> io ResultCode
  Connects to a given address and port.
  Returns 0 on success, and an error number on error.

  Visibility: export
listen : HasIO io => Socket -> io Int
  Listens on a bound socket.
  
  @sock The socket to listen on.

  Visibility: export
accept : HasIO io => Socket -> io (Either SocketError (Socket, SocketAddress))
  Accept a connection on the provided socket.
  
  Returns on failure a `SocketError`
  Returns on success a pairing of:
  + `Socket`        :: The socket representing the connection.
  + `SocketAddress` :: The
  
  @sock The socket used to establish connection.

  Visibility: export
send : HasIO io => Socket -> String -> io (Either SocketError ResultCode)
  Send data on the specified socket.
  
  Returns on failure a `SocketError`.
  Returns on success the `ResultCode`.
  
  @sock The socket on which to send the message.
  @msg  The data to send.

  Visibility: export
recv : HasIO io => Socket -> ByteLength -> io (Either SocketError (String, ResultCode))
  Receive data on the specified socket.
  
  Returns on failure a `SocketError`
  Returns on success a pairing of:
  + `String`     :: The payload.
  + `ResultCode` :: The result of the underlying function.
  
  @sock The socket on which to receive the message.
  @len  How much of the data to receive.

  Visibility: export
recvAll : HasIO io => Socket -> io (Either SocketError String)
  Receive all the remaining data on the specified socket.
  
  Returns on failure a `SocketError`
  Returns on success the payload `String`
  
  @sock The socket on which to receive the message.

  Visibility: export
sendTo : HasIO io => Socket -> SocketAddress -> Port -> String -> io (Either SocketError ByteLength)
  Send a message.
  
  Returns on failure a `SocketError`
  Returns on success the `ResultCode`
  
  @sock The socket on which to send the message.
  @addr Address of the recipient.
  @port The port on which to send the message.
  @msg  The message to send.

  Visibility: export
recvFrom : HasIO io => Socket -> ByteLength -> io (Either SocketError (UDPAddrInfo, (String, ResultCode)))
  Receive a message.
  
  Returns on failure a `SocketError`.
  Returns on success a triple of
  + `UDPAddrInfo` :: The address of the sender.
  + `String`      :: The payload.
  + `Int`         :: Result value from underlying function.
  
  @sock The channel on which to receive.
  @len  Size of the expected message.
  

  Visibility: export
sendBytes : HasIO m => Socket -> List Bits8 -> m (Either SocketError Int)
  Send data on the specified socket.
  
  Returns on failure a `SocketError`.
  Returns on success the number of bytes sent.
  
  @sock   The socket on which to send the message.
  @bytes  The data to send.

  Visibility: export
recvBytes : HasIO m => Socket -> ByteLength -> m (Either SocketError (List Bits8))
  Receive data on the specified socket.
  
  Returns on failure a `SocketError`
  Returns on success a pairing of:
  + `List Bits8` :: The payload.
  + `ResultCode` :: The result of the underlying function.
  
  @sock     The socket on which to receive the message.
  @max_size How much of the data to receive at most.

  Visibility: export
recvAllBytes : HasIO io => Socket -> io (Either SocketError (List Bits8))
  Receive all the remaining data on the specified socket.
  
  Returns on failure a `SocketError`
  Returns on success the payload `List Bits8`
  
  @sock The socket on which to receive the message.

  Visibility: export

\ No newline at end of file
diff --git a/network/index.html b/network/index.html
index 1b71170e88..d460ade0bb 100644
--- a/network/index.html
+++ b/network/index.html
@@ -61,4 +61,4 @@
 
 
 
-
Package network - Namespaces

\ No newline at end of file
+
Package network - Namespaces

\ No newline at end of file
diff --git a/papers/docs/Control.DivideAndConquer.html b/papers/docs/Control.DivideAndConquer.html
index fa643e4f47..f1760c0730 100644
--- a/papers/docs/Control.DivideAndConquer.html
+++ b/papers/docs/Control.DivideAndConquer.html
@@ -70,4 +70,4 @@
 The original paper relies on Coq's impredicative Set axiom,
 something we don't have access to in Idris 2. We can however
 reproduce the results by ignoring the type levels
-
Definitions
data ListF : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : ListF a x
  
(::) : a -> x -> ListF a x

  Hint: 
Functor (ListF a)
data Mu : (Type -> Type) -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkMu : (r -> Mu f) -> f r -> Mu f
inMu : f (Mu f) -> Mu f
  Totality: total
  Visibility: public export
outMu : Functor f => Mu f -> f (Mu f)
  Totality: total
  Visibility: public export
fold : Functor f => (f a -> a) -> Mu f -> a
  Totality: total
  Visibility: public export
KAlg : Type
  Totality: total
  Visibility: public export
0 Mono : (KAlg -> KAlg) -> Type
  Totality: total
  Visibility: public export
data Mu : (KAlg -> KAlg) -> KAlg
  Totality: total
  Visibility: public export
  Constructor: 
MkMu : (a x -> Mu f x) -> f a x -> Mu f x
inMu : f (Mu f) x -> Mu f x
  Totality: total
  Visibility: public export
outMu : Mono f -> Mu f x -> f (Mu f) x
  Totality: total
  Visibility: public export
0 FoldT : (0 _ : (Type -> Type)) -> KAlg -> Type -> Type
  Totality: total
  Visibility: public export
0 SAlgF : (0 _ : (Type -> Type)) -> KAlg -> (Type -> Type) -> Type
  Totality: total
  Visibility: public export
0 SAlg : (0 _ : (Type -> Type)) -> (Type -> Type) -> Type
  Totality: total
  Visibility: public export
0 AlgF : (0 _ : (Type -> Type)) -> KAlg -> (Type -> Type) -> Type
  Totality: total
  Visibility: public export
0 Alg : (0 _ : (Type -> Type)) -> (Type -> Type) -> Type
  Totality: total
  Visibility: public export
inSAlg : (0 f : (Type -> Type)) -> SAlgF SAlg x -> SAlg x
  Totality: total
  Visibility: public export
monoSAlgF : (0 f : (Type -> Type)) -> Mono SAlgF
  Totality: total
  Visibility: public export
outSAlg : (0 f : (Type -> Type)) -> SAlg x -> SAlgF SAlg x
  Totality: total
  Visibility: public export
inAlg : (0 f : (Type -> Type)) -> AlgF Alg x -> Alg x
  Totality: total
  Visibility: public export
monoAlgF : (0 f : (Type -> Type)) -> Mono AlgF
  Totality: total
  Visibility: public export
outAlg : (0 f : (Type -> Type)) -> Alg x -> AlgF Alg x
  Totality: total
  Visibility: public export
0 DcF : (0 _ : (Type -> Type)) -> Type -> Type
  Totality: total
  Visibility: public export
functorDcF : (0 f : (Type -> Type)) -> Functor DcF
  Totality: total
  Visibility: public export
0 Dc : (0 _ : (Type -> Type)) -> Type
  Totality: total
  Visibility: public export
fold : (0 f : (Type -> Type)) -> FoldT Alg Dc
  Totality: total
  Visibility: public export
record RevealT : (0 _ : (Type -> Type)) -> (Type -> Type) -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkRevealT : (0 f : (Type -> Type)) -> ((r -> Dc) -> x Dc) -> RevealT x r

  Projection: 
.runRevealT : (0 f : (Type -> Type)) -> RevealT x r -> (r -> Dc) -> x Dc

  Hint: 
(0 f : (Type -> Type)) -> Functor (RevealT x)
.runRevealT : (0 f : (Type -> Type)) -> RevealT x r -> (r -> Dc) -> x Dc
  Totality: total
  Visibility: public export
runRevealT : (0 f : (Type -> Type)) -> RevealT x r -> (r -> Dc) -> x Dc
  Totality: total
  Visibility: public export
functorRevealT : (0 f : (Type -> Type)) -> Functor (RevealT x)
  Totality: total
  Visibility: public export
promote : (0 f : (Type -> Type)) -> Functor x => SAlg x -> Alg (RevealT x)
  Totality: total
  Visibility: public export
sfold : (0 f : (Type -> Type)) -> FoldT SAlg Dc
  Totality: total
  Visibility: public export
inDc : (0 f : (Type -> Type)) -> f Dc -> Dc
  Totality: total
  Visibility: public export
0 list : Type -> Type
  Totality: total
  Visibility: public export
Nil : list a
  Totality: total
  Visibility: public export
(::) : a -> list a -> list a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
fromList : List a -> list a
  Totality: total
  Visibility: public export
0 SpanF : Type -> Type -> Type
  Totality: total
  Visibility: public export
spanr : FoldT SAlg r -> (a -> Bool) -> r -> SpanF a r
  Totality: total
  Visibility: export
zero : Nat -> Nat
  Totality: total
  Visibility: export
matchExample : Bool
  Totality: total
  Visibility: export
sortExample : String -> String
  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
data ListF : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : ListF a x
  
(::) : a -> x -> ListF a x

  Hint: 
Functor (ListF a)
data Mu : (Type -> Type) -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkMu : (r -> Mu f) -> f r -> Mu f
inMu : f (Mu f) -> Mu f
  Totality: total
  Visibility: public export
outMu : Functor f => Mu f -> f (Mu f)
  Totality: total
  Visibility: public export
fold : Functor f => (f a -> a) -> Mu f -> a
  Totality: total
  Visibility: public export
KAlg : Type
  Totality: total
  Visibility: public export
0 Mono : (KAlg -> KAlg) -> Type
  Totality: total
  Visibility: public export
data Mu : (KAlg -> KAlg) -> KAlg
  Totality: total
  Visibility: public export
  Constructor: 
MkMu : (a x -> Mu f x) -> f a x -> Mu f x
inMu : f (Mu f) x -> Mu f x
  Totality: total
  Visibility: public export
outMu : Mono f -> Mu f x -> f (Mu f) x
  Totality: total
  Visibility: public export
0 FoldT : (0 _ : (Type -> Type)) -> KAlg -> Type -> Type
  Totality: total
  Visibility: public export
0 SAlgF : (0 _ : (Type -> Type)) -> KAlg -> (Type -> Type) -> Type
  Totality: total
  Visibility: public export
0 SAlg : (0 _ : (Type -> Type)) -> (Type -> Type) -> Type
  Totality: total
  Visibility: public export
0 AlgF : (0 _ : (Type -> Type)) -> KAlg -> (Type -> Type) -> Type
  Totality: total
  Visibility: public export
0 Alg : (0 _ : (Type -> Type)) -> (Type -> Type) -> Type
  Totality: total
  Visibility: public export
inSAlg : (0 f : (Type -> Type)) -> SAlgF SAlg x -> SAlg x
  Totality: total
  Visibility: public export
monoSAlgF : (0 f : (Type -> Type)) -> Mono SAlgF
  Totality: total
  Visibility: public export
outSAlg : (0 f : (Type -> Type)) -> SAlg x -> SAlgF SAlg x
  Totality: total
  Visibility: public export
inAlg : (0 f : (Type -> Type)) -> AlgF Alg x -> Alg x
  Totality: total
  Visibility: public export
monoAlgF : (0 f : (Type -> Type)) -> Mono AlgF
  Totality: total
  Visibility: public export
outAlg : (0 f : (Type -> Type)) -> Alg x -> AlgF Alg x
  Totality: total
  Visibility: public export
0 DcF : (0 _ : (Type -> Type)) -> Type -> Type
  Totality: total
  Visibility: public export
functorDcF : (0 f : (Type -> Type)) -> Functor DcF
  Totality: total
  Visibility: public export
0 Dc : (0 _ : (Type -> Type)) -> Type
  Totality: total
  Visibility: public export
fold : (0 f : (Type -> Type)) -> FoldT Alg Dc
  Totality: total
  Visibility: public export
record RevealT : (0 _ : (Type -> Type)) -> (Type -> Type) -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkRevealT : (0 f : (Type -> Type)) -> ((r -> Dc) -> x Dc) -> RevealT x r

  Projection: 
.runRevealT : (0 f : (Type -> Type)) -> RevealT x r -> (r -> Dc) -> x Dc

  Hint: 
(0 f : (Type -> Type)) -> Functor (RevealT x)
.runRevealT : (0 f : (Type -> Type)) -> RevealT x r -> (r -> Dc) -> x Dc
  Totality: total
  Visibility: public export
runRevealT : (0 f : (Type -> Type)) -> RevealT x r -> (r -> Dc) -> x Dc
  Totality: total
  Visibility: public export
functorRevealT : (0 f : (Type -> Type)) -> Functor (RevealT x)
  Totality: total
  Visibility: public export
promote : (0 f : (Type -> Type)) -> Functor x => SAlg x -> Alg (RevealT x)
  Totality: total
  Visibility: public export
sfold : (0 f : (Type -> Type)) -> FoldT SAlg Dc
  Totality: total
  Visibility: public export
inDc : (0 f : (Type -> Type)) -> f Dc -> Dc
  Totality: total
  Visibility: public export
0 list : Type -> Type
  Totality: total
  Visibility: public export
Nil : list a
  Totality: total
  Visibility: public export
(::) : a -> list a -> list a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
fromList : List a -> list a
  Totality: total
  Visibility: public export
0 SpanF : Type -> Type -> Type
  Totality: total
  Visibility: public export
spanr : FoldT SAlg r -> (a -> Bool) -> r -> SpanF a r
  Totality: total
  Visibility: export
zero : Nat -> Nat
  Totality: total
  Visibility: export
matchExample : Bool
  Totality: total
  Visibility: export
sortExample : String -> String
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/papers/docs/Data.Container.html b/papers/docs/Data.Container.html
index fa0c7de6cf..4f34696fdf 100644
--- a/papers/docs/Data.Container.html
+++ b/papers/docs/Data.Container.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Container(source)
Definitions
record Container : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkContainer : (Shape : Type) -> (Shape -> Type) -> Container

  Projections:
  
.Position : ({rec:0} : Container) -> Shape {rec:0} -> Type
  
.Shape : Container -> Type

  Hint: 
Functor (Extension c)
.Shape : Container -> Type
  Totality: total
  Visibility: public export
Shape : Container -> Type
  Totality: total
  Visibility: public export
.Position : ({rec:0} : Container) -> Shape {rec:0} -> Type
  Totality: total
  Visibility: public export
Position : ({rec:0} : Container) -> Shape {rec:0} -> Type
  Totality: total
  Visibility: public export
record Extension : Container -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkExtension : (shape : Shape c) -> (Position c shape -> x) -> Extension c x

  Projections:
  
.payloads : ({rec:0} : Extension c x) -> Position c (shape {rec:0}) -> x
  
.shape : Extension c x -> Shape c

  Hint: 
Functor (Extension c)
.shape : Extension c x -> Shape c
  Totality: total
  Visibility: public export
shape : Extension c x -> Shape c
  Totality: total
  Visibility: public export
.payloads : ({rec:0} : Extension c x) -> Position c (shape {rec:0}) -> x
  Totality: total
  Visibility: public export
payloads : ({rec:0} : Extension c x) -> Position c (shape {rec:0}) -> x
  Totality: total
  Visibility: public export
record Morphism : Container -> Container -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkMorphism : (shapeMorphism : (Shape c -> Shape d)) -> (Position d (shapeMorphism s) -> Position c s) -> Morphism c d

  Projections:
  
.positionMorphism : ({rec:0} : Morphism c d) -> Position d (shapeMorphism {rec:0} s) -> Position c s
  
.shapeMorphism : Morphism c d -> Shape c -> Shape d
.shapeMorphism : Morphism c d -> Shape c -> Shape d
  Totality: total
  Visibility: public export
shapeMorphism : Morphism c d -> Shape c -> Shape d
  Totality: total
  Visibility: public export
.positionMorphism : ({rec:0} : Morphism c d) -> Position d (shapeMorphism {rec:0} s) -> Position c s
  Totality: total
  Visibility: public export
positionMorphism : ({rec:0} : Morphism c d) -> Position d (shapeMorphism {rec:0} s) -> Position c s
  Totality: total
  Visibility: public export
Extension : Morphism c d -> Extension c x -> Extension d x
  Totality: total
  Visibility: public export
Const : Type -> Container
  Totality: total
  Visibility: public export
toConst : k -> Extension (Const k) x
  Totality: total
  Visibility: export
fromConst : Extension (Const k) x -> k
  Totality: total
  Visibility: export
Identity : Container
  Totality: total
  Visibility: public export
toIdentity : x -> Extension Identity x
  Totality: total
  Visibility: export
fromIdentity : Extension Identity x -> x
  Totality: total
  Visibility: export
Compose : Container -> Container -> Container
  Totality: total
  Visibility: public export
toCompose : (.) (Extension d) (Extension c) x -> Extension (Compose d c) x
  Totality: total
  Visibility: export
fromCompose : Extension (Compose d c) x -> (.) (Extension d) (Extension c) x
  Totality: total
  Visibility: export
Sum : Container -> Container -> Container
  Totality: total
  Visibility: public export
toSum : Either (Extension c x) (Extension d x) -> Extension (Sum c d) x
  Totality: total
  Visibility: export
fromSum : Extension (Sum c d) x -> Either (Extension c x) (Extension d x)
  Totality: total
  Visibility: export
Pair : Container -> Container -> Container
  Totality: total
  Visibility: public export
toPair : (Extension c x, Extension d x) -> Extension (Pair c d) x
  Totality: total
  Visibility: export
fromPair : Extension (Pair c d) x -> (Extension c x, Extension d x)
  Totality: total
  Visibility: export
Exponential : Type -> Container -> Container
  Totality: total
  Visibility: public export
toExponential : (k -> Extension c x) -> Extension (Exponential k c) x
  Totality: total
  Visibility: export
fromExponential : Extension (Exponential k c) x -> k -> Extension c x
  Totality: total
  Visibility: export
data W : Container -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkW : Extension c (W c) -> W c
map : Morphism c d -> W c -> W d
  Totality: total
  Visibility: export
foldr : (Extension c x -> x) -> W c -> x
  Totality: total
  Visibility: export
para : (Extension c (x, W c) -> x) -> W c -> x
  Totality: total
  Visibility: export
record Free : Container -> Type -> Type
  @Free@ is a wrapper around @W@ to make it inference friendly.
  Without this wrapper, neither @pure@ nor @bind@ are able to infer their @c@ argument.

  Totality: total
  Visibility: public export
  Constructor: 
MkFree : W (Sum c (Const x)) -> Free c x

  Projection: 
.runFree : Free c x -> W (Sum c (Const x))
.runFree : Free c x -> W (Sum c (Const x))
  Totality: total
  Visibility: public export
runFree : Free c x -> W (Sum c (Const x))
  Totality: total
  Visibility: public export
pure : x -> Free c x
  Totality: total
  Visibility: export
(>>=) : Free c x -> (x -> Free c y) -> Free c y
  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 1
join : Free c (Free c x) -> Free c x
  Totality: total
  Visibility: export
data M : Container -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkM : Extension c (Inf (M c)) -> M c
unfoldr : (s -> Extension c s) -> s -> M c
  Totality: total
  Visibility: export
record Cofree : Container -> Type -> Type
  @Cofree@ is a wrapper around @M@ to make it inference friendly.
  Without this wrapper, neither @extract@ nor @extend@ are able to infer their @c@ argument.

  Totality: total
  Visibility: public export
  Constructor: 
MkCofree : M (Pair (Const x) c) -> Cofree c x

  Projection: 
.runCofree : Cofree c x -> M (Pair (Const x) c)
.runCofree : Cofree c x -> M (Pair (Const x) c)
  Totality: total
  Visibility: public export
runCofree : Cofree c x -> M (Pair (Const x) c)
  Totality: total
  Visibility: public export
extract : Cofree c x -> x
  Totality: total
  Visibility: export
extend : (Cofree c a -> b) -> Cofree c a -> Cofree c b
  Totality: total
  Visibility: export
duplicate : Cofree c a -> Cofree c (Cofree c a)
  Totality: total
  Visibility: export
Derivative : Container -> Container
  Totality: total
  Visibility: public export
hole : (v : Extension (Derivative c) x) -> Position c (fst (shape v))
  Totality: total
  Visibility: export
unplug : (v : Extension c x) -> Position c (shape v) -> (Extension (Derivative c) x, x)
  Totality: total
  Visibility: export
plug : (v : Extension (Derivative c) x) -> DecEq (Position c (fst (shape v))) => x -> Extension c x
  Totality: total
  Visibility: export
toConst : Extension (Const Void) x -> Extension (Derivative (Const k)) x
  Totality: total
  Visibility: export
fromConst : Extension (Derivative (Const k)) x -> Extension (Const Void) x
  Totality: total
  Visibility: export
toIdentity : Extension (Derivative Identity) x
  Totality: total
  Visibility: export
toSum : Extension (Sum (Derivative c) (Derivative d)) x -> Extension (Derivative (Sum c d)) x
  Totality: total
  Visibility: export
fromSum : Extension (Derivative (Sum c d)) x -> Extension (Sum (Derivative c) (Derivative d)) x
  Totality: total
  Visibility: export
toPair : Extension (Sum (Pair (Derivative c) d) (Pair c (Derivative d))) x -> Extension (Derivative (Pair c d)) x
  Totality: total
  Visibility: export
fromPair : Extension (Derivative (Pair c d)) x -> Extension (Sum (Pair (Derivative c) d) (Pair c (Derivative d))) x
  Totality: total
  Visibility: export
fromCompose : Extension (Derivative (Compose c d)) x -> Extension (Pair (Derivative d) (Compose (Derivative c) d)) x
  Totality: total
  Visibility: export
toCompose : ((s : c .Shape) -> DecEq (Position c s)) -> ((s : d .Shape) -> DecEq (Position d s)) -> Extension (Pair (Derivative d) (Compose (Derivative c) d)) x -> Extension (Derivative (Compose c d)) x
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Container(source)
Definitions
record Container : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkContainer : (Shape : Type) -> (Shape -> Type) -> Container

  Projections:
  
.Position : ({rec:0} : Container) -> Shape {rec:0} -> Type
  
.Shape : Container -> Type

  Hint: 
Functor (Extension c)
.Shape : Container -> Type
  Totality: total
  Visibility: public export
Shape : Container -> Type
  Totality: total
  Visibility: public export
.Position : ({rec:0} : Container) -> Shape {rec:0} -> Type
  Totality: total
  Visibility: public export
Position : ({rec:0} : Container) -> Shape {rec:0} -> Type
  Totality: total
  Visibility: public export
record Extension : Container -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkExtension : (shape : Shape c) -> (Position c shape -> x) -> Extension c x

  Projections:
  
.payloads : ({rec:0} : Extension c x) -> Position c (shape {rec:0}) -> x
  
.shape : Extension c x -> Shape c

  Hint: 
Functor (Extension c)
.shape : Extension c x -> Shape c
  Totality: total
  Visibility: public export
shape : Extension c x -> Shape c
  Totality: total
  Visibility: public export
.payloads : ({rec:0} : Extension c x) -> Position c (shape {rec:0}) -> x
  Totality: total
  Visibility: public export
payloads : ({rec:0} : Extension c x) -> Position c (shape {rec:0}) -> x
  Totality: total
  Visibility: public export
record Morphism : Container -> Container -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkMorphism : (shapeMorphism : (Shape c -> Shape d)) -> (Position d (shapeMorphism s) -> Position c s) -> Morphism c d

  Projections:
  
.positionMorphism : ({rec:0} : Morphism c d) -> Position d (shapeMorphism {rec:0} s) -> Position c s
  
.shapeMorphism : Morphism c d -> Shape c -> Shape d
.shapeMorphism : Morphism c d -> Shape c -> Shape d
  Totality: total
  Visibility: public export
shapeMorphism : Morphism c d -> Shape c -> Shape d
  Totality: total
  Visibility: public export
.positionMorphism : ({rec:0} : Morphism c d) -> Position d (shapeMorphism {rec:0} s) -> Position c s
  Totality: total
  Visibility: public export
positionMorphism : ({rec:0} : Morphism c d) -> Position d (shapeMorphism {rec:0} s) -> Position c s
  Totality: total
  Visibility: public export
Extension : Morphism c d -> Extension c x -> Extension d x
  Totality: total
  Visibility: public export
Const : Type -> Container
  Totality: total
  Visibility: public export
toConst : k -> Extension (Const k) x
  Totality: total
  Visibility: export
fromConst : Extension (Const k) x -> k
  Totality: total
  Visibility: export
Identity : Container
  Totality: total
  Visibility: public export
toIdentity : x -> Extension Identity x
  Totality: total
  Visibility: export
fromIdentity : Extension Identity x -> x
  Totality: total
  Visibility: export
Compose : Container -> Container -> Container
  Totality: total
  Visibility: public export
toCompose : (.) (Extension d) (Extension c) x -> Extension (Compose d c) x
  Totality: total
  Visibility: export
fromCompose : Extension (Compose d c) x -> (.) (Extension d) (Extension c) x
  Totality: total
  Visibility: export
Sum : Container -> Container -> Container
  Totality: total
  Visibility: public export
toSum : Either (Extension c x) (Extension d x) -> Extension (Sum c d) x
  Totality: total
  Visibility: export
fromSum : Extension (Sum c d) x -> Either (Extension c x) (Extension d x)
  Totality: total
  Visibility: export
Pair : Container -> Container -> Container
  Totality: total
  Visibility: public export
toPair : (Extension c x, Extension d x) -> Extension (Pair c d) x
  Totality: total
  Visibility: export
fromPair : Extension (Pair c d) x -> (Extension c x, Extension d x)
  Totality: total
  Visibility: export
Exponential : Type -> Container -> Container
  Totality: total
  Visibility: public export
toExponential : (k -> Extension c x) -> Extension (Exponential k c) x
  Totality: total
  Visibility: export
fromExponential : Extension (Exponential k c) x -> k -> Extension c x
  Totality: total
  Visibility: export
data W : Container -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkW : Extension c (W c) -> W c
map : Morphism c d -> W c -> W d
  Totality: total
  Visibility: export
foldr : (Extension c x -> x) -> W c -> x
  Totality: total
  Visibility: export
para : (Extension c (x, W c) -> x) -> W c -> x
  Totality: total
  Visibility: export
record Free : Container -> Type -> Type
  @Free@ is a wrapper around @W@ to make it inference friendly.
  Without this wrapper, neither @pure@ nor @bind@ are able to infer their @c@ argument.

  Totality: total
  Visibility: public export
  Constructor: 
MkFree : W (Sum c (Const x)) -> Free c x

  Projection: 
.runFree : Free c x -> W (Sum c (Const x))
.runFree : Free c x -> W (Sum c (Const x))
  Totality: total
  Visibility: public export
runFree : Free c x -> W (Sum c (Const x))
  Totality: total
  Visibility: public export
pure : x -> Free c x
  Totality: total
  Visibility: export
(>>=) : Free c x -> (x -> Free c y) -> Free c y
  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 1
join : Free c (Free c x) -> Free c x
  Totality: total
  Visibility: export
data M : Container -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkM : Extension c (Inf (M c)) -> M c
unfoldr : (s -> Extension c s) -> s -> M c
  Totality: total
  Visibility: export
record Cofree : Container -> Type -> Type
  @Cofree@ is a wrapper around @M@ to make it inference friendly.
  Without this wrapper, neither @extract@ nor @extend@ are able to infer their @c@ argument.

  Totality: total
  Visibility: public export
  Constructor: 
MkCofree : M (Pair (Const x) c) -> Cofree c x

  Projection: 
.runCofree : Cofree c x -> M (Pair (Const x) c)
.runCofree : Cofree c x -> M (Pair (Const x) c)
  Totality: total
  Visibility: public export
runCofree : Cofree c x -> M (Pair (Const x) c)
  Totality: total
  Visibility: public export
extract : Cofree c x -> x
  Totality: total
  Visibility: export
extend : (Cofree c a -> b) -> Cofree c a -> Cofree c b
  Totality: total
  Visibility: export
duplicate : Cofree c a -> Cofree c (Cofree c a)
  Totality: total
  Visibility: export
Derivative : Container -> Container
  Totality: total
  Visibility: public export
hole : (v : Extension (Derivative c) x) -> Position c (fst (shape v))
  Totality: total
  Visibility: export
unplug : (v : Extension c x) -> Position c (shape v) -> (Extension (Derivative c) x, x)
  Totality: total
  Visibility: export
plug : (v : Extension (Derivative c) x) -> DecEq (Position c (fst (shape v))) => x -> Extension c x
  Totality: total
  Visibility: export
toConst : Extension (Const Void) x -> Extension (Derivative (Const k)) x
  Totality: total
  Visibility: export
fromConst : Extension (Derivative (Const k)) x -> Extension (Const Void) x
  Totality: total
  Visibility: export
toIdentity : Extension (Derivative Identity) x
  Totality: total
  Visibility: export
toSum : Extension (Sum (Derivative c) (Derivative d)) x -> Extension (Derivative (Sum c d)) x
  Totality: total
  Visibility: export
fromSum : Extension (Derivative (Sum c d)) x -> Extension (Sum (Derivative c) (Derivative d)) x
  Totality: total
  Visibility: export
toPair : Extension (Sum (Pair (Derivative c) d) (Pair c (Derivative d))) x -> Extension (Derivative (Pair c d)) x
  Totality: total
  Visibility: export
fromPair : Extension (Derivative (Pair c d)) x -> Extension (Sum (Pair (Derivative c) d) (Pair c (Derivative d))) x
  Totality: total
  Visibility: export
fromCompose : Extension (Derivative (Compose c d)) x -> Extension (Pair (Derivative d) (Compose (Derivative c) d)) x
  Totality: total
  Visibility: export
toCompose : ((s : c .Shape) -> DecEq (Position c s)) -> ((s : d .Shape) -> DecEq (Position d s)) -> Extension (Pair (Derivative d) (Compose (Derivative c) d)) x -> Extension (Derivative (Compose c d)) x
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/papers/docs/Data.Description.Indexed.html b/papers/docs/Data.Description.Indexed.html
index b085b25239..d68a52fbae 100644
--- a/papers/docs/Data.Description.Indexed.html
+++ b/papers/docs/Data.Description.Indexed.html
@@ -65,4 +65,4 @@
 A Completely Unique Account of Enumeration
 by Cas van der Rest, and Wouter Swierstra
 https://doi.org/10.1145/3547636
-
Definitions
data IDesc : (Type -> Type) -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Zero : IDesc p i
  
One : IDesc p i
  
Id : i -> IDesc p i
  
(*) : IDesc p i -> IDesc p i -> IDesc p i
  
(+) : IDesc p i -> IDesc p i -> IDesc p i
  
Sig : (s : Type) -> p s -> (s -> IDesc p i) -> IDesc p i
Elem : IDesc p i -> (i -> Type) -> Type
  Totality: total
  Visibility: public export
data Fix : (i -> IDesc p i) -> i -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkFix : assert_total (Elem (d i) (Fix d)) -> Fix d i
map : (d : IDesc p i) -> ((v : i) -> x v -> y v) -> Elem d x -> Elem d y
  Totality: total
  Visibility: export
ifold : ((v : i) -> Elem (d v) x -> x v) -> Fix d v -> x v
  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
data IDesc : (Type -> Type) -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Zero : IDesc p i
  
One : IDesc p i
  
Id : i -> IDesc p i
  
(*) : IDesc p i -> IDesc p i -> IDesc p i
  
(+) : IDesc p i -> IDesc p i -> IDesc p i
  
Sig : (s : Type) -> p s -> (s -> IDesc p i) -> IDesc p i
Elem : IDesc p i -> (i -> Type) -> Type
  Totality: total
  Visibility: public export
data Fix : (i -> IDesc p i) -> i -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkFix : assert_total (Elem (d i) (Fix d)) -> Fix d i
map : (d : IDesc p i) -> ((v : i) -> x v -> y v) -> Elem d x -> Elem d y
  Totality: total
  Visibility: export
ifold : ((v : i) -> Elem (d v) x -> x v) -> Fix d v -> x v
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/papers/docs/Data.Description.Regular.html b/papers/docs/Data.Description.Regular.html
index 795e42bdeb..f15a865cac 100644
--- a/papers/docs/Data.Description.Regular.html
+++ b/papers/docs/Data.Description.Regular.html
@@ -65,4 +65,4 @@
 A Completely Unique Account of Enumeration
 by Cas van der Rest, and Wouter Swierstra
 https://doi.org/10.1145/3547636
-
Definitions
data Desc : (Type -> Type) -> Type
  Description of regular functors
  @ p stores additional data for constant types
      e.g. the fact they are enumerable

  Totality: total
  Visibility: public export
  Constructors:
  
Zero : Desc p
  The code for the empty type
  
One : Desc p
  The code for the unit type
  
Id : Desc p
  The code for the identity functor
  
Const : (0 s : Type) -> p s -> Desc p
  The code for the constant functor
  
(*) : Desc p -> Desc p -> Desc p
  The code for the product of functors
  
(+) : Desc p -> Desc p -> Desc p
  The code for the sum of functors
0 Elem : Desc p -> Type -> Type
  Computing the meaning of a description as a functor

  Totality: total
  Visibility: public export
map : (d : Desc p) -> (a -> b) -> Elem d a -> Elem d b
  Elem does decode to functors

  Totality: total
  Visibility: export
data Fix : Desc p -> Type
  A regular type is obtained by taking the fixpoint of
  the decoding of a description.
  Unfortunately Idris 2 does not currently detect that this definition
  is total because we do not track positivity in function arguments

  Totality: total
  Visibility: public export
  Constructor: 
MkFix : assert_total (Elem d (Fix d)) -> Fix d
fold : (Elem d x -> x) -> Fix d -> x
  Fix is an initial algebra so we get the fold

  Totality: total
  Visibility: export
record (~>) : (d : Desc p) -> (Fix d -> Type) -> Type
  A memo trie is a coinductive structure

  Totality: total
  Visibility: export
  Constructor: 
MkMemo : assert_total (Memo d (\x => Inf (d ~> x)) (b . MkFix)) -> d ~> b

  Projection: 
.getMemo : d ~> b -> assert_total (Memo d (\x => Inf (d ~> x)) (b . MkFix))

  Fixity Declaration: infixr operator, level 0
trie : ((x : Fix d) -> b x) -> d ~> b
  Totality: total
  Visibility: export
untrie : d ~> b -> (x : Fix d) -> b x
  Totality: total
  Visibility: export
memo : (0 b : (Fix d -> Type)) -> ((x : Fix d) -> b x) -> (x : Fix d) -> b x
  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
data Desc : (Type -> Type) -> Type
  Description of regular functors
  @ p stores additional data for constant types
      e.g. the fact they are enumerable

  Totality: total
  Visibility: public export
  Constructors:
  
Zero : Desc p
  The code for the empty type
  
One : Desc p
  The code for the unit type
  
Id : Desc p
  The code for the identity functor
  
Const : (0 s : Type) -> p s -> Desc p
  The code for the constant functor
  
(*) : Desc p -> Desc p -> Desc p
  The code for the product of functors
  
(+) : Desc p -> Desc p -> Desc p
  The code for the sum of functors
0 Elem : Desc p -> Type -> Type
  Computing the meaning of a description as a functor

  Totality: total
  Visibility: public export
map : (d : Desc p) -> (a -> b) -> Elem d a -> Elem d b
  Elem does decode to functors

  Totality: total
  Visibility: export
data Fix : Desc p -> Type
  A regular type is obtained by taking the fixpoint of
  the decoding of a description.
  Unfortunately Idris 2 does not currently detect that this definition
  is total because we do not track positivity in function arguments

  Totality: total
  Visibility: public export
  Constructor: 
MkFix : assert_total (Elem d (Fix d)) -> Fix d
fold : (Elem d x -> x) -> Fix d -> x
  Fix is an initial algebra so we get the fold

  Totality: total
  Visibility: export
record (~>) : (d : Desc p) -> (Fix d -> Type) -> Type
  A memo trie is a coinductive structure

  Totality: total
  Visibility: export
  Constructor: 
MkMemo : assert_total (Memo d (\x => Inf (d ~> x)) (b . MkFix)) -> d ~> b

  Projection: 
.getMemo : d ~> b -> assert_total (Memo d (\x => Inf (d ~> x)) (b . MkFix))

  Fixity Declaration: infixr operator, level 0
trie : ((x : Fix d) -> b x) -> d ~> b
  Totality: total
  Visibility: export
untrie : d ~> b -> (x : Fix d) -> b x
  Totality: total
  Visibility: export
memo : (0 b : (Fix d -> Type)) -> ((x : Fix d) -> b x) -> (x : Fix d) -> b x
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/papers/docs/Data.Enumerate.Common.html b/papers/docs/Data.Enumerate.Common.html
index 0b78f5db6b..caa111526c 100644
--- a/papers/docs/Data.Enumerate.Common.html
+++ b/papers/docs/Data.Enumerate.Common.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Enumerate.Common(source)
Definitions
prodWith : (a -> b -> c) -> List a -> List b -> List c
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.Enumerate.Common(source)
Definitions
prodWith : (a -> b -> c) -> List a -> List b -> List c
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/papers/docs/Data.Enumerate.Indexed.html b/papers/docs/Data.Enumerate.Indexed.html
index f65dc1259c..93ae2735ac 100644
--- a/papers/docs/Data.Enumerate.Indexed.html
+++ b/papers/docs/Data.Enumerate.Indexed.html
@@ -65,4 +65,4 @@
 A Completely Unique Account of Enumeration
 by Cas van der Rest, and Wouter Swierstra
 https://doi.org/10.1145/3547636
-
Definitions
record IEnumerator : (i -> Type) -> Type -> Type
  An (a,b)-enumerator is an enumerator for values of type b provided
  that we already know how to enumerate subterms of type a

  Totality: total
  Visibility: export
  Constructor: 
MkIEnumerator : (((v : i) -> List (a v)) -> List b) -> IEnumerator a b

  Projection: 
.runIEnumerator : IEnumerator a b -> ((v : i) -> List (a v)) -> List b

  Hints:
  
Alternative (IEnumerator a)
  
Applicative (IEnumerator a)
  
Functor (IEnumerator a)
  
Monad (IEnumerator a)
rec : (v : i) -> IEnumerator a (a v)
  Totality: total
  Visibility: export
pairWith : (b -> c -> d) -> IEnumerator a b -> IEnumerator a c -> IEnumerator a d
  Totality: total
  Visibility: export
pair : IEnumerator a b -> IEnumerator a c -> IEnumerator a (b, c)
  Totality: total
  Visibility: export
sig : {b : a -> Type} -> IEnumerator f a -> ((x : a) -> IEnumerator f (b x)) -> IEnumerator f (x : a ** b x)
  Totality: total
  Visibility: export
const : List b -> IEnumerator a b
  Totality: total
  Visibility: export
isized : ((v : i) -> IEnumerator a (a v)) -> Nat -> (v : i) -> List (a v)
  Totality: total
  Visibility: export
indexed : (d : (i -> IDesc List i)) -> (v : i) -> IEnumerator (Fix d) (Fix d v)
  Totality: total
  Visibility: export
0 Memorator : (d : Desc p) -> (Fix d -> Type) -> Type -> Type
  Totality: total
  Visibility: export
memorate : ((x : Fix d) -> Memorator d b (b x)) -> Nat -> (x : Fix d) -> List (b x)
  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
record IEnumerator : (i -> Type) -> Type -> Type
  An (a,b)-enumerator is an enumerator for values of type b provided
  that we already know how to enumerate subterms of type a

  Totality: total
  Visibility: export
  Constructor: 
MkIEnumerator : (((v : i) -> List (a v)) -> List b) -> IEnumerator a b

  Projection: 
.runIEnumerator : IEnumerator a b -> ((v : i) -> List (a v)) -> List b

  Hints:
  
Alternative (IEnumerator a)
  
Applicative (IEnumerator a)
  
Functor (IEnumerator a)
  
Monad (IEnumerator a)
rec : (v : i) -> IEnumerator a (a v)
  Totality: total
  Visibility: export
pairWith : (b -> c -> d) -> IEnumerator a b -> IEnumerator a c -> IEnumerator a d
  Totality: total
  Visibility: export
pair : IEnumerator a b -> IEnumerator a c -> IEnumerator a (b, c)
  Totality: total
  Visibility: export
sig : {b : a -> Type} -> IEnumerator f a -> ((x : a) -> IEnumerator f (b x)) -> IEnumerator f (x : a ** b x)
  Totality: total
  Visibility: export
const : List b -> IEnumerator a b
  Totality: total
  Visibility: export
isized : ((v : i) -> IEnumerator a (a v)) -> Nat -> (v : i) -> List (a v)
  Totality: total
  Visibility: export
indexed : (d : (i -> IDesc List i)) -> (v : i) -> IEnumerator (Fix d) (Fix d v)
  Totality: total
  Visibility: export
0 Memorator : (d : Desc p) -> (Fix d -> Type) -> Type -> Type
  Totality: total
  Visibility: export
memorate : ((x : Fix d) -> Memorator d b (b x)) -> Nat -> (x : Fix d) -> List (b x)
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/papers/docs/Data.Enumerate.html b/papers/docs/Data.Enumerate.html
index 794d43c515..0f9ce4e37a 100644
--- a/papers/docs/Data.Enumerate.html
+++ b/papers/docs/Data.Enumerate.html
@@ -65,4 +65,4 @@
 A Completely Unique Account of Enumeration
 by Cas van der Rest, and Wouter Swierstra
 https://doi.org/10.1145/3547636
-
Definitions
record Enumerator : Type -> Type -> Type
  An (a,b)-enumerator is an enumerator for values of type b provided
  that we already know how to enumerate subterms of type a

  Totality: total
  Visibility: export
  Constructor: 
MkEnumerator : (List a -> List b) -> Enumerator a b

  Projection: 
.runEnumerator : Enumerator a b -> List a -> List b

  Hints:
  
Alternative (Enumerator a)
  
Applicative (Enumerator a)
  
Functor (Enumerator a)
  
Monad (Enumerator a)
pairWith : (b -> c -> d) -> Enumerator a b -> Enumerator a c -> Enumerator a d
  This interleaving is fair, unlike one defined using concatMap.
  Cf. paper for definition of fairness

  Totality: total
  Visibility: export
pair : Enumerator a b -> Enumerator a c -> Enumerator a (b, c)
  Totality: total
  Visibility: export
const : List b -> Enumerator a b
  Like `pure` but returns more than one result

  Totality: total
  Visibility: export
rec : Enumerator a a
  The construction of recursive substructures is memoised by
  simply passing the result of the recursive call

  Totality: total
  Visibility: export
sized : Enumerator a a -> Nat -> List a
  Assuming that the enumerator is building one layer of term,
  sized e n willl produce a list of values of depth n

  Totality: total
  Visibility: export
stream : Enumerator a a -> Stream (List a)
  Assuming that the enumerator is building one layer of term,
  stream e will produce a list of increasingly deep values

  Totality: total
  Visibility: export
regular : (d : Desc List) -> Enumerator (Fix d) (Fix d)
  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
record Enumerator : Type -> Type -> Type
  An (a,b)-enumerator is an enumerator for values of type b provided
  that we already know how to enumerate subterms of type a

  Totality: total
  Visibility: export
  Constructor: 
MkEnumerator : (List a -> List b) -> Enumerator a b

  Projection: 
.runEnumerator : Enumerator a b -> List a -> List b

  Hints:
  
Alternative (Enumerator a)
  
Applicative (Enumerator a)
  
Functor (Enumerator a)
  
Monad (Enumerator a)
pairWith : (b -> c -> d) -> Enumerator a b -> Enumerator a c -> Enumerator a d
  This interleaving is fair, unlike one defined using concatMap.
  Cf. paper for definition of fairness

  Totality: total
  Visibility: export
pair : Enumerator a b -> Enumerator a c -> Enumerator a (b, c)
  Totality: total
  Visibility: export
const : List b -> Enumerator a b
  Like `pure` but returns more than one result

  Totality: total
  Visibility: export
rec : Enumerator a a
  The construction of recursive substructures is memoised by
  simply passing the result of the recursive call

  Totality: total
  Visibility: export
sized : Enumerator a a -> Nat -> List a
  Assuming that the enumerator is building one layer of term,
  sized e n willl produce a list of values of depth n

  Totality: total
  Visibility: export
stream : Enumerator a a -> Stream (List a)
  Assuming that the enumerator is building one layer of term,
  stream e will produce a list of increasingly deep values

  Totality: total
  Visibility: export
regular : (d : Desc List) -> Enumerator (Fix d) (Fix d)
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/papers/docs/Data.INTEGER.html b/papers/docs/Data.INTEGER.html
index d87e859683..b114c8f9ca 100644
--- a/papers/docs/Data.INTEGER.html
+++ b/papers/docs/Data.INTEGER.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.INTEGER(source)
Definitions
data INTEGER : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Z : INTEGER
  
PS : Nat -> INTEGER
  
NS : Nat -> INTEGER

  Hints:
  
Cast Nat INTEGER
  
Cast Integer INTEGER
  
Cast INTEGER Integer
  
Neg INTEGER
  
Num INTEGER
  
Show INTEGER
add : INTEGER -> INTEGER -> INTEGER
  Totality: total
  Visibility: public export
mult : INTEGER -> INTEGER -> INTEGER
  Totality: total
  Visibility: public export
plusZeroRightNeutral : (m : INTEGER) -> m + Z = m
  Totality: total
  Visibility: export
plusCommutative : (m : INTEGER) -> (n : INTEGER) -> m + n = n + m
  Totality: total
  Visibility: export
castPlus : (m : Nat) -> (n : Nat) -> the INTEGER (cast (m + n)) = cast m + cast n
  Totality: total
  Visibility: export
unfoldPS : (m : Nat) -> PS m = 1 + cast m
  Totality: total
  Visibility: export
unfoldNS : (m : Nat) -> NS m = -1 - cast m
  Totality: total
  Visibility: export
difference : Nat -> Nat -> INTEGER
  Totality: total
  Visibility: export
differenceZeroRight : (n : Nat) -> difference n 0 = cast n
  Totality: total
  Visibility: export
minusSuccSucc : (m : Nat) -> (n : Nat) -> the INTEGER (cast (S m) - cast (S n)) = cast m - cast n
  Totality: total
  Visibility: export
unfoldDifference : (m : Nat) -> (n : Nat) -> difference m n = cast m - cast n
  Totality: total
  Visibility: export
negateInvolutive : (m : INTEGER) -> negate (negate m) = m
  Totality: total
  Visibility: export
negatePlus : (m : INTEGER) -> (n : INTEGER) -> negate (m + n) = negate m + negate n
  Totality: total
  Visibility: export
negateDifference : (m : Nat) -> (n : Nat) -> negate (difference m n) = difference n m
  Totality: total
  Visibility: export
minusZeroRight : (m : INTEGER) -> m - Z = m
  Totality: total
  Visibility: export
plusInverse : (m : INTEGER) -> m - m = Z
  Totality: total
  Visibility: export
plusAssociative : (m : INTEGER) -> (n : INTEGER) -> (p : INTEGER) -> m + (n + p) = (m + n) + p
  Totality: total
  Visibility: export

\ No newline at end of file
+
Data.INTEGER(source)
Definitions
data INTEGER : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Z : INTEGER
  
PS : Nat -> INTEGER
  
NS : Nat -> INTEGER

  Hints:
  
Cast Nat INTEGER
  
Cast Integer INTEGER
  
Cast INTEGER Integer
  
Neg INTEGER
  
Num INTEGER
  
Show INTEGER
add : INTEGER -> INTEGER -> INTEGER
  Totality: total
  Visibility: public export
mult : INTEGER -> INTEGER -> INTEGER
  Totality: total
  Visibility: public export
plusZeroRightNeutral : (m : INTEGER) -> m + Z = m
  Totality: total
  Visibility: export
plusCommutative : (m : INTEGER) -> (n : INTEGER) -> m + n = n + m
  Totality: total
  Visibility: export
castPlus : (m : Nat) -> (n : Nat) -> the INTEGER (cast (m + n)) = cast m + cast n
  Totality: total
  Visibility: export
unfoldPS : (m : Nat) -> PS m = 1 + cast m
  Totality: total
  Visibility: export
unfoldNS : (m : Nat) -> NS m = -1 - cast m
  Totality: total
  Visibility: export
difference : Nat -> Nat -> INTEGER
  Totality: total
  Visibility: export
differenceZeroRight : (n : Nat) -> difference n 0 = cast n
  Totality: total
  Visibility: export
minusSuccSucc : (m : Nat) -> (n : Nat) -> the INTEGER (cast (S m) - cast (S n)) = cast m - cast n
  Totality: total
  Visibility: export
unfoldDifference : (m : Nat) -> (n : Nat) -> difference m n = cast m - cast n
  Totality: total
  Visibility: export
negateInvolutive : (m : INTEGER) -> negate (negate m) = m
  Totality: total
  Visibility: export
negatePlus : (m : INTEGER) -> (n : INTEGER) -> negate (m + n) = negate m + negate n
  Totality: total
  Visibility: export
negateDifference : (m : Nat) -> (n : Nat) -> negate (difference m n) = difference n m
  Totality: total
  Visibility: export
minusZeroRight : (m : INTEGER) -> m - Z = m
  Totality: total
  Visibility: export
plusInverse : (m : INTEGER) -> m - m = Z
  Totality: total
  Visibility: export
plusAssociative : (m : INTEGER) -> (n : INTEGER) -> (p : INTEGER) -> m + (n + p) = (m + n) + p
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/papers/docs/Data.InductionRecursion.DybjerSetzer.html b/papers/docs/Data.InductionRecursion.DybjerSetzer.html
index 3be71f1aa8..2bfabd265e 100644
--- a/papers/docs/Data.InductionRecursion.DybjerSetzer.html
+++ b/papers/docs/Data.InductionRecursion.DybjerSetzer.html
@@ -64,4 +64,4 @@
 
Data.InductionRecursion.DybjerSetzer(source)
There are different flavours of induction-recursion. This is the one
 introduced in Dybjer and Setzer's paper:
 Indexed induction-recursion
-
Definitions
data Code : (sort -> Type) -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Yield : output -> Code input output
  
Store : (payload : Type) -> (payload -> Code input output) -> Code input output
  
Branch : (label : Type) -> (toSort : (label -> sort)) -> (((l : label) -> input (toSort l)) -> Code input output) -> Code input output

  Hints:
  
Applicative (Code i)
  
Functor (Code i)
  
Monad (Code i)
DecodeType : Code input output -> (x : (sort -> Type)) -> (x s -> input s) -> Type
  Visibility: public export
DecodeOutput : (c : Code input output) -> (x : Lazy (sort -> Type)) -> (f : (Force x s -> input s)) -> DecodeType c (Force x) (\{s:1027} => f) -> output
  Visibility: public export
data Mu : ((s : sort) -> Code input (input s)) -> sort -> Type
  Totality: not strictly positive
  Visibility: public export
  Constructor: 
MkMu : DecodeType (f s) (Mu f) (\{s:1208} => Decode) -> Mu f s
Decode : Mu f s -> input s
  Visibility: public export
bind : Code i o -> (o -> Code i o') -> Code i o'
  Visibility: public export

\ No newline at end of file
+
Definitions
data Code : (sort -> Type) -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Yield : output -> Code input output
  
Store : (payload : Type) -> (payload -> Code input output) -> Code input output
  
Branch : (label : Type) -> (toSort : (label -> sort)) -> (((l : label) -> input (toSort l)) -> Code input output) -> Code input output

  Hints:
  
Applicative (Code i)
  
Functor (Code i)
  
Monad (Code i)
DecodeType : Code input output -> (x : (sort -> Type)) -> (x s -> input s) -> Type
  Visibility: public export
DecodeOutput : (c : Code input output) -> (x : Lazy (sort -> Type)) -> (f : (Force x s -> input s)) -> DecodeType c (Force x) (\{s:1027} => f) -> output
  Visibility: public export
data Mu : ((s : sort) -> Code input (input s)) -> sort -> Type
  Totality: not strictly positive
  Visibility: public export
  Constructor: 
MkMu : DecodeType (f s) (Mu f) (\{s:1208} => Decode) -> Mu f s
Decode : Mu f s -> input s
  Visibility: public export
bind : Code i o -> (o -> Code i o') -> Code i o'
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Data.Linear.Communications.html b/papers/docs/Data.Linear.Communications.html
index 8ad636c8a3..81bb1be6e8 100644
--- a/papers/docs/Data.Linear.Communications.html
+++ b/papers/docs/Data.Linear.Communications.html
@@ -64,4 +64,4 @@
 
Data.Linear.Communications(source)
This module is based on the content of the functional pearl
 How to Take the Inverse of a Type
 by Daniel Marshall and Dominic Orchard
-
Definitions
data Protocol : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Send : Type -> Protocol -> Protocol
  
Recv : Type -> Protocol -> Protocol
  
End : Protocol
Dual : Protocol -> Protocol
  Totality: total
  Visibility: public export
data LChan : Protocol -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkLChan : LChan p

\ No newline at end of file
+
Definitions
data Protocol : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Send : Type -> Protocol -> Protocol
  
Recv : Type -> Protocol -> Protocol
  
End : Protocol
Dual : Protocol -> Protocol
  Totality: total
  Visibility: public export
data LChan : Protocol -> Type
  Totality: total
  Visibility: export
  Constructor: 
MkLChan : LChan p

\ No newline at end of file
diff --git a/papers/docs/Data.Linear.Diff.html b/papers/docs/Data.Linear.Diff.html
index 22ec256887..80babfd949 100644
--- a/papers/docs/Data.Linear.Diff.html
+++ b/papers/docs/Data.Linear.Diff.html
@@ -64,4 +64,4 @@
 
Data.Linear.Diff(source)
This module is based on the content of the functional pearl
 How to Take the Inverse of a Type
 by Daniel Marshall and Dominic Orchard
-
Definitions
Quadruple : Type -> Type
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
Quadruple : Type -> Type
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Data.Linear.Inverse.html b/papers/docs/Data.Linear.Inverse.html
index db48ef3521..38ee52c0e8 100644
--- a/papers/docs/Data.Linear.Inverse.html
+++ b/papers/docs/Data.Linear.Inverse.html
@@ -64,4 +64,4 @@
 
Data.Linear.Inverse(source)
This module is based on the content of the functional pearl
 How to Take the Inverse of a Type
 by Daniel Marshall and Dominic Orchard
-
Definitions
Inverse : Type -> Type
  Inverse is a shorthand for 'multiplicative skew inverse'

  Totality: total
  Visibility: export
mkInverse : (a -@ ()) -@ Inverse a
  Totality: total
  Visibility: export
divide : a -@ (Inverse a -@ ())
  And this is the morphism witnessing the multiplicative skew inverse

  Totality: total
  Visibility: export
doubleNegation : a -@ Inverse (Inverse a)
  Totality: total
  Visibility: export
maybeNeg : LMaybe a -@ (Inverse a -@ LMaybe (Inverse a))
  We only use the inverse of a if the LMaybe is actually Just.m

  Totality: total
  Visibility: export
lid : a -@ a
  Totality: total
  Visibility: public export
lcompose : (b -@ c) -@ ((a -@ b) -@ (a -@ c))
  Totality: total
  Visibility: public export
comap : (b -@ a) -@ (Inverse a -@ Inverse b)
  Totality: total
  Visibility: public export
comapId : (u : Inverse a) -> comap lid u = lid u
  Totality: total
  Visibility: export
comapComp : (u : Inverse a) -> comap (lcompose g f) u = lcompose (comap f) (comap g) u
  Totality: total
  Visibility: export
munit : () -@ Inverse ()
  Totality: total
  Visibility: export
mmult : Inverse a -@ (Inverse b -@ Inverse (LPair a b))
  Totality: total
  Visibility: export
Pow : Type -> INTEGER -> Type
  Totality: total
  Visibility: public export
zip : Pow a n -@ (Pow b n -@ Pow (LPair a b) n)
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 6
powPositiveL : (m : Nat) -> (n : Nat) -> Pow a (cast (m + n)) -@ LPair (Pow a (cast m)) (Pow a (cast n))
  Totality: total
  Visibility: export
powPositiveR : (m : Nat) -> (n : Nat) -> Pow a (cast m) -@ (Pow a (cast n) -@ Pow a (cast (m + n)))
  Totality: total
  Visibility: export
powNegateL : (m : Nat) -> Pow a (negate (cast m)) -> Pow (Inverse a) (cast m)
  Totality: total
  Visibility: export
powNegateR : (m : Nat) -> Pow (Inverse a) (cast m) -> Pow a (negate (cast m))
  Totality: total
  Visibility: export
powNegativeL : (m : Nat) -> (n : Nat) -> Pow a (negate (cast (m + n))) -@ LPair (Pow a (negate (cast m))) (Pow a (negate (cast n)))
  Totality: total
  Visibility: export
powNegativeR : (m : Nat) -> (n : Nat) -> Pow a (negate (cast m)) -@ (Pow a (negate (cast n)) -@ Pow a (negate (cast (m + n))))
  Totality: total
  Visibility: export
powAnnihilate : (m : Nat) -> Pow a (cast m) -@ (Pow a (negate (cast m)) -@ ())
  Totality: total
  Visibility: export
powMinus : (m : Nat) -> (n : Nat) -> Pow a (cast m) -@ (Pow a (negate (cast n)) -@ Pow a (cast m - cast n))
  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
Inverse : Type -> Type
  Inverse is a shorthand for 'multiplicative skew inverse'

  Totality: total
  Visibility: export
mkInverse : (a -@ ()) -@ Inverse a
  Totality: total
  Visibility: export
divide : a -@ (Inverse a -@ ())
  And this is the morphism witnessing the multiplicative skew inverse

  Totality: total
  Visibility: export
doubleNegation : a -@ Inverse (Inverse a)
  Totality: total
  Visibility: export
maybeNeg : LMaybe a -@ (Inverse a -@ LMaybe (Inverse a))
  We only use the inverse of a if the LMaybe is actually Just.m

  Totality: total
  Visibility: export
lid : a -@ a
  Totality: total
  Visibility: public export
lcompose : (b -@ c) -@ ((a -@ b) -@ (a -@ c))
  Totality: total
  Visibility: public export
comap : (b -@ a) -@ (Inverse a -@ Inverse b)
  Totality: total
  Visibility: public export
comapId : (u : Inverse a) -> comap lid u = lid u
  Totality: total
  Visibility: export
comapComp : (u : Inverse a) -> comap (lcompose g f) u = lcompose (comap f) (comap g) u
  Totality: total
  Visibility: export
munit : () -@ Inverse ()
  Totality: total
  Visibility: export
mmult : Inverse a -@ (Inverse b -@ Inverse (LPair a b))
  Totality: total
  Visibility: export
Pow : Type -> INTEGER -> Type
  Totality: total
  Visibility: public export
zip : Pow a n -@ (Pow b n -@ Pow (LPair a b) n)
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 6
powPositiveL : (m : Nat) -> (n : Nat) -> Pow a (cast (m + n)) -@ LPair (Pow a (cast m)) (Pow a (cast n))
  Totality: total
  Visibility: export
powPositiveR : (m : Nat) -> (n : Nat) -> Pow a (cast m) -@ (Pow a (cast n) -@ Pow a (cast (m + n)))
  Totality: total
  Visibility: export
powNegateL : (m : Nat) -> Pow a (negate (cast m)) -> Pow (Inverse a) (cast m)
  Totality: total
  Visibility: export
powNegateR : (m : Nat) -> Pow (Inverse a) (cast m) -> Pow a (negate (cast m))
  Totality: total
  Visibility: export
powNegativeL : (m : Nat) -> (n : Nat) -> Pow a (negate (cast (m + n))) -@ LPair (Pow a (negate (cast m))) (Pow a (negate (cast n)))
  Totality: total
  Visibility: export
powNegativeR : (m : Nat) -> (n : Nat) -> Pow a (negate (cast m)) -@ (Pow a (negate (cast n)) -@ Pow a (negate (cast (m + n))))
  Totality: total
  Visibility: export
powAnnihilate : (m : Nat) -> Pow a (cast m) -@ (Pow a (negate (cast m)) -@ ())
  Totality: total
  Visibility: export
powMinus : (m : Nat) -> (n : Nat) -> Pow a (cast m) -@ (Pow a (negate (cast n)) -@ Pow a (cast m - cast n))
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/papers/docs/Data.OpenUnion.html b/papers/docs/Data.OpenUnion.html
index 10af504243..3059e0da7a 100644
--- a/papers/docs/Data.OpenUnion.html
+++ b/papers/docs/Data.OpenUnion.html
@@ -67,4 +67,4 @@
 
 By using an AtIndex proof, we are able to get rid of all of the unsafe
 coercions in the original module.
-
Definitions
data Union : (a -> Type) -> List a -> Type
  An open union of families is an index picking a family out together with
  a value in the family thus picked.

  Totality: total
  Visibility: public export
  Constructor: 
Element : (k : Nat) -> (0 _ : AtIndex t ts k) -> elt t -> Union elt ts

  Hint: 
Uninhabited (Union elt [])
inj : Member t ts => elt t -> Union elt ts
  Given that equality of type families is not decidable, we have to
  rely on the interface `Member` to automatically find the index of a
  given family.

  Totality: total
  Visibility: public export
prj : Member t ts => Union elt ts -> Maybe (elt t)
  Given that equality of type families is not decidable, we have to
  rely on the interface `Member` to automatically find the index of a
  given family.

  Totality: total
  Visibility: public export
split : Subset Nat (flip HasLength ss) -> Union elt (ss ++ ts) -> Either (Union elt ss) (Union elt ts)
  By doing a bit of arithmetic we can figure out whether the union's value
  came from the left or the right list used in the index.

  Totality: total
  Visibility: public export
decomp : Union elt (t :: ts) -> Either (Union elt ts) (elt t)
  We can inspect an open union over a non-empty list of families to check
  whether the value it contains belongs either to the first family or any
  other in the tail.

  Totality: total
  Visibility: public export
decomp0 : Union elt [t] -> elt t
  An open union over a singleton list is just a wrapper

  Totality: total
  Visibility: public export
weakenR : Union elt ts -> Union elt (ts ++ us)
  Inserting new union members on the right leaves the index unchanged.

  Totality: total
  Visibility: public export
weakenL : Subset Nat (flip HasLength ss) -> Union elt ts -> Union elt (ss ++ ts)
  Inserting new union members on the left, requires shifting the index by
  the number of members introduced. Note that this number is the only
  thing we need to keep around at runtime.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
data Union : (a -> Type) -> List a -> Type
  An open union of families is an index picking a family out together with
  a value in the family thus picked.

  Totality: total
  Visibility: public export
  Constructor: 
Element : (k : Nat) -> (0 _ : AtIndex t ts k) -> elt t -> Union elt ts

  Hint: 
Uninhabited (Union elt [])
inj : Member t ts => elt t -> Union elt ts
  Given that equality of type families is not decidable, we have to
  rely on the interface `Member` to automatically find the index of a
  given family.

  Totality: total
  Visibility: public export
prj : Member t ts => Union elt ts -> Maybe (elt t)
  Given that equality of type families is not decidable, we have to
  rely on the interface `Member` to automatically find the index of a
  given family.

  Totality: total
  Visibility: public export
split : Subset Nat (flip HasLength ss) -> Union elt (ss ++ ts) -> Either (Union elt ss) (Union elt ts)
  By doing a bit of arithmetic we can figure out whether the union's value
  came from the left or the right list used in the index.

  Totality: total
  Visibility: public export
decomp : Union elt (t :: ts) -> Either (Union elt ts) (elt t)
  We can inspect an open union over a non-empty list of families to check
  whether the value it contains belongs either to the first family or any
  other in the tail.

  Totality: total
  Visibility: public export
decomp0 : Union elt [t] -> elt t
  An open union over a singleton list is just a wrapper

  Totality: total
  Visibility: public export
weakenR : Union elt ts -> Union elt (ts ++ us)
  Inserting new union members on the right leaves the index unchanged.

  Totality: total
  Visibility: public export
weakenL : Subset Nat (flip HasLength ss) -> Union elt ts -> Union elt (ss ++ ts)
  Inserting new union members on the left, requires shifting the index by
  the number of members introduced. Note that this number is the only
  thing we need to keep around at runtime.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Data.ProofDelay.html b/papers/docs/Data.ProofDelay.html
index 08f830b3f4..b9f4ebfeec 100644
--- a/papers/docs/Data.ProofDelay.html
+++ b/papers/docs/Data.ProofDelay.html
@@ -65,4 +65,4 @@
 Deferring the Details and Deriving Programs
 by Liam O'Connor
 https://doi.org/10.1145/3331554.3342605
-
Definitions
record PDelay : Type -> Type
  A type `x` which can only be computed once some, delayed, proof obligations
  have been fulfilled.

  Totality: total
  Visibility: public export
  Constructor: 
Prf : (goals : List Type) -> (HList goals -> x) -> PDelay x

  Projections:
  
.goals : PDelay x -> List Type
  List of propositions we need to prove.
  
.prove : ({rec:0} : PDelay x) -> HList (goals {rec:0}) -> x
  Given the proofs required (i.e. the goals), actually compute the value x.
.goals : PDelay x -> List Type
  List of propositions we need to prove.

  Totality: total
  Visibility: public export
goals : PDelay x -> List Type
  List of propositions we need to prove.

  Totality: total
  Visibility: public export
.prove : ({rec:0} : PDelay x) -> HList (goals {rec:0}) -> x
  Given the proofs required (i.e. the goals), actually compute the value x.

  Totality: total
  Visibility: public export
prove : ({rec:0} : PDelay x) -> HList (goals {rec:0}) -> x
  Given the proofs required (i.e. the goals), actually compute the value x.

  Totality: total
  Visibility: public export
pure : tx -> PDelay tx
  A value which can immediately be constructed (i.e. no delayed proofs).

  Totality: total
  Visibility: public export
later : PDelay tx
  Delay the full computation of `x` until `later`.

  Totality: total
  Visibility: public export
(<*>) : PDelay (a -> b) -> PDelay a -> PDelay b
  We can compose `PDelay` computations.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 3
data OList : Nat -> Nat -> Type
  An ordered list type.
  
  [27](https://dl.acm.org/doi/10.1145/2503778.2503786)

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : LTE m n -> OList m n
  
Cons : (x : Nat) -> LTE m x -> OList x n -> OList m n
data BST : Nat -> Nat -> Type
  A binary search tree carrying proofs of the ordering in the leaves.
  
  [31](https://dl.acm.org/doi/10.1145/2628136.2628163)

  Totality: total
  Visibility: public export
  Constructors:
  
Leaf : LTE m n -> BST m n
  
Branch : (x : Nat) -> BST m x -> BST x n -> BST m n
nil : PDelay (OList m n)
  OList `Nil`, but delaying the proof obligation.

  Totality: total
  Visibility: public export
cons : (x : Nat) -> PDelay (OList x n) -> PDelay (OList m n)
  OList `Cons`, but delaying the proof obligations.

  Totality: total
  Visibility: public export
example : OList 1 5
  Extracting an actual `OList` from the delayed version requires providing the
  unergonomic proofs.

  Totality: total
  Visibility: public export
leaf : PDelay (BST m n)
  BST `Leaf`, but delaying the proof obligation.

  Totality: total
  Visibility: public export
branch : (x : Nat) -> PDelay (BST m x) -> PDelay (BST x n) -> PDelay (BST m n)
  BST `Branch`, but delaying the proof obligations.

  Totality: total
  Visibility: public export
example2 : BST 2 10
  Once again, extracting the actual `BST` requires providing the uninteresting
  proofs.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
record PDelay : Type -> Type
  A type `x` which can only be computed once some, delayed, proof obligations
  have been fulfilled.

  Totality: total
  Visibility: public export
  Constructor: 
Prf : (goals : List Type) -> (HList goals -> x) -> PDelay x

  Projections:
  
.goals : PDelay x -> List Type
  List of propositions we need to prove.
  
.prove : ({rec:0} : PDelay x) -> HList (goals {rec:0}) -> x
  Given the proofs required (i.e. the goals), actually compute the value x.
.goals : PDelay x -> List Type
  List of propositions we need to prove.

  Totality: total
  Visibility: public export
goals : PDelay x -> List Type
  List of propositions we need to prove.

  Totality: total
  Visibility: public export
.prove : ({rec:0} : PDelay x) -> HList (goals {rec:0}) -> x
  Given the proofs required (i.e. the goals), actually compute the value x.

  Totality: total
  Visibility: public export
prove : ({rec:0} : PDelay x) -> HList (goals {rec:0}) -> x
  Given the proofs required (i.e. the goals), actually compute the value x.

  Totality: total
  Visibility: public export
pure : tx -> PDelay tx
  A value which can immediately be constructed (i.e. no delayed proofs).

  Totality: total
  Visibility: public export
later : PDelay tx
  Delay the full computation of `x` until `later`.

  Totality: total
  Visibility: public export
(<*>) : PDelay (a -> b) -> PDelay a -> PDelay b
  We can compose `PDelay` computations.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 3
data OList : Nat -> Nat -> Type
  An ordered list type.
  
  [27](https://dl.acm.org/doi/10.1145/2503778.2503786)

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : LTE m n -> OList m n
  
Cons : (x : Nat) -> LTE m x -> OList x n -> OList m n
data BST : Nat -> Nat -> Type
  A binary search tree carrying proofs of the ordering in the leaves.
  
  [31](https://dl.acm.org/doi/10.1145/2628136.2628163)

  Totality: total
  Visibility: public export
  Constructors:
  
Leaf : LTE m n -> BST m n
  
Branch : (x : Nat) -> BST m x -> BST x n -> BST m n
nil : PDelay (OList m n)
  OList `Nil`, but delaying the proof obligation.

  Totality: total
  Visibility: public export
cons : (x : Nat) -> PDelay (OList x n) -> PDelay (OList m n)
  OList `Cons`, but delaying the proof obligations.

  Totality: total
  Visibility: public export
example : OList 1 5
  Extracting an actual `OList` from the delayed version requires providing the
  unergonomic proofs.

  Totality: total
  Visibility: public export
leaf : PDelay (BST m n)
  BST `Leaf`, but delaying the proof obligation.

  Totality: total
  Visibility: public export
branch : (x : Nat) -> PDelay (BST m x) -> PDelay (BST x n) -> PDelay (BST m n)
  BST `Branch`, but delaying the proof obligations.

  Totality: total
  Visibility: public export
example2 : BST 2 10
  Once again, extracting the actual `BST` requires providing the uninteresting
  proofs.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Data.Recursion.Free.html b/papers/docs/Data.Recursion.Free.html
index dd641ddebe..4c42e9a1e4 100644
--- a/papers/docs/Data.Recursion.Free.html
+++ b/papers/docs/Data.Recursion.Free.html
@@ -72,4 +72,4 @@
 domain/evaluation pair by computing a Dybjer-Setzer code we build a
 specialised structure that allows us to make the domain proof runtime
 irrelevant.
-
Definitions
data General : (a : Type) -> (a -> Type) -> Type -> Type
  Syntax for a program using general recursion

  Totality: total
  Visibility: public export
  Constructors:
  
Tell : x -> General a b x
  We can return a value without performing any recursive call.
  
Ask : (i : a) -> (b i -> General a b x) -> General a b x
  Or we can pick an input and ask an oracle to give us a return value
  for it. The second argument is a continuation explaining what we want
  to do with the returned value.

  Hints:
  
Applicative (General a b)
  
Functor (General a b)
  
Monad (General a b)
PiG : (a : Type) -> (a -> Type) -> Type
  Type of functions using general recursion

  Totality: total
  Visibility: public export
fold : (x -> y) -> ((i : a) -> (b i -> y) -> y) -> General a b x -> y
  Recursor for General

  Totality: total
  Visibility: public export
call : PiG a b
  Perform a recursive call and return the value provided by the oracle.

  Totality: total
  Visibility: public export
bind : General a b x -> (x -> General a b y) -> General a b y
  Monadic bind (defined outside of the interface to be able to use it for
  map and (<*>)).

  Totality: total
  Visibility: public export
monadMorphism : Monad m => ((i : a) -> m (b i)) -> General a b x -> m x
  Given a monadic oracle we can give a monad morphism interpreting a
  function using general recursion as a monadic process.

  Totality: total
  Visibility: public export
already : General a b x -> Maybe x
  Check whehther we are ready to return a value

  Totality: total
  Visibility: public export
expand : PiG a b -> General a b x -> General a b x
  Use a function using general recursion to expand all of the oracle calls.

  Totality: total
  Visibility: public export
engine : PiG a b -> Nat -> General a b x -> General a b x
  Recursively call expand a set number of times.

  Totality: total
  Visibility: public export
petrol : PiG a b -> Nat -> (i : a) -> Maybe (b i)
  Check whether recursively calling expand a set number of times is enough
  to produce a value.

  Totality: total
  Visibility: public export
late : PiG a b -> General a b x -> Late x
  Rely on an oracle using general recursion to convert a function using
  general recursion into a process returning a value in the (distant) future.

  Totality: total
  Visibility: public export
lazy : PiG a b -> (i : a) -> Late (b i)
  Interpret a function using general recursion as a process returning
  a value in the (distant) future.

  Totality: total
  Visibility: public export
Domain : PiG a b -> (i : a) -> Code b (b i)
  Compute, as a Dybjer-Setzer code for an inductive-recursive type, the domain
  of a function defined by general recursion.

  Totality: total
  Visibility: public export
evaluate : (f : PiG a b) -> (i : a) -> Mu (Domain f) i -> b i
  If a given input is in the domain of the function then we may evaluate
  it fully on that input and obtain a pure return value.

  Totality: total
  Visibility: public export
totally : (f : PiG a b) -> ((i : a) -> Mu (Domain f) i) -> (i : a) -> b i
  If every input value is in the domain then the function is total.

  Totality: total
  Visibility: public export
data Layer : PiG a b -> General a b (b i) -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
MkTell : (o : b i) -> Layer f (Tell o)
  A computation returning a value is trivially terminating
  
MkAsk : (j : a) -> (jprf : Domain f j) -> (k : (b j -> General a b (b i))) -> Layer f (k (evaluate f j jprf)) -> Layer f (Ask j k)
  Performing a call to the oracle is termnating if the input is in its
  domain and if the rest of the computation is also finite.
view : (d : General a b (b i)) -> (0 l : Layer f d) -> View l
  Function computing the view by pattern-matching on the computation and
  inverting the proof. Note that the proof is runtime irrelevant even though
  the resulting view is not: this is possible because the relevant constructor
  is uniquely determined by the shape of `d`.

  Totality: total
  Visibility: public export
totally : (f : PiG a b) -> (0 _ : ((i : a) -> Domain f i)) -> (i : a) -> b i
  If a function's domain is total then it is a pure function.

  Totality: total
  Visibility: public export
irrelevantDomain : (f : PiG a b) -> (i : a) -> (p : Domain f i) -> (q : Domain f i) -> p = q
  Domain is a singleton type

  Totality: total
  Visibility: export
evaluateLayerIrrelevance : (f : PiG a b) -> (d : General a b (b i)) -> (0 p : Layer f d) -> (0 q : Layer f d) -> evaluateLayer f d p = evaluateLayer f d q
  The result of `evaluateLayer` does not depend on the specific proof that
  `i` is in the domain of the layer of computation at hand.

  Totality: total
  Visibility: export
evaluateIrrelevance : (f : PiG a b) -> (i : a) -> (0 p : Domain f i) -> (0 q : Domain f i) -> evaluate f i p = evaluate f i q
  The result of `evaluate` does not depend on the specific proof that `i`
  is in the domain of the function at hand.

  Totality: total
  Visibility: export
totallyIrrelevance : (f : PiG a b) -> (0 p : ((i : a) -> Domain f i)) -> (0 q : ((i : a) -> Domain f i)) -> (i : a) -> totally f p i = totally f q i
  The result computed by a total function is independent from the proof
  that it is total.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
data General : (a : Type) -> (a -> Type) -> Type -> Type
  Syntax for a program using general recursion

  Totality: total
  Visibility: public export
  Constructors:
  
Tell : x -> General a b x
  We can return a value without performing any recursive call.
  
Ask : (i : a) -> (b i -> General a b x) -> General a b x
  Or we can pick an input and ask an oracle to give us a return value
  for it. The second argument is a continuation explaining what we want
  to do with the returned value.

  Hints:
  
Applicative (General a b)
  
Functor (General a b)
  
Monad (General a b)
PiG : (a : Type) -> (a -> Type) -> Type
  Type of functions using general recursion

  Totality: total
  Visibility: public export
fold : (x -> y) -> ((i : a) -> (b i -> y) -> y) -> General a b x -> y
  Recursor for General

  Totality: total
  Visibility: public export
call : PiG a b
  Perform a recursive call and return the value provided by the oracle.

  Totality: total
  Visibility: public export
bind : General a b x -> (x -> General a b y) -> General a b y
  Monadic bind (defined outside of the interface to be able to use it for
  map and (<*>)).

  Totality: total
  Visibility: public export
monadMorphism : Monad m => ((i : a) -> m (b i)) -> General a b x -> m x
  Given a monadic oracle we can give a monad morphism interpreting a
  function using general recursion as a monadic process.

  Totality: total
  Visibility: public export
already : General a b x -> Maybe x
  Check whehther we are ready to return a value

  Totality: total
  Visibility: public export
expand : PiG a b -> General a b x -> General a b x
  Use a function using general recursion to expand all of the oracle calls.

  Totality: total
  Visibility: public export
engine : PiG a b -> Nat -> General a b x -> General a b x
  Recursively call expand a set number of times.

  Totality: total
  Visibility: public export
petrol : PiG a b -> Nat -> (i : a) -> Maybe (b i)
  Check whether recursively calling expand a set number of times is enough
  to produce a value.

  Totality: total
  Visibility: public export
late : PiG a b -> General a b x -> Late x
  Rely on an oracle using general recursion to convert a function using
  general recursion into a process returning a value in the (distant) future.

  Totality: total
  Visibility: public export
lazy : PiG a b -> (i : a) -> Late (b i)
  Interpret a function using general recursion as a process returning
  a value in the (distant) future.

  Totality: total
  Visibility: public export
Domain : PiG a b -> (i : a) -> Code b (b i)
  Compute, as a Dybjer-Setzer code for an inductive-recursive type, the domain
  of a function defined by general recursion.

  Totality: total
  Visibility: public export
evaluate : (f : PiG a b) -> (i : a) -> Mu (Domain f) i -> b i
  If a given input is in the domain of the function then we may evaluate
  it fully on that input and obtain a pure return value.

  Totality: total
  Visibility: public export
totally : (f : PiG a b) -> ((i : a) -> Mu (Domain f) i) -> (i : a) -> b i
  If every input value is in the domain then the function is total.

  Totality: total
  Visibility: public export
data Layer : PiG a b -> General a b (b i) -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
MkTell : (o : b i) -> Layer f (Tell o)
  A computation returning a value is trivially terminating
  
MkAsk : (j : a) -> (jprf : Domain f j) -> (k : (b j -> General a b (b i))) -> Layer f (k (evaluate f j jprf)) -> Layer f (Ask j k)
  Performing a call to the oracle is termnating if the input is in its
  domain and if the rest of the computation is also finite.
view : (d : General a b (b i)) -> (0 l : Layer f d) -> View l
  Function computing the view by pattern-matching on the computation and
  inverting the proof. Note that the proof is runtime irrelevant even though
  the resulting view is not: this is possible because the relevant constructor
  is uniquely determined by the shape of `d`.

  Totality: total
  Visibility: public export
totally : (f : PiG a b) -> (0 _ : ((i : a) -> Domain f i)) -> (i : a) -> b i
  If a function's domain is total then it is a pure function.

  Totality: total
  Visibility: public export
irrelevantDomain : (f : PiG a b) -> (i : a) -> (p : Domain f i) -> (q : Domain f i) -> p = q
  Domain is a singleton type

  Totality: total
  Visibility: export
evaluateLayerIrrelevance : (f : PiG a b) -> (d : General a b (b i)) -> (0 p : Layer f d) -> (0 q : Layer f d) -> evaluateLayer f d p = evaluateLayer f d q
  The result of `evaluateLayer` does not depend on the specific proof that
  `i` is in the domain of the layer of computation at hand.

  Totality: total
  Visibility: export
evaluateIrrelevance : (f : PiG a b) -> (i : a) -> (0 p : Domain f i) -> (0 q : Domain f i) -> evaluate f i p = evaluate f i q
  The result of `evaluate` does not depend on the specific proof that `i`
  is in the domain of the function at hand.

  Totality: total
  Visibility: export
totallyIrrelevance : (f : PiG a b) -> (0 p : ((i : a) -> Domain f i)) -> (0 q : ((i : a) -> Domain f i)) -> (i : a) -> totally f p i = totally f q i
  The result computed by a total function is independent from the proof
  that it is total.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/papers/docs/Data.Tree.Perfect.html b/papers/docs/Data.Tree.Perfect.html
index 932514f4d9..e15e342b5e 100644
--- a/papers/docs/Data.Tree.Perfect.html
+++ b/papers/docs/Data.Tree.Perfect.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.Tree.Perfect(source)
Definitions
data Tree : Nat -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Leaf : a -> Tree 0 a
  
Node : Tree n a -> Tree n a -> Tree (S n) a

  Hints:
  
Applicative (Tree n)
  
Functor (Tree n)
replicate : (n : Nat) -> a -> Tree n a
  Totality: total
  Visibility: public export
data Path : Nat -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Here : Path 0
  
Left : Path n -> Path (S n)
  
Right : Path n -> Path (S n)
toNat : Path n -> Nat
  Totality: total
  Visibility: public export
toNatBounded : (n : Nat) -> (p : Path n) -> LT (toNat p) (pow2 n)
  Totality: total
  Visibility: export
data View : Nat -> Nat -> Type
  This pattern-matching in `fromNat` is annoying:
  The    `Z (S _)` case is impossible
  In the `k (S n)` case we want to branch on whether `k `LT` pow2 n`
  and get our hands on some proofs.
  This view factors out that work.

  Totality: total
  Visibility: public export
  Constructors:
  
ZZ : View 0 0
  
SLT : (0 _ : LT k (pow2 n)) -> View k (S n)
  
SNLT : (0 _ : GTE k (pow2 n)) -> (0 _ : LT (minus k (pow2 n)) (pow2 n)) -> View k (S n)
view : (k : Nat) -> (n : Nat) -> (0 _ : LT k (pow2 n)) -> View k n
  Totality: total
  Visibility: public export
fromNat : (k : Nat) -> (n : Nat) -> (0 _ : LT k (pow2 n)) -> Path n
  Convert a natural number to a path in a perfect binary tree

  Totality: total
  Visibility: public export
fromNatCorrect : (k : Nat) -> (n : Nat) -> (0 p : LT k (pow2 n)) -> toNat (fromNat k n p) = k
  The `fromNat` conversion is compatible with the semantics `toNat`

  Totality: total
  Visibility: export
lookup : Tree n a -> Path n -> a
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Data.Tree.Perfect(source)
Definitions
data Tree : Nat -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Leaf : a -> Tree 0 a
  
Node : Tree n a -> Tree n a -> Tree (S n) a

  Hints:
  
Applicative (Tree n)
  
Functor (Tree n)
replicate : (n : Nat) -> a -> Tree n a
  Totality: total
  Visibility: public export
data Path : Nat -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Here : Path 0
  
Left : Path n -> Path (S n)
  
Right : Path n -> Path (S n)
toNat : Path n -> Nat
  Totality: total
  Visibility: public export
toNatBounded : (n : Nat) -> (p : Path n) -> LT (toNat p) (pow2 n)
  Totality: total
  Visibility: export
data View : Nat -> Nat -> Type
  This pattern-matching in `fromNat` is annoying:
  The    `Z (S _)` case is impossible
  In the `k (S n)` case we want to branch on whether `k `LT` pow2 n`
  and get our hands on some proofs.
  This view factors out that work.

  Totality: total
  Visibility: public export
  Constructors:
  
ZZ : View 0 0
  
SLT : (0 _ : LT k (pow2 n)) -> View k (S n)
  
SNLT : (0 _ : GTE k (pow2 n)) -> (0 _ : LT (minus k (pow2 n)) (pow2 n)) -> View k (S n)
view : (k : Nat) -> (n : Nat) -> (0 _ : LT k (pow2 n)) -> View k n
  Totality: total
  Visibility: public export
fromNat : (k : Nat) -> (n : Nat) -> (0 _ : LT k (pow2 n)) -> Path n
  Convert a natural number to a path in a perfect binary tree

  Totality: total
  Visibility: public export
fromNatCorrect : (k : Nat) -> (n : Nat) -> (0 p : LT k (pow2 n)) -> toNat (fromNat k n p) = k
  The `fromNat` conversion is compatible with the semantics `toNat`

  Totality: total
  Visibility: export
lookup : Tree n a -> Path n -> a
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Data.Vect.Binary.html b/papers/docs/Data.Vect.Binary.html
index 3b7f2f924c..78c63b1e43 100644
--- a/papers/docs/Data.Vect.Binary.html
+++ b/papers/docs/Data.Vect.Binary.html
@@ -63,4 +63,4 @@
 
 
Data.Vect.Binary(source)
The content of this file is taken from the paper
 Heterogeneous Binary Random-access lists
-
Definitions
data BVect : Nat -> Bin -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : BVect n [] a
  
(::) : IMaybe (isI b) (Tree n a) -> BVect (S n) bs a -> BVect n (b :: bs) a
data Path : Nat -> Bin -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Here : Path n -> Path n (I :: bs)
  
There : Path (S n) bs -> Path n (b :: bs)
zero : Path n (suc bs)
  Totality: total
  Visibility: public export
lookup : BVect n bs a -> Path n bs -> a
  Totality: total
  Visibility: public export
cons : Tree n a -> BVect n bs a -> BVect n (suc bs) a
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
data BVect : Nat -> Bin -> Type -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : BVect n [] a
  
(::) : IMaybe (isI b) (Tree n a) -> BVect (S n) bs a -> BVect n (b :: bs) a
data Path : Nat -> Bin -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Here : Path n -> Path n (I :: bs)
  
There : Path (S n) bs -> Path n (b :: bs)
zero : Path n (suc bs)
  Totality: total
  Visibility: public export
lookup : BVect n bs a -> Path n bs -> a
  Totality: total
  Visibility: public export
cons : Tree n a -> BVect n bs a -> BVect n (suc bs) a
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Data.W.html b/papers/docs/Data.W.html
index d9408d6c8b..9045a0a3cb 100644
--- a/papers/docs/Data.W.html
+++ b/papers/docs/Data.W.html
@@ -61,4 +61,4 @@
 
 
 
-
Data.W(source)
Definitions
fromString : String -> Fin
  Totality: total
  Visibility: public export
fromString : (nm : String) -> IsJust (lookup d nm) => Shape d
  Totality: total
  Visibility: export
lam : ((x : Elem d) -> b $$ x) -> Pi d b
  Totality: total
  Visibility: export
appArr : (d : Fin) -> PiArr d b -> (x : Elem d) -> appArr d b x
  Totality: total
  Visibility: public export
($$) : Pi d b -> (x : Elem d) -> b $$ x
  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 0
beta : (f : ((x : Elem d) -> b $$ x)) -> (x : Elem d) -> lam f $$ x = f x
  Totality: total
  Visibility: export
eta : (f : Pi d b) -> lam (\x => f $$ x) = f
  Totality: total
  Visibility: export
ext : (f : ((x : Elem d) -> b $$ x)) -> (g : ((x : Elem d) -> b $$ x)) -> ((x : Elem d) -> f x = g x) -> lam f = lam g
  Totality: total
  Visibility: export
NAT : Type
  Totality: total
  Visibility: public export
lamArr : (d : Fin) -> (e : Arr d Type) -> (k : Arr d e Type) -> ((x : ElemArr d e) -> appArr d e k x) -> PiArr d e k
  Totality: total
  Visibility: public export
lam : ((x : Elem p) -> k $$ x) -> Pi p k
  Totality: total
  Visibility: public export
appArr : (d : Fin) -> (e : Arr d Type) -> (k : Arr d e Type) -> PiArr d e k -> (x : ElemArr d e) -> appArr d e k x
  Totality: total
  Visibility: public export
($$) : Pi p k -> (x : Elem p) -> k $$ x
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 0

\ No newline at end of file
+
Data.W(source)
Definitions
fromString : String -> Fin
  Totality: total
  Visibility: public export
fromString : (nm : String) -> IsJust (lookup d nm) => Shape d
  Totality: total
  Visibility: export
lam : ((x : Elem d) -> b $$ x) -> Pi d b
  Totality: total
  Visibility: export
appArr : (d : Fin) -> PiArr d b -> (x : Elem d) -> appArr d b x
  Totality: total
  Visibility: public export
($$) : Pi d b -> (x : Elem d) -> b $$ x
  Totality: total
  Visibility: export
  Fixity Declaration: infixl operator, level 0
beta : (f : ((x : Elem d) -> b $$ x)) -> (x : Elem d) -> lam f $$ x = f x
  Totality: total
  Visibility: export
eta : (f : Pi d b) -> lam (\x => f $$ x) = f
  Totality: total
  Visibility: export
ext : (f : ((x : Elem d) -> b $$ x)) -> (g : ((x : Elem d) -> b $$ x)) -> ((x : Elem d) -> f x = g x) -> lam f = lam g
  Totality: total
  Visibility: export
NAT : Type
  Totality: total
  Visibility: public export
lamArr : (d : Fin) -> (e : Arr d Type) -> (k : Arr d e Type) -> ((x : ElemArr d e) -> appArr d e k x) -> PiArr d e k
  Totality: total
  Visibility: public export
lam : ((x : Elem p) -> k $$ x) -> Pi p k
  Totality: total
  Visibility: public export
appArr : (d : Fin) -> (e : Arr d Type) -> (k : Arr d e Type) -> PiArr d e k -> (x : ElemArr d e) -> appArr d e k x
  Totality: total
  Visibility: public export
($$) : Pi p k -> (x : Elem p) -> k $$ x
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 0

\ No newline at end of file
diff --git a/papers/docs/Language.IntrinsicScoping.TypeTheory.html b/papers/docs/Language.IntrinsicScoping.TypeTheory.html
index 39caf7e9a6..8499f51cd9 100644
--- a/papers/docs/Language.IntrinsicScoping.TypeTheory.html
+++ b/papers/docs/Language.IntrinsicScoping.TypeTheory.html
@@ -67,4 +67,4 @@
 
 NB: Unlike `Language.TypeTheory`, this is not a direct translation
     of the code in the paper but rather a more idiomatic solution.
-
Definitions
Scoped : Type
  Visibility: public export
thin : (0 ext : List Name) -> Check f g -> Check (ext ++ f) g
  Visibility: export
thin : (0 ext : List Name) -> Infer f g -> Infer (ext ++ f) g
  Visibility: export
closed : (0 g : SnocList Name) -> Infer f [<] -> Infer f g
  Visibility: export
thin : (0 ext : List Name) -> Value f -> Value (ext ++ f)
  Visibility: export

\ No newline at end of file
+
Definitions
Scoped : Type
  Visibility: public export
thin : (0 ext : List Name) -> Check f g -> Check (ext ++ f) g
  Visibility: export
thin : (0 ext : List Name) -> Infer f g -> Infer (ext ++ f) g
  Visibility: export
closed : (0 g : SnocList Name) -> Infer f [<] -> Infer f g
  Visibility: export
thin : (0 ext : List Name) -> Value f -> Value (ext ++ f)
  Visibility: export

\ No newline at end of file
diff --git a/papers/docs/Language.IntrinsicScoping.Variables.html b/papers/docs/Language.IntrinsicScoping.Variables.html
index e9e741ddc2..3e7c9c5b7e 100644
--- a/papers/docs/Language.IntrinsicScoping.Variables.html
+++ b/papers/docs/Language.IntrinsicScoping.Variables.html
@@ -61,4 +61,4 @@
 
 
 
-
Language.IntrinsicScoping.Variables(source)
Definitions
Name : Type
  We do not really care about the notion of names used here
  as long as it has a decidable notion of equality.
  String will do for now

  Totality: total
  Visibility: export
IContext : Type
  A context of De Bruijn indices is right-to-left.
  Just like in typing rules, newly bound variables are added
  at the most local end with index 0, and all other variables
  see their index shifted by 1.

  Totality: total
  Visibility: public export
data AtIndex : Nat -> Name -> IContext -> Type
  De Bruijn indices are right-to-left, starting from 0

  Totality: total
  Visibility: public export
  Constructors:
  
Z : AtIndex 0 nm (g :< nm)
  
S : AtIndex n nm g -> AtIndex (S n) nm (g :< {_:9257})
record Index : Name -> IContext -> Type
  An index is the pairing of its encoding as a natural number
  and the proof it is valid

  Totality: total
  Visibility: public export
  Constructor: 
MkIndex : (getIndex : Nat) -> (0 _ : AtIndex getIndex nm ctx) -> Index nm ctx

  Projections:
  
.getIndex : Index nm ctx -> Nat
  
0 .validIndex : ({rec:0} : Index nm ctx) -> AtIndex (getIndex {rec:0}) nm ctx

  Hint: 
Injective weaken
.getIndex : Index nm ctx -> Nat
  Totality: total
  Visibility: public export
getIndex : Index nm ctx -> Nat
  Totality: total
  Visibility: public export
0 .validIndex : ({rec:0} : Index nm ctx) -> AtIndex (getIndex {rec:0}) nm ctx
  Totality: total
  Visibility: public export
0 validIndex : ({rec:0} : Index nm ctx) -> AtIndex (getIndex {rec:0}) nm ctx
  Totality: total
  Visibility: public export
fresh : Index nm (ctx :< nm)
  Totality: total
  Visibility: public export
weaken : Index nm ctx -> Index nm (ctx :< {_:9376})
  Totality: total
  Visibility: public export
data View : Index nm ctx -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Z : View fresh
  
S : (p : Index nm ctx) -> View (weaken p)
view : (p : Index nm ctx) -> View p
  Totality: total
  Visibility: public export
isLast : Index nm ([<x] <+> g) -> Either (nm = x) (Index nm g)
  Totality: total
  Visibility: export
delete : Index nm g -> IContext
  Totality: total
  Visibility: public export
thicken : (v : Index nm g) -> (v' : Index nm' g) -> Either (nm = nm', v = v') (Index nm' (delete v))
  Totality: total
  Visibility: export
irrelevantAtIndex : (p : AtIndex n nm g) -> (q : AtIndex n nm' g) -> (nm = nm', p = q)
  Totality: total
  Visibility: export
hetEqDec : (v : Index nm g) -> (w : Index nm' g) -> Dec (nm = nm', v = w)
  Totality: total
  Visibility: export
LContext : Type
  A context of De Bruijn levels is left-to-right
  Newly bound variables are added at the far end, with index (length ctx).
  This has the advantage that all other variables have an unchanged level.

  Totality: total
  Visibility: public export
data AtLevel : Nat -> Name -> LContext -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
H : n = length ctx -> AtLevel n nm (nm :: ctx)
  
T : AtLevel n nm ctx -> AtLevel n nm ({_:10180} :: ctx)
record Level : Name -> LContext -> Type
  A level is the pairing of its encoding as a natural number
  and the proof it is valid

  Totality: total
  Visibility: public export
  Constructor: 
MkLevel : (getLevel : Nat) -> (0 _ : AtLevel getLevel nm ctx) -> Level nm ctx

  Projections:
  
.getLevel : Level nm ctx -> Nat
  
0 .validIndex : ({rec:0} : Level nm ctx) -> AtLevel (getLevel {rec:0}) nm ctx
.getLevel : Level nm ctx -> Nat
  Totality: total
  Visibility: public export
getLevel : Level nm ctx -> Nat
  Totality: total
  Visibility: public export
0 .validIndex : ({rec:0} : Level nm ctx) -> AtLevel (getLevel {rec:0}) nm ctx
  Totality: total
  Visibility: public export
0 validIndex : ({rec:0} : Level nm ctx) -> AtLevel (getLevel {rec:0}) nm ctx
  Totality: total
  Visibility: public export
weaken : Level nm ctx -> Level nm ({_:10329} :: ctx)
  Totality: total
  Visibility: export
fresh : Level nm (nm :: ctx)
  Totality: total
  Visibility: export
data View : Level nm ctx -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Z : View fresh
  
S : (p : Level nm ctx) -> View (weaken p)
view : (p : Level nm ctx) -> View p
  Totality: total
  Visibility: public export
irrelevantAtLevel : (p : AtLevel n nm ctx) -> (q : AtLevel n nm' ctx) -> (nm = nm', p = q)
  Totality: total
  Visibility: export
hetEqDec : (v : Level nm g) -> (w : Level nm' g) -> Dec (nm = nm', v = w)
  Totality: total
  Visibility: export
rev : List a -> SnocList a
  Totality: total
  Visibility: public export
lteIsPlus : LTE m n -> Plus (minus n m) m n
  Totality: total
  Visibility: export
asIndex : AtLevel n nm ls -> AtIndex (minus (length ls) (S n)) nm (rev ls)
  Totality: total
  Visibility: export
asIndex : Level nm ls -> Index nm (rev ls)
  Totality: total
  Visibility: export

\ No newline at end of file
+
Language.IntrinsicScoping.Variables(source)
Definitions
Name : Type
  We do not really care about the notion of names used here
  as long as it has a decidable notion of equality.
  String will do for now

  Totality: total
  Visibility: export
IContext : Type
  A context of De Bruijn indices is right-to-left.
  Just like in typing rules, newly bound variables are added
  at the most local end with index 0, and all other variables
  see their index shifted by 1.

  Totality: total
  Visibility: public export
data AtIndex : Nat -> Name -> IContext -> Type
  De Bruijn indices are right-to-left, starting from 0

  Totality: total
  Visibility: public export
  Constructors:
  
Z : AtIndex 0 nm (g :< nm)
  
S : AtIndex n nm g -> AtIndex (S n) nm (g :< {_:9257})
record Index : Name -> IContext -> Type
  An index is the pairing of its encoding as a natural number
  and the proof it is valid

  Totality: total
  Visibility: public export
  Constructor: 
MkIndex : (getIndex : Nat) -> (0 _ : AtIndex getIndex nm ctx) -> Index nm ctx

  Projections:
  
.getIndex : Index nm ctx -> Nat
  
0 .validIndex : ({rec:0} : Index nm ctx) -> AtIndex (getIndex {rec:0}) nm ctx

  Hint: 
Injective weaken
.getIndex : Index nm ctx -> Nat
  Totality: total
  Visibility: public export
getIndex : Index nm ctx -> Nat
  Totality: total
  Visibility: public export
0 .validIndex : ({rec:0} : Index nm ctx) -> AtIndex (getIndex {rec:0}) nm ctx
  Totality: total
  Visibility: public export
0 validIndex : ({rec:0} : Index nm ctx) -> AtIndex (getIndex {rec:0}) nm ctx
  Totality: total
  Visibility: public export
fresh : Index nm (ctx :< nm)
  Totality: total
  Visibility: public export
weaken : Index nm ctx -> Index nm (ctx :< {_:9376})
  Totality: total
  Visibility: public export
data View : Index nm ctx -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Z : View fresh
  
S : (p : Index nm ctx) -> View (weaken p)
view : (p : Index nm ctx) -> View p
  Totality: total
  Visibility: public export
isLast : Index nm ([<x] <+> g) -> Either (nm = x) (Index nm g)
  Totality: total
  Visibility: export
delete : Index nm g -> IContext
  Totality: total
  Visibility: public export
thicken : (v : Index nm g) -> (v' : Index nm' g) -> Either (nm = nm', v = v') (Index nm' (delete v))
  Totality: total
  Visibility: export
irrelevantAtIndex : (p : AtIndex n nm g) -> (q : AtIndex n nm' g) -> (nm = nm', p = q)
  Totality: total
  Visibility: export
hetEqDec : (v : Index nm g) -> (w : Index nm' g) -> Dec (nm = nm', v = w)
  Totality: total
  Visibility: export
LContext : Type
  A context of De Bruijn levels is left-to-right
  Newly bound variables are added at the far end, with index (length ctx).
  This has the advantage that all other variables have an unchanged level.

  Totality: total
  Visibility: public export
data AtLevel : Nat -> Name -> LContext -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
H : n = length ctx -> AtLevel n nm (nm :: ctx)
  
T : AtLevel n nm ctx -> AtLevel n nm ({_:10180} :: ctx)
record Level : Name -> LContext -> Type
  A level is the pairing of its encoding as a natural number
  and the proof it is valid

  Totality: total
  Visibility: public export
  Constructor: 
MkLevel : (getLevel : Nat) -> (0 _ : AtLevel getLevel nm ctx) -> Level nm ctx

  Projections:
  
.getLevel : Level nm ctx -> Nat
  
0 .validIndex : ({rec:0} : Level nm ctx) -> AtLevel (getLevel {rec:0}) nm ctx
.getLevel : Level nm ctx -> Nat
  Totality: total
  Visibility: public export
getLevel : Level nm ctx -> Nat
  Totality: total
  Visibility: public export
0 .validIndex : ({rec:0} : Level nm ctx) -> AtLevel (getLevel {rec:0}) nm ctx
  Totality: total
  Visibility: public export
0 validIndex : ({rec:0} : Level nm ctx) -> AtLevel (getLevel {rec:0}) nm ctx
  Totality: total
  Visibility: public export
weaken : Level nm ctx -> Level nm ({_:10329} :: ctx)
  Totality: total
  Visibility: export
fresh : Level nm (nm :: ctx)
  Totality: total
  Visibility: export
data View : Level nm ctx -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Z : View fresh
  
S : (p : Level nm ctx) -> View (weaken p)
view : (p : Level nm ctx) -> View p
  Totality: total
  Visibility: public export
irrelevantAtLevel : (p : AtLevel n nm ctx) -> (q : AtLevel n nm' ctx) -> (nm = nm', p = q)
  Totality: total
  Visibility: export
hetEqDec : (v : Level nm g) -> (w : Level nm' g) -> Dec (nm = nm', v = w)
  Totality: total
  Visibility: export
rev : List a -> SnocList a
  Totality: total
  Visibility: public export
lteIsPlus : LTE m n -> Plus (minus n m) m n
  Totality: total
  Visibility: export
asIndex : AtLevel n nm ls -> AtIndex (minus (length ls) (S n)) nm (rev ls)
  Totality: total
  Visibility: export
asIndex : Level nm ls -> Index nm (rev ls)
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/papers/docs/Language.IntrinsicTyping.ABT.html b/papers/docs/Language.IntrinsicTyping.ABT.html
index 98af4719b8..0ec4957a9d 100644
--- a/papers/docs/Language.IntrinsicTyping.ABT.html
+++ b/papers/docs/Language.IntrinsicTyping.ABT.html
@@ -63,4 +63,4 @@
 
 
Language.IntrinsicTyping.ABT(source)
Abstract binding trees are a generic representation of terms over
 a given signature
-
Definitions
record Argument : Type
  A constructor's argument describes the kind of the variables that
  will be bound in the subterm as well as the overall type of the
  argument.
    The argument `n` in `S n`   is described by `MkArgument [] Nat`
    The argument `b` in `\x. b` is described by `MkArgument [s] t`

  Totality: total
  Visibility: public export
  Constructor: 
MkArgument : List kind -> kind -> Argument

  Projections:
  
.argType : Argument -> kind
  
.binders : Argument -> List kind
.binders : Argument -> List kind
  Totality: total
  Visibility: public export
binders : Argument -> List kind
  Totality: total
  Visibility: public export
.argType : Argument -> kind
  Totality: total
  Visibility: public export
argType : Argument -> kind
  Totality: total
  Visibility: public export
0 Signature : Type
  A signature is a relation describing constructors.
  Each constructor has a list of arguments and a return type.

  Totality: total
  Visibility: public export
data Term : Signature -> SnocList kind -> kind -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Var : Elem s ctx -> Term sig ctx s
  Variables are represented using typed De Bruijn indices.
  
Con : sig args s -> Args sig ctx args -> Term sig ctx s
  Constructors are provided by the signature
data Args : Signature -> SnocList kind -> List Argument -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Args sig ctx []
  Empty list
  
(::) : Term sig (ctx <>< bds) s -> Args sig ctx args -> Args sig ctx (MkArgument bds s :: args)
  An argument with binders `bds` and return type `s` is provided by a term
  whose scope has been extended by `bds` and whose return type is `s`.
lift : (Elem s ctx -> Elem s ctx') -> Elem s (ctx :< t) -> Elem s (ctx' :< t)
  Totality: total
  Visibility: public export
lifts : (bds : List kind) -> (Elem s ctx -> Elem s ctx') -> Elem s (ctx <>< bds) -> Elem s (ctx' <>< bds)
  Totality: total
  Visibility: public export
rename : (Elem s ctx -> Elem s ctx') -> Term sig ctx s -> Term sig ctx' s
  Totality: total
  Visibility: public export
renames : (Elem s ctx -> Elem s ctx') -> Args sig ctx args -> Args sig ctx' args
  Totality: total
  Visibility: public export
extend : (Elem s ctx -> Term sig ctx' s) -> Elem s (ctx :< t) -> Term sig (ctx' :< t) s
  Totality: total
  Visibility: public export
extends : (bds : List kind) -> (Elem s ctx -> Term sig ctx' s) -> Elem s (ctx <>< bds) -> Term sig (ctx' <>< bds) s
  Totality: total
  Visibility: public export
substitute : (Elem s ctx -> Term sig ctx' s) -> Term sig ctx s -> Term sig ctx' s
  Totality: total
  Visibility: public export
substitutes : (Elem s ctx -> Term sig ctx' s) -> Args sig ctx args -> Args sig ctx' args
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
record Argument : Type
  A constructor's argument describes the kind of the variables that
  will be bound in the subterm as well as the overall type of the
  argument.
    The argument `n` in `S n`   is described by `MkArgument [] Nat`
    The argument `b` in `\x. b` is described by `MkArgument [s] t`

  Totality: total
  Visibility: public export
  Constructor: 
MkArgument : List kind -> kind -> Argument

  Projections:
  
.argType : Argument -> kind
  
.binders : Argument -> List kind
.binders : Argument -> List kind
  Totality: total
  Visibility: public export
binders : Argument -> List kind
  Totality: total
  Visibility: public export
.argType : Argument -> kind
  Totality: total
  Visibility: public export
argType : Argument -> kind
  Totality: total
  Visibility: public export
0 Signature : Type
  A signature is a relation describing constructors.
  Each constructor has a list of arguments and a return type.

  Totality: total
  Visibility: public export
data Term : Signature -> SnocList kind -> kind -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Var : Elem s ctx -> Term sig ctx s
  Variables are represented using typed De Bruijn indices.
  
Con : sig args s -> Args sig ctx args -> Term sig ctx s
  Constructors are provided by the signature
data Args : Signature -> SnocList kind -> List Argument -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Args sig ctx []
  Empty list
  
(::) : Term sig (ctx <>< bds) s -> Args sig ctx args -> Args sig ctx (MkArgument bds s :: args)
  An argument with binders `bds` and return type `s` is provided by a term
  whose scope has been extended by `bds` and whose return type is `s`.
lift : (Elem s ctx -> Elem s ctx') -> Elem s (ctx :< t) -> Elem s (ctx' :< t)
  Totality: total
  Visibility: public export
lifts : (bds : List kind) -> (Elem s ctx -> Elem s ctx') -> Elem s (ctx <>< bds) -> Elem s (ctx' <>< bds)
  Totality: total
  Visibility: public export
rename : (Elem s ctx -> Elem s ctx') -> Term sig ctx s -> Term sig ctx' s
  Totality: total
  Visibility: public export
renames : (Elem s ctx -> Elem s ctx') -> Args sig ctx args -> Args sig ctx' args
  Totality: total
  Visibility: public export
extend : (Elem s ctx -> Term sig ctx' s) -> Elem s (ctx :< t) -> Term sig (ctx' :< t) s
  Totality: total
  Visibility: public export
extends : (bds : List kind) -> (Elem s ctx -> Term sig ctx' s) -> Elem s (ctx <>< bds) -> Term sig (ctx' <>< bds) s
  Totality: total
  Visibility: public export
substitute : (Elem s ctx -> Term sig ctx' s) -> Term sig ctx s -> Term sig ctx' s
  Totality: total
  Visibility: public export
substitutes : (Elem s ctx -> Term sig ctx' s) -> Args sig ctx args -> Args sig ctx' args
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Language.IntrinsicTyping.Krivine.html b/papers/docs/Language.IntrinsicTyping.Krivine.html
index f8aa134ef9..5ee7204a1d 100644
--- a/papers/docs/Language.IntrinsicTyping.Krivine.html
+++ b/papers/docs/Language.IntrinsicTyping.Krivine.html
@@ -65,4 +65,4 @@
 From Mathematics to Abstract Machine
 A formal derivation of an executable Krivine machine
 by Wouter Swierstra
-
Definitions
data Ty : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Base : Ty
  
Arr : Ty -> Ty -> Ty
Context : Type
  Totality: total
  Visibility: public export
data Term : Context -> Ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Lam : Term (a :: g) b -> Term g (Arr a b)
  
App : Term g (Arr a b) -> Term g a -> Term g b
  
Var : Elem a g -> Term g a
data Closed : Ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Closure : Term g a -> Env g -> Closed a
  
ClApp : Closed (Arr a b) -> Closed a -> Closed b
data Env : Context -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Env []
  
(::) : Closed a -> Env g -> Env (a :: g)
data IsValue : Closed g -> Type
  Totality: total
  Visibility: public export
  Constructor: 
Lam : IsValue (Closure (Lam b) env)
data Value : Ty -> Type
  Totality: total
  Visibility: public export
  Constructor: 
Val : (c : Closed a) -> IsValue c -> Value a
data Redex : Ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
RVar : Elem a g -> Env g -> Redex a
  
RApp : Term g (Arr a b) -> Term g a -> Env g -> Redex b
  
Beta : Term (a :: g) b -> Env g -> Closed a -> Redex b
redex : Redex a -> Closed a
  Totality: total
  Visibility: public export
lookup : Env g -> Elem a g -> Closed a
  Totality: total
  Visibility: public export
contract : Redex a -> Closed a
  Totality: total
  Visibility: public export
data EvalContext : Ty -> Ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : EvalContext inner inner
  
(::) : Closed a -> EvalContext inner outer -> EvalContext (Arr a inner) outer
snoc : EvalContext inner (Arr dom outer) -> Closed dom -> EvalContext inner outer
  Totality: total
  Visibility: public export
data SnocView : EvalContext inner outer -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Lin : SnocView []
  
(:<) : (ctx : EvalContext inner (Arr dom outer)) -> (t : Closed dom) -> SnocView (snoc ctx t)
snocView : (ctx : EvalContext inner outer) -> SnocView ctx
  Totality: total
  Visibility: public export
plug : EvalContext a b -> Closed a -> Closed b
  Totality: total
  Visibility: public export
0 plugSnoc : (ctx : EvalContext a (Arr dom b)) -> (t : Closed dom) -> (f : Closed a) -> plug (snoc ctx t) f = ClApp (plug ctx f) t
  Totality: total
  Visibility: public export
data Decomposition : Closed a -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Val : (sc : Term (a :: g) b) -> (env : Env g) -> Decomposition (Closure (Lam sc) env)
  
Red : (r : Redex s) -> (ctx : EvalContext s t) -> Decomposition (plug ctx (redex r))
load : (ctx : EvalContext a b) -> (c : Closed a) -> Decomposition (plug ctx c)
  Totality: total
  Visibility: public export
unload : (ctx : EvalContext (Arr a b) outer) -> (sc : Term (a :: g) b) -> (env : Env g) -> Decomposition (plug ctx (Closure (Lam sc) env))
  Totality: total
  Visibility: public export
decompose : (c : Closed a) -> Decomposition c
  Totality: total
  Visibility: public export
decomposePlug : (ctx : EvalContext a b) -> (c : Closed a) -> decompose (plug ctx c) = load ctx c
  Totality: total
  Visibility: public export
recompose : Decomposition c -> Closed a
  Totality: total
  Visibility: public export
headReduce : Closed a -> Closed a
  Totality: total
  Visibility: public export
loadRedex : (ctx : EvalContext a b) -> (r : Redex a) -> load ctx (redex r) = Red r ctx
  Totality: total
  Visibility: public export
headReducePlug : (ctx : EvalContext a b) -> (r : Redex a) -> headReduce (plug ctx (redex r)) = plug ctx (contract r)
  Totality: total
  Visibility: public export
headReduceClApp : (f : Closed (Arr a b)) -> Not (IsValue f) -> (t : Closed a) -> headReduce (ClApp f t) = ClApp (headReduce f) t
  Totality: total
  Visibility: public export
data Trace : Decomposition c -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Done : (sc : Term ({a:5010} :: {g:5009}) {b:5008}) -> (env : Env {g:5009}) -> Trace (Val sc env)
  
Step : (ctx : EvalContext a b) -> (r : Redex a) -> Trace (decompose (plug ctx (contract r))) -> Trace (Red r ctx)
iterate : (0 _ : Trace d) -> Value a
  Totality: total
  Visibility: public export
Reducible : (a : Ty) -> Closed a -> Type
  Totality: total
  Visibility: public export
data ReducibleEnv : Env g -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : ReducibleEnv []
  
(::) : Reducible a t -> ReducibleEnv env -> ReducibleEnv (t :: env)
lookup : ReducibleEnv env -> (v : Elem a g) -> Reducible a (lookup env v)
  Totality: total
  Visibility: public export
step : Trace (decompose (headReduce c)) -> Trace (decompose c)
  Totality: total
  Visibility: public export
expand : Reducible a (headReduce c) -> Reducible a c
  Totality: total
  Visibility: public export
closure : (t : Term g a) -> ReducibleEnv env -> Reducible a (Closure t env)
  Totality: total
  Visibility: public export
theorem : (c : Closed a) -> Reducible a c
  Totality: total
  Visibility: public export
theoremEnv : (env : Env g) -> ReducibleEnv env
  Totality: total
  Visibility: public export
termination : (c : Closed a) -> Trace (decompose c)
  Totality: total
  Visibility: public export
evaluate : Closed a -> Value a
  Totality: total
  Visibility: public export
refocus : (ctx : EvalContext a b) -> (c : Closed a) -> Decomposition (plug ctx c)
  Totality: total
  Visibility: public export
refocusCorrect : (ctx : EvalContext a b) -> (c : Closed a) -> refocus ctx c = decompose (plug ctx c)
  Totality: total
  Visibility: public export
data Trace : Decomposition c -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Done : (0 sc : Term ({a:6022} :: {g:6021}) {b:6020}) -> (0 env : Env {g:6021}) -> Trace (Val sc env)
  
Step : (0 ctx : EvalContext a b) -> (0 r : Redex a) -> Trace (refocus ctx (contract r)) -> Trace (Red r ctx)
trace : Trace d -> (0 _ : e = d) -> Trace e
  Totality: total
  Visibility: public export
termination : (c : Closed a) -> Trace (decompose c)
  Totality: total
  Visibility: public export
iterate : (0 _ : Trace d) -> Value a
  Totality: total
  Visibility: public export
evaluate : Closed a -> Value a
  Totality: total
  Visibility: public export
IsValidEnv : Env g -> Type
  Totality: total
  Visibility: public export
IsValidClosed : Closed a -> Type
  Totality: total
  Visibility: public export
ValidEnv : Context -> Type
  Totality: total
  Visibility: public export
ValidClosed : Ty -> Type
  Totality: total
  Visibility: public export
Closure : Term g a -> ValidEnv g -> ValidClosed a
  Totality: total
  Visibility: public export
fstClosure : (t : Term g a) -> (env : ValidEnv g) -> fst (Closure t env) = Closure t (fst env)
  Totality: total
  Visibility: public export
0 getContext : ValidClosed a -> Context
  Totality: total
  Visibility: public export
getEnv : (c : ValidClosed a) -> ValidEnv (getContext c)
  Totality: total
  Visibility: public export
getTerm : (c : ValidClosed a) -> Term (getContext c) a
  Totality: total
  Visibility: public export
etaValidClosed : (c : ValidClosed a) -> c = Closure (getTerm c) (getEnv c)
  Totality: total
  Visibility: public export
lookup : ValidEnv g -> Elem a g -> ValidClosed a
  Totality: total
  Visibility: public export
fstLookup : (env : ValidEnv g) -> (v : Elem a g) -> fst (lookup env v) = lookup (fst env) v
  Totality: total
  Visibility: public export
Nil : ValidEnv []
  Totality: total
  Visibility: public export
(::) : ValidClosed a -> ValidEnv g -> ValidEnv (a :: g)
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
IsValidEvalContext : EvalContext a b -> Type
  Totality: total
  Visibility: public export
ValidEvalContext : Ty -> Ty -> Type
  Totality: total
  Visibility: public export
Nil : ValidEvalContext a a
  Totality: total
  Visibility: public export
(::) : ValidClosed a -> ValidEvalContext b c -> ValidEvalContext (Arr a b) c
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
fstCons : (t : ValidClosed a) -> (ctx : ValidEvalContext b c) -> fst (t :: ctx) = fst t :: fst ctx
  Totality: total
  Visibility: public export
data View : ValidEvalContext a b -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : View []
  
(::) : (t : ValidClosed a) -> (ctx : ValidEvalContext b c) -> View (t :: ctx)
irrelevantUnit : (t : ()) -> t = ()
  Totality: total
  Visibility: public export
etaPair : (p : (a, b)) -> p = (fst p, snd p)
  Totality: total
  Visibility: public export
view : (ctx : ValidEvalContext a b) -> View ctx
  Totality: total
  Visibility: public export
data Trace : Term g a -> ValidEnv g -> ValidEvalContext a b -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Var : Trace (getTerm (lookup env v)) (getEnv (lookup env v)) ctx -> Trace (Var v) env ctx
  
App : Trace f env (Closure t env :: ctx) -> Trace (f `App` t) env ctx
  
Beta : Trace sc (arg :: env) ctx -> Trace (Lam sc) env (arg :: ctx)
  
Done : Trace (Lam sc) env []
vvar : (tr : Trace (Var v) env ctx) -> (tr' : Trace (getTerm (lookup env v)) (getEnv (lookup env v)) ctx ** tr = Var tr')
  Totality: total
  Visibility: public export
vapp : (tr : Trace (f `App` t) env ctx) -> (tr' : Trace f env (Closure t env :: ctx) ** tr = (tr' `App`))
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 5
vlam0 : ctx = [] -> (tr : Trace (Lam sc) env ctx) -> tr = Done
  Totality: total
  Visibility: public export
vlamS : ctx = arg :: ctx' -> (tr : Trace (Lam sc) env ctx) -> (tr' : Trace sc (arg :: env) ctx' ** tr = Beta tr')
  Totality: total
  Visibility: public export
view : (t : Term g a) -> (env : ValidEnv g) -> (ctx : ValidEvalContext a b) -> (0 tr : Trace t env ctx) -> View tr
  Totality: total
  Visibility: public export
refocus : (0 _ : Trace t env ctx) -> Value b
  Totality: total
  Visibility: public export
correctness : (ctx : ValidEvalContext a b) -> (t : Term g a) -> (env : ValidEnv g) -> (trold : Trace (refocus (fst ctx) (Closure t (fst env)))) -> (trnew : Trace t env ctx) -> refocus trnew = iterate trold
  Totality: total
  Visibility: public export
trace : (ctx : ValidEvalContext a b) -> (t : Term g a) -> (env : ValidEnv g) -> Trace (refocus (fst ctx) (Closure t (fst env))) -> Trace t env ctx
  Totality: total
  Visibility: public export
termination : (t : Term [] a) -> Trace t [] []
  Totality: total
  Visibility: public export
evaluate : Term [] a -> Value a
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
data Ty : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Base : Ty
  
Arr : Ty -> Ty -> Ty
Context : Type
  Totality: total
  Visibility: public export
data Term : Context -> Ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Lam : Term (a :: g) b -> Term g (Arr a b)
  
App : Term g (Arr a b) -> Term g a -> Term g b
  
Var : Elem a g -> Term g a
data Closed : Ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Closure : Term g a -> Env g -> Closed a
  
ClApp : Closed (Arr a b) -> Closed a -> Closed b
data Env : Context -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Env []
  
(::) : Closed a -> Env g -> Env (a :: g)
data IsValue : Closed g -> Type
  Totality: total
  Visibility: public export
  Constructor: 
Lam : IsValue (Closure (Lam b) env)
data Value : Ty -> Type
  Totality: total
  Visibility: public export
  Constructor: 
Val : (c : Closed a) -> IsValue c -> Value a
data Redex : Ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
RVar : Elem a g -> Env g -> Redex a
  
RApp : Term g (Arr a b) -> Term g a -> Env g -> Redex b
  
Beta : Term (a :: g) b -> Env g -> Closed a -> Redex b
redex : Redex a -> Closed a
  Totality: total
  Visibility: public export
lookup : Env g -> Elem a g -> Closed a
  Totality: total
  Visibility: public export
contract : Redex a -> Closed a
  Totality: total
  Visibility: public export
data EvalContext : Ty -> Ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : EvalContext inner inner
  
(::) : Closed a -> EvalContext inner outer -> EvalContext (Arr a inner) outer
snoc : EvalContext inner (Arr dom outer) -> Closed dom -> EvalContext inner outer
  Totality: total
  Visibility: public export
data SnocView : EvalContext inner outer -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Lin : SnocView []
  
(:<) : (ctx : EvalContext inner (Arr dom outer)) -> (t : Closed dom) -> SnocView (snoc ctx t)
snocView : (ctx : EvalContext inner outer) -> SnocView ctx
  Totality: total
  Visibility: public export
plug : EvalContext a b -> Closed a -> Closed b
  Totality: total
  Visibility: public export
0 plugSnoc : (ctx : EvalContext a (Arr dom b)) -> (t : Closed dom) -> (f : Closed a) -> plug (snoc ctx t) f = ClApp (plug ctx f) t
  Totality: total
  Visibility: public export
data Decomposition : Closed a -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Val : (sc : Term (a :: g) b) -> (env : Env g) -> Decomposition (Closure (Lam sc) env)
  
Red : (r : Redex s) -> (ctx : EvalContext s t) -> Decomposition (plug ctx (redex r))
load : (ctx : EvalContext a b) -> (c : Closed a) -> Decomposition (plug ctx c)
  Totality: total
  Visibility: public export
unload : (ctx : EvalContext (Arr a b) outer) -> (sc : Term (a :: g) b) -> (env : Env g) -> Decomposition (plug ctx (Closure (Lam sc) env))
  Totality: total
  Visibility: public export
decompose : (c : Closed a) -> Decomposition c
  Totality: total
  Visibility: public export
decomposePlug : (ctx : EvalContext a b) -> (c : Closed a) -> decompose (plug ctx c) = load ctx c
  Totality: total
  Visibility: public export
recompose : Decomposition c -> Closed a
  Totality: total
  Visibility: public export
headReduce : Closed a -> Closed a
  Totality: total
  Visibility: public export
loadRedex : (ctx : EvalContext a b) -> (r : Redex a) -> load ctx (redex r) = Red r ctx
  Totality: total
  Visibility: public export
headReducePlug : (ctx : EvalContext a b) -> (r : Redex a) -> headReduce (plug ctx (redex r)) = plug ctx (contract r)
  Totality: total
  Visibility: public export
headReduceClApp : (f : Closed (Arr a b)) -> Not (IsValue f) -> (t : Closed a) -> headReduce (ClApp f t) = ClApp (headReduce f) t
  Totality: total
  Visibility: public export
data Trace : Decomposition c -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Done : (sc : Term ({a:5010} :: {g:5009}) {b:5008}) -> (env : Env {g:5009}) -> Trace (Val sc env)
  
Step : (ctx : EvalContext a b) -> (r : Redex a) -> Trace (decompose (plug ctx (contract r))) -> Trace (Red r ctx)
iterate : (0 _ : Trace d) -> Value a
  Totality: total
  Visibility: public export
Reducible : (a : Ty) -> Closed a -> Type
  Totality: total
  Visibility: public export
data ReducibleEnv : Env g -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : ReducibleEnv []
  
(::) : Reducible a t -> ReducibleEnv env -> ReducibleEnv (t :: env)
lookup : ReducibleEnv env -> (v : Elem a g) -> Reducible a (lookup env v)
  Totality: total
  Visibility: public export
step : Trace (decompose (headReduce c)) -> Trace (decompose c)
  Totality: total
  Visibility: public export
expand : Reducible a (headReduce c) -> Reducible a c
  Totality: total
  Visibility: public export
closure : (t : Term g a) -> ReducibleEnv env -> Reducible a (Closure t env)
  Totality: total
  Visibility: public export
theorem : (c : Closed a) -> Reducible a c
  Totality: total
  Visibility: public export
theoremEnv : (env : Env g) -> ReducibleEnv env
  Totality: total
  Visibility: public export
termination : (c : Closed a) -> Trace (decompose c)
  Totality: total
  Visibility: public export
evaluate : Closed a -> Value a
  Totality: total
  Visibility: public export
refocus : (ctx : EvalContext a b) -> (c : Closed a) -> Decomposition (plug ctx c)
  Totality: total
  Visibility: public export
refocusCorrect : (ctx : EvalContext a b) -> (c : Closed a) -> refocus ctx c = decompose (plug ctx c)
  Totality: total
  Visibility: public export
data Trace : Decomposition c -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Done : (0 sc : Term ({a:6022} :: {g:6021}) {b:6020}) -> (0 env : Env {g:6021}) -> Trace (Val sc env)
  
Step : (0 ctx : EvalContext a b) -> (0 r : Redex a) -> Trace (refocus ctx (contract r)) -> Trace (Red r ctx)
trace : Trace d -> (0 _ : e = d) -> Trace e
  Totality: total
  Visibility: public export
termination : (c : Closed a) -> Trace (decompose c)
  Totality: total
  Visibility: public export
iterate : (0 _ : Trace d) -> Value a
  Totality: total
  Visibility: public export
evaluate : Closed a -> Value a
  Totality: total
  Visibility: public export
IsValidEnv : Env g -> Type
  Totality: total
  Visibility: public export
IsValidClosed : Closed a -> Type
  Totality: total
  Visibility: public export
ValidEnv : Context -> Type
  Totality: total
  Visibility: public export
ValidClosed : Ty -> Type
  Totality: total
  Visibility: public export
Closure : Term g a -> ValidEnv g -> ValidClosed a
  Totality: total
  Visibility: public export
fstClosure : (t : Term g a) -> (env : ValidEnv g) -> fst (Closure t env) = Closure t (fst env)
  Totality: total
  Visibility: public export
0 getContext : ValidClosed a -> Context
  Totality: total
  Visibility: public export
getEnv : (c : ValidClosed a) -> ValidEnv (getContext c)
  Totality: total
  Visibility: public export
getTerm : (c : ValidClosed a) -> Term (getContext c) a
  Totality: total
  Visibility: public export
etaValidClosed : (c : ValidClosed a) -> c = Closure (getTerm c) (getEnv c)
  Totality: total
  Visibility: public export
lookup : ValidEnv g -> Elem a g -> ValidClosed a
  Totality: total
  Visibility: public export
fstLookup : (env : ValidEnv g) -> (v : Elem a g) -> fst (lookup env v) = lookup (fst env) v
  Totality: total
  Visibility: public export
Nil : ValidEnv []
  Totality: total
  Visibility: public export
(::) : ValidClosed a -> ValidEnv g -> ValidEnv (a :: g)
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
IsValidEvalContext : EvalContext a b -> Type
  Totality: total
  Visibility: public export
ValidEvalContext : Ty -> Ty -> Type
  Totality: total
  Visibility: public export
Nil : ValidEvalContext a a
  Totality: total
  Visibility: public export
(::) : ValidClosed a -> ValidEvalContext b c -> ValidEvalContext (Arr a b) c
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
fstCons : (t : ValidClosed a) -> (ctx : ValidEvalContext b c) -> fst (t :: ctx) = fst t :: fst ctx
  Totality: total
  Visibility: public export
data View : ValidEvalContext a b -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : View []
  
(::) : (t : ValidClosed a) -> (ctx : ValidEvalContext b c) -> View (t :: ctx)
irrelevantUnit : (t : ()) -> t = ()
  Totality: total
  Visibility: public export
etaPair : (p : (a, b)) -> p = (fst p, snd p)
  Totality: total
  Visibility: public export
view : (ctx : ValidEvalContext a b) -> View ctx
  Totality: total
  Visibility: public export
data Trace : Term g a -> ValidEnv g -> ValidEvalContext a b -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Var : Trace (getTerm (lookup env v)) (getEnv (lookup env v)) ctx -> Trace (Var v) env ctx
  
App : Trace f env (Closure t env :: ctx) -> Trace (f `App` t) env ctx
  
Beta : Trace sc (arg :: env) ctx -> Trace (Lam sc) env (arg :: ctx)
  
Done : Trace (Lam sc) env []
vvar : (tr : Trace (Var v) env ctx) -> (tr' : Trace (getTerm (lookup env v)) (getEnv (lookup env v)) ctx ** tr = Var tr')
  Totality: total
  Visibility: public export
vapp : (tr : Trace (f `App` t) env ctx) -> (tr' : Trace f env (Closure t env :: ctx) ** tr = (tr' `App`))
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 5
vlam0 : ctx = [] -> (tr : Trace (Lam sc) env ctx) -> tr = Done
  Totality: total
  Visibility: public export
vlamS : ctx = arg :: ctx' -> (tr : Trace (Lam sc) env ctx) -> (tr' : Trace sc (arg :: env) ctx' ** tr = Beta tr')
  Totality: total
  Visibility: public export
view : (t : Term g a) -> (env : ValidEnv g) -> (ctx : ValidEvalContext a b) -> (0 tr : Trace t env ctx) -> View tr
  Totality: total
  Visibility: public export
refocus : (0 _ : Trace t env ctx) -> Value b
  Totality: total
  Visibility: public export
correctness : (ctx : ValidEvalContext a b) -> (t : Term g a) -> (env : ValidEnv g) -> (trold : Trace (refocus (fst ctx) (Closure t (fst env)))) -> (trnew : Trace t env ctx) -> refocus trnew = iterate trold
  Totality: total
  Visibility: public export
trace : (ctx : ValidEvalContext a b) -> (t : Term g a) -> (env : ValidEnv g) -> Trace (refocus (fst ctx) (Closure t (fst env))) -> Trace t env ctx
  Totality: total
  Visibility: public export
termination : (t : Term [] a) -> Trace t [] []
  Totality: total
  Visibility: public export
evaluate : Term [] a -> Value a
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Language.IntrinsicTyping.SECD.html b/papers/docs/Language.IntrinsicTyping.SECD.html
index ac30ff233c..178f32de4c 100644
--- a/papers/docs/Language.IntrinsicTyping.SECD.html
+++ b/papers/docs/Language.IntrinsicTyping.SECD.html
@@ -64,4 +64,4 @@
 
Language.IntrinsicTyping.SECD(source)
The content of this module is based on the MSc Thesis
 Coinductive Formalization of SECD Machine in Agda
 by Adam Krupička
-
Reexports
import public Data.Late
import public Data.List.Quantifiers
Definitions
data Ty : Type
  Totality: total
  Visibility: public export
  Constructors:
  
TyInt : Ty
  
TyBool : Ty
  
TyPair : Ty -> Ty -> Ty
  
TyList : Ty -> Ty
  
TyFun : Ty -> Ty -> Ty
data Const : Ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
AnInt : Int -> Const TyInt
  
True : Const TyBool
  
False : Const TyBool
fromInteger : Integer -> Const TyInt
  Totality: total
  Visibility: public export
Stack : Type
  Totality: total
  Visibility: public export
Env : Type
  Totality: total
  Visibility: public export
FunDump : Type
  Totality: total
  Visibility: public export
record State : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkState : Stack -> Env -> FunDump -> State

  Projections:
  
.dump : State -> FunDump
  
.env : State -> Env
  
.stack : State -> Stack
.stack : State -> Stack
  Totality: total
  Visibility: public export
stack : State -> Stack
  Totality: total
  Visibility: public export
.env : State -> Env
  Totality: total
  Visibility: public export
env : State -> Env
  Totality: total
  Visibility: public export
.dump : State -> FunDump
  Totality: total
  Visibility: public export
dump : State -> FunDump
  Totality: total
  Visibility: public export
data Step : State -> State -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
LDC : Const ty -> Step (MkState s e f) (MkState (ty :: s) e f)
  Load a constant of a base type
  
LDA : Elem ty e -> Step (MkState s e f) (MkState (ty :: s) e f)
  Load a value from an address in the environment
  
LDF : Steps (MkState [] (a :: e) ((a, b) :: f)) (MkState [b] (a :: e) ((a, b) :: f)) -> Step (MkState s e f) (MkState (TyFun a b :: s) e f)
  Load a recursive function
  
LDR : Elem (a, b) f -> Step (MkState s e f) (MkState (TyFun a b :: s) e f)
  Load a function for recursive application
  
APP : Step (MkState (a :: (TyFun a b :: s)) e f) (MkState (b :: s) e f)
  Apply a function to its argument
  
TAP : Step (MkState (a :: (TyFun a b :: s)) e f) (MkState (b :: s) e f)
  Apply a function to its argument, tail call
  
RTN : Step (MkState (b :: s) e ((a, b) :: f)) (MkState [b] e ((a, b) :: f))
  Return a value from inside a function
  
BCH : Steps (MkState s e f) (MkState s' e f) -> Steps (MkState s e f) (MkState s' e f) -> Step (MkState (TyBool :: s) e f) (MkState s' e f)
  Branch over a boolean
  
FLP : Step (MkState (a :: (b :: s)) e f) (MkState (b :: (a :: s)) e f)
  Flip the stack's top values
  
NIL : Step (MkState s e f) (MkState (TyList a :: s) e f)
  Nil constructor
  
CNS : Step (MkState (a :: (TyList a :: s)) e f) (MkState (TyList a :: s) e f)
  Cons constructor
  
HED : Step (MkState (TyList a :: s) e f) (MkState (a :: s) e f)
  Head destructor
  
TAL : Step (MkState (TyList a :: s) e f) (MkState (TyList a :: s) e f)
  Tail destructor
  
MKP : Step (MkState (a :: (b :: s)) e f) (MkState (TyPair a b :: s) e f)
  Pair constructor
  
FST : Step (MkState (TyPair a b :: s) e f) (MkState (a :: s) e f)
  First pair destructor
  
SND : Step (MkState (TyPair a b :: s) e f) (MkState (b :: s) e f)
  Second pair destructor
  
ADD : Step (MkState (TyInt :: (TyInt :: s)) e f) (MkState (TyInt :: s) e f)
  Addition of ints
  
SUB : Step (MkState (TyInt :: (TyInt :: s)) e f) (MkState (TyInt :: s) e f)
  Subtraction of ints
  
MUL : Step (MkState (TyInt :: (TyInt :: s)) e f) (MkState (TyInt :: s) e f)
  Multiplication of ints
  
EQB : Step (MkState (a :: (a :: s)) e f) (MkState (TyBool :: s) e f)
  Structural equality test
  
NOT : Step (MkState (TyBool :: s) e f) (MkState (TyBool :: s) e f)
  Boolean negation
data Steps : State -> State -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Steps s s
  
(::) : Step s t -> Steps t u -> Steps s u
data Stepz : State -> State -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Lin : Stepz s s
  
(:<) : Stepz s t -> Step t u -> Stepz s u
(<>>) : Stepz s t -> Steps t u -> Steps s u
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 6
(<><) : Stepz s t -> Steps t u -> Stepz s u
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 7
(++) : Steps s t -> Steps t u -> Steps s u
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
NUL : Steps (MkState (TyList a :: s) e f) (MkState (TyBool :: s) e f)
  Totality: total
  Visibility: public export
LDL : List Int -> Steps (MkState s e f) (MkState (TyList TyInt :: s) e f)
  Totality: total
  Visibility: public export
PLS : Step (MkState s e f) (MkState (TyFun TyInt (TyFun TyInt TyInt) :: s) e f)
  Totality: total
  Visibility: public export
MAP : Step (MkState [] e f) (MkState [TyFun (TyFun a b) (TyFun (TyList a) (TyList b))] e f)
  Totality: total
  Visibility: public export
FLD : Step (MkState [] e f) (MkState [TyFun (TyFun b (TyFun a b)) (TyFun b (TyFun (TyList a) b))] e f)
  Totality: total
  Visibility: public export
SUM : Steps (MkState [] e f) (MkState [TyFun (TyList TyInt) TyInt] e f)
  Totality: total
  Visibility: public export
Meaning : Ty -> Type
  Totality: total
  Visibility: public export
fromConst : Const ty -> Meaning ty
  Totality: total
  Visibility: public export
Meaning : List Ty -> Type
  Totality: total
  Visibility: public export
0 Meaning : FunDump -> Type
  Totality: total
  Visibility: public export
tail : Meaning (ab :: f) -> Meaning f
  Totality: total
  Visibility: public export
lookup : Meaning f -> Elem (a, b) f -> Closure a b
  Totality: total
  Visibility: public export
record Meaning : State -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkMeaning : Meaning (st .stack) -> Meaning (st .env) -> Meaning (st .dump) -> Meaning st

  Projections:
  
.dumpVal : Meaning st -> Meaning (st .dump)
  
.envVal : Meaning st -> Meaning (st .env)
  
.stackVal : Meaning st -> Meaning (st .stack)
.stackVal : Meaning st -> Meaning (st .stack)
  Totality: total
  Visibility: public export
stackVal : Meaning st -> Meaning (st .stack)
  Totality: total
  Visibility: public export
.envVal : Meaning st -> Meaning (st .env)
  Totality: total
  Visibility: public export
envVal : Meaning st -> Meaning (st .env)
  Totality: total
  Visibility: public export
.dumpVal : Meaning st -> Meaning (st .dump)
  Totality: total
  Visibility: public export
dumpVal : Meaning st -> Meaning (st .dump)
  Totality: total
  Visibility: public export
record Closure : Ty -> Ty -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkClosure : Steps (MkState [] (a :: localEnv) ((a, b) :: localFunDump)) (MkState [b] (a :: localEnv) ((a, b) :: localFunDump)) -> Meaning localEnv -> Meaning localFunDump -> Closure a b

  Projections:
  
.code : ({rec:0} : Closure a b) -> Steps (MkState [] (a :: localEnv {rec:0}) ((a, b) :: localFunDump {rec:0})) (MkState [b] (a :: localEnv {rec:0}) ((a, b) :: localFunDump {rec:0}))
  
.dumpVal : ({rec:0} : Closure a b) -> Meaning (localFunDump {rec:0})
  
.envVal : ({rec:0} : Closure a b) -> Meaning (localEnv {rec:0})
  
0 .localEnv : Closure a b -> Env
  
0 .localFunDump : Closure a b -> FunDump
0 .localEnv : Closure a b -> Env
  Totality: total
  Visibility: public export
0 localEnv : Closure a b -> Env
  Totality: total
  Visibility: public export
0 .localFunDump : Closure a b -> FunDump
  Totality: total
  Visibility: public export
0 localFunDump : Closure a b -> FunDump
  Totality: total
  Visibility: public export
.code : ({rec:0} : Closure a b) -> Steps (MkState [] (a :: localEnv {rec:0}) ((a, b) :: localFunDump {rec:0})) (MkState [b] (a :: localEnv {rec:0}) ((a, b) :: localFunDump {rec:0}))
  Totality: total
  Visibility: public export
code : ({rec:0} : Closure a b) -> Steps (MkState [] (a :: localEnv {rec:0}) ((a, b) :: localFunDump {rec:0})) (MkState [b] (a :: localEnv {rec:0}) ((a, b) :: localFunDump {rec:0}))
  Totality: total
  Visibility: public export
.envVal : ({rec:0} : Closure a b) -> Meaning (localEnv {rec:0})
  Totality: total
  Visibility: public export
envVal : ({rec:0} : Closure a b) -> Meaning (localEnv {rec:0})
  Totality: total
  Visibility: public export
.dumpVal : ({rec:0} : Closure a b) -> Meaning (localFunDump {rec:0})
  Totality: total
  Visibility: public export
dumpVal : ({rec:0} : Closure a b) -> Meaning (localFunDump {rec:0})
  Totality: total
  Visibility: public export
eqb : (ty : Ty) -> Meaning ty -> Meaning ty -> Bool
  Totality: total
  Visibility: public export
eqbs : (ty : Ty) -> Meaning (TyList ty) -> Meaning (TyList ty) -> Bool
  Totality: total
  Visibility: public export
steps : Meaning st -> Steps st st' -> Late (Meaning st')
  Totality: total
  Visibility: public export
step : Meaning st -> Step st st' -> Late (Meaning st')
  Totality: total
  Visibility: public export
run : Steps (MkState [] [] []) (MkState (ty :: {_:11116}) [] []) -> Nat -> Maybe (Meaning ty)
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Reexports
import public Data.Late
import public Data.List.Quantifiers
Definitions
data Ty : Type
  Totality: total
  Visibility: public export
  Constructors:
  
TyInt : Ty
  
TyBool : Ty
  
TyPair : Ty -> Ty -> Ty
  
TyList : Ty -> Ty
  
TyFun : Ty -> Ty -> Ty
data Const : Ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
AnInt : Int -> Const TyInt
  
True : Const TyBool
  
False : Const TyBool
fromInteger : Integer -> Const TyInt
  Totality: total
  Visibility: public export
Stack : Type
  Totality: total
  Visibility: public export
Env : Type
  Totality: total
  Visibility: public export
FunDump : Type
  Totality: total
  Visibility: public export
record State : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkState : Stack -> Env -> FunDump -> State

  Projections:
  
.dump : State -> FunDump
  
.env : State -> Env
  
.stack : State -> Stack
.stack : State -> Stack
  Totality: total
  Visibility: public export
stack : State -> Stack
  Totality: total
  Visibility: public export
.env : State -> Env
  Totality: total
  Visibility: public export
env : State -> Env
  Totality: total
  Visibility: public export
.dump : State -> FunDump
  Totality: total
  Visibility: public export
dump : State -> FunDump
  Totality: total
  Visibility: public export
data Step : State -> State -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
LDC : Const ty -> Step (MkState s e f) (MkState (ty :: s) e f)
  Load a constant of a base type
  
LDA : Elem ty e -> Step (MkState s e f) (MkState (ty :: s) e f)
  Load a value from an address in the environment
  
LDF : Steps (MkState [] (a :: e) ((a, b) :: f)) (MkState [b] (a :: e) ((a, b) :: f)) -> Step (MkState s e f) (MkState (TyFun a b :: s) e f)
  Load a recursive function
  
LDR : Elem (a, b) f -> Step (MkState s e f) (MkState (TyFun a b :: s) e f)
  Load a function for recursive application
  
APP : Step (MkState (a :: (TyFun a b :: s)) e f) (MkState (b :: s) e f)
  Apply a function to its argument
  
TAP : Step (MkState (a :: (TyFun a b :: s)) e f) (MkState (b :: s) e f)
  Apply a function to its argument, tail call
  
RTN : Step (MkState (b :: s) e ((a, b) :: f)) (MkState [b] e ((a, b) :: f))
  Return a value from inside a function
  
BCH : Steps (MkState s e f) (MkState s' e f) -> Steps (MkState s e f) (MkState s' e f) -> Step (MkState (TyBool :: s) e f) (MkState s' e f)
  Branch over a boolean
  
FLP : Step (MkState (a :: (b :: s)) e f) (MkState (b :: (a :: s)) e f)
  Flip the stack's top values
  
NIL : Step (MkState s e f) (MkState (TyList a :: s) e f)
  Nil constructor
  
CNS : Step (MkState (a :: (TyList a :: s)) e f) (MkState (TyList a :: s) e f)
  Cons constructor
  
HED : Step (MkState (TyList a :: s) e f) (MkState (a :: s) e f)
  Head destructor
  
TAL : Step (MkState (TyList a :: s) e f) (MkState (TyList a :: s) e f)
  Tail destructor
  
MKP : Step (MkState (a :: (b :: s)) e f) (MkState (TyPair a b :: s) e f)
  Pair constructor
  
FST : Step (MkState (TyPair a b :: s) e f) (MkState (a :: s) e f)
  First pair destructor
  
SND : Step (MkState (TyPair a b :: s) e f) (MkState (b :: s) e f)
  Second pair destructor
  
ADD : Step (MkState (TyInt :: (TyInt :: s)) e f) (MkState (TyInt :: s) e f)
  Addition of ints
  
SUB : Step (MkState (TyInt :: (TyInt :: s)) e f) (MkState (TyInt :: s) e f)
  Subtraction of ints
  
MUL : Step (MkState (TyInt :: (TyInt :: s)) e f) (MkState (TyInt :: s) e f)
  Multiplication of ints
  
EQB : Step (MkState (a :: (a :: s)) e f) (MkState (TyBool :: s) e f)
  Structural equality test
  
NOT : Step (MkState (TyBool :: s) e f) (MkState (TyBool :: s) e f)
  Boolean negation
data Steps : State -> State -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Nil : Steps s s
  
(::) : Step s t -> Steps t u -> Steps s u
data Stepz : State -> State -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Lin : Stepz s s
  
(:<) : Stepz s t -> Step t u -> Stepz s u
(<>>) : Stepz s t -> Steps t u -> Steps s u
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 6
(<><) : Stepz s t -> Steps t u -> Stepz s u
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 7
(++) : Steps s t -> Steps t u -> Steps s u
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
NUL : Steps (MkState (TyList a :: s) e f) (MkState (TyBool :: s) e f)
  Totality: total
  Visibility: public export
LDL : List Int -> Steps (MkState s e f) (MkState (TyList TyInt :: s) e f)
  Totality: total
  Visibility: public export
PLS : Step (MkState s e f) (MkState (TyFun TyInt (TyFun TyInt TyInt) :: s) e f)
  Totality: total
  Visibility: public export
MAP : Step (MkState [] e f) (MkState [TyFun (TyFun a b) (TyFun (TyList a) (TyList b))] e f)
  Totality: total
  Visibility: public export
FLD : Step (MkState [] e f) (MkState [TyFun (TyFun b (TyFun a b)) (TyFun b (TyFun (TyList a) b))] e f)
  Totality: total
  Visibility: public export
SUM : Steps (MkState [] e f) (MkState [TyFun (TyList TyInt) TyInt] e f)
  Totality: total
  Visibility: public export
Meaning : Ty -> Type
  Totality: total
  Visibility: public export
fromConst : Const ty -> Meaning ty
  Totality: total
  Visibility: public export
Meaning : List Ty -> Type
  Totality: total
  Visibility: public export
0 Meaning : FunDump -> Type
  Totality: total
  Visibility: public export
tail : Meaning (ab :: f) -> Meaning f
  Totality: total
  Visibility: public export
lookup : Meaning f -> Elem (a, b) f -> Closure a b
  Totality: total
  Visibility: public export
record Meaning : State -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkMeaning : Meaning (st .stack) -> Meaning (st .env) -> Meaning (st .dump) -> Meaning st

  Projections:
  
.dumpVal : Meaning st -> Meaning (st .dump)
  
.envVal : Meaning st -> Meaning (st .env)
  
.stackVal : Meaning st -> Meaning (st .stack)
.stackVal : Meaning st -> Meaning (st .stack)
  Totality: total
  Visibility: public export
stackVal : Meaning st -> Meaning (st .stack)
  Totality: total
  Visibility: public export
.envVal : Meaning st -> Meaning (st .env)
  Totality: total
  Visibility: public export
envVal : Meaning st -> Meaning (st .env)
  Totality: total
  Visibility: public export
.dumpVal : Meaning st -> Meaning (st .dump)
  Totality: total
  Visibility: public export
dumpVal : Meaning st -> Meaning (st .dump)
  Totality: total
  Visibility: public export
record Closure : Ty -> Ty -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkClosure : Steps (MkState [] (a :: localEnv) ((a, b) :: localFunDump)) (MkState [b] (a :: localEnv) ((a, b) :: localFunDump)) -> Meaning localEnv -> Meaning localFunDump -> Closure a b

  Projections:
  
.code : ({rec:0} : Closure a b) -> Steps (MkState [] (a :: localEnv {rec:0}) ((a, b) :: localFunDump {rec:0})) (MkState [b] (a :: localEnv {rec:0}) ((a, b) :: localFunDump {rec:0}))
  
.dumpVal : ({rec:0} : Closure a b) -> Meaning (localFunDump {rec:0})
  
.envVal : ({rec:0} : Closure a b) -> Meaning (localEnv {rec:0})
  
0 .localEnv : Closure a b -> Env
  
0 .localFunDump : Closure a b -> FunDump
0 .localEnv : Closure a b -> Env
  Totality: total
  Visibility: public export
0 localEnv : Closure a b -> Env
  Totality: total
  Visibility: public export
0 .localFunDump : Closure a b -> FunDump
  Totality: total
  Visibility: public export
0 localFunDump : Closure a b -> FunDump
  Totality: total
  Visibility: public export
.code : ({rec:0} : Closure a b) -> Steps (MkState [] (a :: localEnv {rec:0}) ((a, b) :: localFunDump {rec:0})) (MkState [b] (a :: localEnv {rec:0}) ((a, b) :: localFunDump {rec:0}))
  Totality: total
  Visibility: public export
code : ({rec:0} : Closure a b) -> Steps (MkState [] (a :: localEnv {rec:0}) ((a, b) :: localFunDump {rec:0})) (MkState [b] (a :: localEnv {rec:0}) ((a, b) :: localFunDump {rec:0}))
  Totality: total
  Visibility: public export
.envVal : ({rec:0} : Closure a b) -> Meaning (localEnv {rec:0})
  Totality: total
  Visibility: public export
envVal : ({rec:0} : Closure a b) -> Meaning (localEnv {rec:0})
  Totality: total
  Visibility: public export
.dumpVal : ({rec:0} : Closure a b) -> Meaning (localFunDump {rec:0})
  Totality: total
  Visibility: public export
dumpVal : ({rec:0} : Closure a b) -> Meaning (localFunDump {rec:0})
  Totality: total
  Visibility: public export
eqb : (ty : Ty) -> Meaning ty -> Meaning ty -> Bool
  Totality: total
  Visibility: public export
eqbs : (ty : Ty) -> Meaning (TyList ty) -> Meaning (TyList ty) -> Bool
  Totality: total
  Visibility: public export
steps : Meaning st -> Steps st st' -> Late (Meaning st')
  Totality: total
  Visibility: public export
step : Meaning st -> Step st st' -> Late (Meaning st')
  Totality: total
  Visibility: public export
run : Steps (MkState [] [] []) (MkState (ty :: {_:11116}) [] []) -> Nat -> Maybe (Meaning ty)
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Language.IntrinsicTyping.STLCR.html b/papers/docs/Language.IntrinsicTyping.STLCR.html
index 1ccd3717b6..3b047e7e78 100644
--- a/papers/docs/Language.IntrinsicTyping.STLCR.html
+++ b/papers/docs/Language.IntrinsicTyping.STLCR.html
@@ -64,4 +64,4 @@
 
Language.IntrinsicTyping.STLCR(source)
The content of this module is based on the MSc Thesis
 Coinductive Formalization of SECD Machine in Agda
 by Adam Krupička
-
Definitions
data STLCR : List (Ty, Ty) -> List Ty -> Ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Var : Elem ty g -> STLCR r g ty
  
Lam : STLCR ((a, b) :: r) (a :: g) b -> STLCR r g (TyFun a b)
  
App : STLCR r g (TyFun a b) -> STLCR r g a -> STLCR r g b
  
Rec : Elem (a, b) r -> STLCR r g (TyFun a b)
  
If : STLCR r g TyBool -> STLCR r g a -> STLCR r g a -> STLCR r g a
  
Eqb : STLCR r g a -> STLCR r g a -> STLCR r g TyBool
  
Lit : Const ty -> STLCR r g ty
  
Add : STLCR r g TyInt -> STLCR r g TyInt -> STLCR r g TyInt
  
Sub : STLCR r g TyInt -> STLCR r g TyInt -> STLCR r g TyInt
  
Mul : STLCR r g TyInt -> STLCR r g TyInt -> STLCR r g TyInt
fromInteger : Integer -> STLCR r g TyInt
  Totality: total
  Visibility: public export
compile : STLCR r g ty -> Steps (MkState s g r) (MkState (ty :: s) g r)
  Totality: total
  Visibility: public export
compileT : STLCR ((a, b) :: r) (a :: g) b -> Steps (MkState [] (a :: g) ((a, b) :: r)) (MkState [b] (a :: g) ((a, b) :: r))
  Totality: total
  Visibility: public export
compileAcc : Stepz init (MkState s g r) -> STLCR r g ty -> Stepz init (MkState (ty :: s) g r)
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
data STLCR : List (Ty, Ty) -> List Ty -> Ty -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Var : Elem ty g -> STLCR r g ty
  
Lam : STLCR ((a, b) :: r) (a :: g) b -> STLCR r g (TyFun a b)
  
App : STLCR r g (TyFun a b) -> STLCR r g a -> STLCR r g b
  
Rec : Elem (a, b) r -> STLCR r g (TyFun a b)
  
If : STLCR r g TyBool -> STLCR r g a -> STLCR r g a -> STLCR r g a
  
Eqb : STLCR r g a -> STLCR r g a -> STLCR r g TyBool
  
Lit : Const ty -> STLCR r g ty
  
Add : STLCR r g TyInt -> STLCR r g TyInt -> STLCR r g TyInt
  
Sub : STLCR r g TyInt -> STLCR r g TyInt -> STLCR r g TyInt
  
Mul : STLCR r g TyInt -> STLCR r g TyInt -> STLCR r g TyInt
fromInteger : Integer -> STLCR r g TyInt
  Totality: total
  Visibility: public export
compile : STLCR r g ty -> Steps (MkState s g r) (MkState (ty :: s) g r)
  Totality: total
  Visibility: public export
compileT : STLCR ((a, b) :: r) (a :: g) b -> Steps (MkState [] (a :: g) ((a, b) :: r)) (MkState [b] (a :: g) ((a, b) :: r))
  Totality: total
  Visibility: public export
compileAcc : Stepz init (MkState s g r) -> STLCR r g ty -> Stepz init (MkState (ty :: s) g r)
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Language.Tagless.html b/papers/docs/Language.Tagless.html
index 44cd0d71dc..77619ee49d 100644
--- a/papers/docs/Language.Tagless.html
+++ b/papers/docs/Language.Tagless.html
@@ -64,4 +64,4 @@
 
Language.Tagless(source)
This module is based on the paper
 Dependent Tagless Final
 by Nicoals Biri
-
Definitions
(-#) : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 0
BinaryOp : Type -> Type
  Totality: total
  Visibility: public export
Ctx : Type
  Totality: total
  Visibility: public export
Env : Ctx -> Type
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
(-#) : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 0
BinaryOp : Type -> Type
  Totality: total
  Visibility: public export
Ctx : Type
  Totality: total
  Visibility: public export
Env : Ctx -> Type
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Language.TypeTheory.html b/papers/docs/Language.TypeTheory.html
index 8b28318259..f946ee8dff 100644
--- a/papers/docs/Language.TypeTheory.html
+++ b/papers/docs/Language.TypeTheory.html
@@ -68,4 +68,4 @@
 NB: The work is originally written in Haskell and uses unsafe features
     This is not how we would write idiomatic Idris code.
     Cf. Language.IntrinsicScoping.TypeTheory for a more idiomatic representation.
-
Definitions
data Name : Type
  Named variables

  Totality: total
  Visibility: public export
  Constructors:
  
Global : String -> Name
  The most typical of name: external functions
  
Local : Nat -> Name
  When passing under a binder we convert a bound variable
  into a `Local` free variable
  
Quote : Nat -> Name
  During quoting from values back to term we will be using
  the `Quote` constructor

  Hint: 
Eq Name
fromInteger : Integer -> Infer
  Visibility: public export
fromString : String -> Check
  Visibility: public export
fromInteger : Integer -> Check
  Visibility: public export
fromString : String -> Ty
  Visibility: public export

\ No newline at end of file
+
Definitions
data Name : Type
  Named variables

  Totality: total
  Visibility: public export
  Constructors:
  
Global : String -> Name
  The most typical of name: external functions
  
Local : Nat -> Name
  When passing under a binder we convert a bound variable
  into a `Local` free variable
  
Quote : Nat -> Name
  During quoting from values back to term we will be using
  the `Quote` constructor

  Hint: 
Eq Name
fromInteger : Integer -> Infer
  Visibility: public export
fromString : String -> Check
  Visibility: public export
fromInteger : Integer -> Check
  Visibility: public export
fromString : String -> Ty
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Search.Auto.html b/papers/docs/Search.Auto.html
index d347fa5184..1bc5917014 100644
--- a/papers/docs/Search.Auto.html
+++ b/papers/docs/Search.Auto.html
@@ -64,4 +64,4 @@
 
Search.Auto(source)
The content of this module is based on the paper
 Auto in Agda - Programming proof search using reflection
 by Wen Kokke and Wouter Swierstra
-
Definitions
data RuleName : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Free : Name -> RuleName
  
Bound : Nat -> RuleName

  Hint: 
Show RuleName
toName : RuleName -> Name
  Totality: total
  Visibility: export
data TermName : Type
  Totality: total
  Visibility: public export
  Constructors:
  
UName : Name -> TermName
  
Bound : Nat -> TermName
  
Arrow : TermName

  Hint: 
Eq TermName
data Tm : Nat -> Type
  Proof search terms

  Totality: total
  Visibility: public export
  Constructors:
  
Var : Fin n -> Tm n
  
Con : TermName -> List (Tm n) -> Tm n
showTerm : (ns : SnocList Name) -> Tm (length ns) -> String
  Totality: total
  Visibility: export
Env : (Nat -> Type) -> Nat -> Nat -> Type
  Totality: total
  Visibility: public export
rename : Env Fin m n -> Tm m -> Tm n
  Totality: total
  Visibility: export
subst : Env Tm m n -> Tm m -> Tm n
  Totality: total
  Visibility: export
split : Tm m -> (List (Tm m), Tm m)
  Totality: total
  Visibility: export
thin : Fin (S n) -> Fin n -> Fin (S n)
  Totality: total
  Visibility: export
thinInjective : (x : Fin (S n)) -> (y : Fin n) -> (z : Fin n) -> thin x y = thin x z -> y = z
  Totality: total
  Visibility: export
thinnedApart : (x : Fin (S n)) -> (y : Fin n) -> Not (thin x y = x)
  Totality: total
  Visibility: export
thinApart : (x : Fin (S n)) -> (y : Fin (S n)) -> Not (x = y) -> (y' : Fin n ** thin x y' = y)
  Totality: total
  Visibility: export
data Thicken : Fin n -> Fin n -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
EQ : Thicken x x
  
NEQ : (y : Fin n) -> Thicken x (thin x y)
thicken : (x : Fin n) -> (y : Fin n) -> Thicken x y
  Totality: total
  Visibility: export
check : Fin (S n) -> Tm (S n) -> Maybe (Tm n)
  Totality: total
  Visibility: export
for : Tm n -> Fin (S n) -> Env Tm (S n) n
  Totality: total
  Visibility: export
data AList : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Lin : AList m m
  
(:<) : AList m n -> (Fin (S m), Tm m) -> AList (S m) n
(++) : AList m n -> AList l m -> AList l n
  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 7
toSubst : AList m n -> Env Tm m n
  Totality: total
  Visibility: export
mgu : Tm m -> Tm m -> Maybe (Unifying m)
  Totality: total
  Visibility: export
record Rule : Type
  Totality: total
  Visibility: export
  Constructor: 
MkRule : (context : SnocList Name) -> RuleName -> Vect arity (Tm (length context)) -> Tm (length context) -> Rule

  Projections:
  
.arity : Rule -> Nat
  
.conclusion : ({rec:0} : Rule) -> Tm (length (context {rec:0}))
  
.context : Rule -> SnocList Name
  
.premises : ({rec:0} : Rule) -> Vect (arity {rec:0}) (Tm (length (context {rec:0})))
  
.ruleName : Rule -> RuleName

  Hint: 
Show Rule
.scope : Rule -> Nat
  Totality: total
  Visibility: export
HintDB : Type
  Totality: total
  Visibility: public export
data Space : Type -> Type
  A search Space represents the space of possible solutions to a problem.
  It is a finitely branching, potentially infinitely deep, tree.
  E.g. we can prove `Nat` using:
  1. either Z or S                  (finitely branching)
  2. arbitrarily many S constructor (unbounded depth)

  Totality: total
  Visibility: public export
  Constructors:
  
Solution : a -> Space a
  
Candidates : List (Inf (Space a)) -> Space a
data Proof : Type
  A proof is a completed tree where each node is the invocation of a rule
  together with proofs for its premises, or a lambda abstraction with a
  subproof.

  Totality: total
  Visibility: public export
  Constructors:
  
Call : RuleName -> List Proof -> Proof
  
Lam : Nat -> Proof -> Proof

  Hint: 
Show Proof
record PartialProof : Nat -> Type
  A partial proof is a vector of goals and a continuation which, provided
  a proof for each of the goals, returns a completed proof

  Totality: total
  Visibility: public export
  Constructor: 
MkPartialProof : (leftovers : Nat) -> Vect leftovers (Tm m) -> (Vect leftovers Proof -> Proof) -> PartialProof m

  Projections:
  
.continuation : ({rec:0} : PartialProof m) -> Vect (leftovers {rec:0}) Proof -> Proof
  
.goals : ({rec:0} : PartialProof m) -> Vect (leftovers {rec:0}) (Tm m)
  
.leftovers : PartialProof m -> Nat
.leftovers : PartialProof m -> Nat
  Totality: total
  Visibility: public export
leftovers : PartialProof m -> Nat
  Totality: total
  Visibility: public export
.goals : ({rec:0} : PartialProof m) -> Vect (leftovers {rec:0}) (Tm m)
  Totality: total
  Visibility: public export
goals : ({rec:0} : PartialProof m) -> Vect (leftovers {rec:0}) (Tm m)
  Totality: total
  Visibility: public export
.continuation : ({rec:0} : PartialProof m) -> Vect (leftovers {rec:0}) Proof -> Proof
  Totality: total
  Visibility: public export
continuation : ({rec:0} : PartialProof m) -> Vect (leftovers {rec:0}) Proof -> Proof
  Totality: total
  Visibility: public export
apply : (r : Rule) -> Vect (r .arity + k) Proof -> Vect (S k) Proof
  Helper function to manufacture a proof step

  Totality: total
  Visibility: export
solve : Nat -> HintDB -> Tm m -> Space Proof
  Solve takes a database of hints, a goal to prove and returns
  the full search space.

  Totality: total
  Visibility: export
dfs : Nat -> Space a -> List a
  Depth first search strategy to explore a search space.
  This is made total by preemptively limiting the depth the search
  is willing to explore.

  Totality: total
  Visibility: export
convert : (0 f : (SnocList Name -> Nat)) -> ((vars : SnocList Name) -> Name -> Tm (f vars)) -> (vars : SnocList Name) -> TTImp -> Either TTImp (Tm (f vars))
  Converts a type of the form (a -> (a -> b -> c) -> b -> c)
  to our internal representation

  Totality: total
  Visibility: export
parseType : (0 f : (SnocList Name -> Nat)) -> ((vars : SnocList Name) -> Name -> Tm (f vars)) -> TTImp -> Either TTImp (vars : SnocList Name ** Tm (f vars))
  Parse a type of the form
  forall a b c. a -> (a -> b -> c) -> b -> c to
  1. a scope [<a,b,c]
  2. a representation of the rest

  Totality: total
  Visibility: export
parseRule : TTImp -> Either TTImp (vars : SnocList Name ** Tm (length vars))
  Parse a type, where bound variables are flexible variables

  Totality: total
  Visibility: export
parseGoal : TTImp -> Either TTImp (SnocList Name, Tm 0)
  Parse a type, where bound variables are rigid variables

  Totality: total
  Visibility: export
mkRule : Name -> Elab Rule
  Totality: total
  Visibility: export
getGoal : Elab (HintDB, Tm 0)
  Totality: total
  Visibility: export
unquote : Proof -> TTImp
  Totality: total
  Visibility: export
intros : List a -> TTImp -> TTImp
  Totality: total
  Visibility: export
bySearch : Nat -> HintDB -> Elab a
  Totality: total
  Visibility: export

\ No newline at end of file
+
Definitions
data RuleName : Type
  Totality: total
  Visibility: public export
  Constructors:
  
Free : Name -> RuleName
  
Bound : Nat -> RuleName

  Hint: 
Show RuleName
toName : RuleName -> Name
  Totality: total
  Visibility: export
data TermName : Type
  Totality: total
  Visibility: public export
  Constructors:
  
UName : Name -> TermName
  
Bound : Nat -> TermName
  
Arrow : TermName

  Hint: 
Eq TermName
data Tm : Nat -> Type
  Proof search terms

  Totality: total
  Visibility: public export
  Constructors:
  
Var : Fin n -> Tm n
  
Con : TermName -> List (Tm n) -> Tm n
showTerm : (ns : SnocList Name) -> Tm (length ns) -> String
  Totality: total
  Visibility: export
Env : (Nat -> Type) -> Nat -> Nat -> Type
  Totality: total
  Visibility: public export
rename : Env Fin m n -> Tm m -> Tm n
  Totality: total
  Visibility: export
subst : Env Tm m n -> Tm m -> Tm n
  Totality: total
  Visibility: export
split : Tm m -> (List (Tm m), Tm m)
  Totality: total
  Visibility: export
thin : Fin (S n) -> Fin n -> Fin (S n)
  Totality: total
  Visibility: export
thinInjective : (x : Fin (S n)) -> (y : Fin n) -> (z : Fin n) -> thin x y = thin x z -> y = z
  Totality: total
  Visibility: export
thinnedApart : (x : Fin (S n)) -> (y : Fin n) -> Not (thin x y = x)
  Totality: total
  Visibility: export
thinApart : (x : Fin (S n)) -> (y : Fin (S n)) -> Not (x = y) -> (y' : Fin n ** thin x y' = y)
  Totality: total
  Visibility: export
data Thicken : Fin n -> Fin n -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
EQ : Thicken x x
  
NEQ : (y : Fin n) -> Thicken x (thin x y)
thicken : (x : Fin n) -> (y : Fin n) -> Thicken x y
  Totality: total
  Visibility: export
check : Fin (S n) -> Tm (S n) -> Maybe (Tm n)
  Totality: total
  Visibility: export
for : Tm n -> Fin (S n) -> Env Tm (S n) n
  Totality: total
  Visibility: export
data AList : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
Lin : AList m m
  
(:<) : AList m n -> (Fin (S m), Tm m) -> AList (S m) n
(++) : AList m n -> AList l m -> AList l n
  Totality: total
  Visibility: export
  Fixity Declaration: infixr operator, level 7
toSubst : AList m n -> Env Tm m n
  Totality: total
  Visibility: export
mgu : Tm m -> Tm m -> Maybe (Unifying m)
  Totality: total
  Visibility: export
record Rule : Type
  Totality: total
  Visibility: export
  Constructor: 
MkRule : (context : SnocList Name) -> RuleName -> Vect arity (Tm (length context)) -> Tm (length context) -> Rule

  Projections:
  
.arity : Rule -> Nat
  
.conclusion : ({rec:0} : Rule) -> Tm (length (context {rec:0}))
  
.context : Rule -> SnocList Name
  
.premises : ({rec:0} : Rule) -> Vect (arity {rec:0}) (Tm (length (context {rec:0})))
  
.ruleName : Rule -> RuleName

  Hint: 
Show Rule
.scope : Rule -> Nat
  Totality: total
  Visibility: export
HintDB : Type
  Totality: total
  Visibility: public export
data Space : Type -> Type
  A search Space represents the space of possible solutions to a problem.
  It is a finitely branching, potentially infinitely deep, tree.
  E.g. we can prove `Nat` using:
  1. either Z or S                  (finitely branching)
  2. arbitrarily many S constructor (unbounded depth)

  Totality: total
  Visibility: public export
  Constructors:
  
Solution : a -> Space a
  
Candidates : List (Inf (Space a)) -> Space a
data Proof : Type
  A proof is a completed tree where each node is the invocation of a rule
  together with proofs for its premises, or a lambda abstraction with a
  subproof.

  Totality: total
  Visibility: public export
  Constructors:
  
Call : RuleName -> List Proof -> Proof
  
Lam : Nat -> Proof -> Proof

  Hint: 
Show Proof
record PartialProof : Nat -> Type
  A partial proof is a vector of goals and a continuation which, provided
  a proof for each of the goals, returns a completed proof

  Totality: total
  Visibility: public export
  Constructor: 
MkPartialProof : (leftovers : Nat) -> Vect leftovers (Tm m) -> (Vect leftovers Proof -> Proof) -> PartialProof m

  Projections:
  
.continuation : ({rec:0} : PartialProof m) -> Vect (leftovers {rec:0}) Proof -> Proof
  
.goals : ({rec:0} : PartialProof m) -> Vect (leftovers {rec:0}) (Tm m)
  
.leftovers : PartialProof m -> Nat
.leftovers : PartialProof m -> Nat
  Totality: total
  Visibility: public export
leftovers : PartialProof m -> Nat
  Totality: total
  Visibility: public export
.goals : ({rec:0} : PartialProof m) -> Vect (leftovers {rec:0}) (Tm m)
  Totality: total
  Visibility: public export
goals : ({rec:0} : PartialProof m) -> Vect (leftovers {rec:0}) (Tm m)
  Totality: total
  Visibility: public export
.continuation : ({rec:0} : PartialProof m) -> Vect (leftovers {rec:0}) Proof -> Proof
  Totality: total
  Visibility: public export
continuation : ({rec:0} : PartialProof m) -> Vect (leftovers {rec:0}) Proof -> Proof
  Totality: total
  Visibility: public export
apply : (r : Rule) -> Vect (r .arity + k) Proof -> Vect (S k) Proof
  Helper function to manufacture a proof step

  Totality: total
  Visibility: export
solve : Nat -> HintDB -> Tm m -> Space Proof
  Solve takes a database of hints, a goal to prove and returns
  the full search space.

  Totality: total
  Visibility: export
dfs : Nat -> Space a -> List a
  Depth first search strategy to explore a search space.
  This is made total by preemptively limiting the depth the search
  is willing to explore.

  Totality: total
  Visibility: export
convert : (0 f : (SnocList Name -> Nat)) -> ((vars : SnocList Name) -> Name -> Tm (f vars)) -> (vars : SnocList Name) -> TTImp -> Either TTImp (Tm (f vars))
  Converts a type of the form (a -> (a -> b -> c) -> b -> c)
  to our internal representation

  Totality: total
  Visibility: export
parseType : (0 f : (SnocList Name -> Nat)) -> ((vars : SnocList Name) -> Name -> Tm (f vars)) -> TTImp -> Either TTImp (vars : SnocList Name ** Tm (f vars))
  Parse a type of the form
  forall a b c. a -> (a -> b -> c) -> b -> c to
  1. a scope [<a,b,c]
  2. a representation of the rest

  Totality: total
  Visibility: export
parseRule : TTImp -> Either TTImp (vars : SnocList Name ** Tm (length vars))
  Parse a type, where bound variables are flexible variables

  Totality: total
  Visibility: export
parseGoal : TTImp -> Either TTImp (SnocList Name, Tm 0)
  Parse a type, where bound variables are rigid variables

  Totality: total
  Visibility: export
mkRule : Name -> Elab Rule
  Totality: total
  Visibility: export
getGoal : Elab (HintDB, Tm 0)
  Totality: total
  Visibility: export
unquote : Proof -> TTImp
  Totality: total
  Visibility: export
intros : List a -> TTImp -> TTImp
  Totality: total
  Visibility: export
bySearch : Nat -> HintDB -> Elab a
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/papers/docs/Search.CTL.html b/papers/docs/Search.CTL.html
index 6af12f21d3..2ce43e271c 100644
--- a/papers/docs/Search.CTL.html
+++ b/papers/docs/Search.CTL.html
@@ -65,4 +65,4 @@
 Applications of Applicative Proof Search
 by Liam O'Connor
 https://doi.org/10.1145/2976022.2976030
-
Reexports
import public Search.Negation
import public Search.HDecidable
import public Search.Properties
Definitions
record Diagram : Type -> Type -> Type
  Labeled transition diagram

  Totality: total
  Visibility: public export
  Constructor: 
TD : ((labels, state) -> List (labels, state)) -> labels -> Diagram labels state

  Projections:
  
.iState : Diagram labels state -> labels
  Initial state
  
.transFn : Diagram labels state -> (labels, state) -> List (labels, state)
  Transition function
.transFn : Diagram labels state -> (labels, state) -> List (labels, state)
  Transition function

  Totality: total
  Visibility: public export
transFn : Diagram labels state -> (labels, state) -> List (labels, state)
  Transition function

  Totality: total
  Visibility: public export
.iState : Diagram labels state -> labels
  Initial state

  Totality: total
  Visibility: public export
iState : Diagram labels state -> labels
  Initial state

  Totality: total
  Visibility: public export
pComp : {Lbls1 : Type} -> {Lbls2 : Type} -> {Sts : Type} -> Diagram Lbls1 Sts -> Diagram Lbls2 Sts -> Diagram (Lbls1, Lbls2) Sts
  Parallel composition of transition diagrams

  Totality: total
  Visibility: public export
HiHorse : Diagram () Nat
  A process which always increases the shared number.

  Totality: total
  Visibility: public export
LoRoad : Diagram () Nat
  A process which always decreases the shared number.

  Totality: total
  Visibility: public export
data LTE' : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
LTERefl : LTE' m m
  
LTEStep : LTE' n m -> LTE' n (S m)
data CT : Type -> Type -> Type
  A computation tree (corecursive rose tree?)

  Totality: total
  Visibility: public export
  Constructor: 
At : (Lbls : Type) -> (Sts : Type) -> (Lbls, Sts) -> Inf (List CT) -> CT

  Hints:
  
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (AlwaysUntil f g)
  
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (ExistsUntil f g)
model : (Lbls : Type) -> (Sts : Type) -> Diagram Lbls Sts -> Sts -> CT
  Given a transition diagram and a starting value for the shared state,
  construct the computation tree of the given transition diagram.

  Totality: total
  Visibility: public export
Formula : Type -> Type -> Type
  A formula has a bound (for Bounded Model Checking; BMC) and a computation
  tree to check against.

  Totality: total
  Visibility: public export
data Models : (Lbls : Type) -> (Sts : Type) -> CT -> Formula -> Type
  A tree models a formula if there exists a depth d0 for which the property
  holds for all depths d >= d0.

  Totality: total
  Visibility: public export
  Constructor: 
ItModels : (Lbls : Type) -> (Sts : Type) -> (d0 : Nat) -> (LTE' d0 d -> f d m) -> Models m f
record DepthInv : (Lbls : Type) -> (Sts : Type) -> Formula -> Type
  Depth-invariance (DI) is when a formula cannot be falsified by increasing
  the search depth.

  Totality: total
  Visibility: public export
  Constructor: 
DI : (Lbls : Type) -> (Sts : Type) -> (f n m -> f (S n) m) -> DepthInv f

  Projection: 
.prf : (Lbls : Type) -> (Sts : Type) -> DepthInv f -> f n m -> f (S n) m

  Hints:
  
(Lbls : Type) -> (Sts : Type) -> DepthInv TrueF
  
(Lbls : Type) -> (Sts : Type) -> DepthInv (Guarded p)
  
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (AND' f g)
  
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (AlwaysUntil f g)
  
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (ExistsUntil f g)
  
(Lbls : Type) -> (Sts : Type) -> DepthInv Completed
.prf : (Lbls : Type) -> (Sts : Type) -> DepthInv f -> f n m -> f (S n) m
  Totality: total
  Visibility: public export
prf : (Lbls : Type) -> (Sts : Type) -> DepthInv f -> f n m -> f (S n) m
  Totality: total
  Visibility: public export
diModels : (Lbls : Type) -> (Sts : Type) -> DepthInv f => f n m -> Models m f
  A DI-formula holding for a specific depth means the CT models the formula
  in general (we could increase the search depth and still be fine).

  Totality: total
  Visibility: public export
data TrueF : (Lbls : Type) -> (Sts : Type) -> Formula
  A trivially true (TT) formula.

  Totality: total
  Visibility: public export
  Constructor: 
TT : (Lbls : Type) -> (Sts : Type) -> TrueF n m

  Hint: 
(Lbls : Type) -> (Sts : Type) -> DepthInv TrueF
TrueDI : (Lbls : Type) -> (Sts : Type) -> DepthInv TrueF
  A tt formula is depth-invariant.

  Totality: total
  Visibility: public export
data Guarded : (Lbls : Type) -> (Sts : Type) -> (Sts -> Lbls -> Type) -> Formula
  The formula `Guarded g` is true when the current state satisfies the
  guard `g`.

  Totality: total
  Visibility: public export
  Constructor: 
Here : (Lbls : Type) -> (Sts : Type) -> g st l -> Guarded g depth (At (l, st) ms)

  Hint: 
(Lbls : Type) -> (Sts : Type) -> DepthInv (Guarded p)
diGuarded : (Lbls : Type) -> (Sts : Type) -> DepthInv (Guarded p)
  Guarded expressions are depth-invariant as the guard does not care about
  depth.

  Totality: total
  Visibility: public export
record AND' : (Lbls : Type) -> (Sts : Type) -> Formula -> Formula -> Nat -> CT -> Type
  Conjunction of two `Formula`s

  Totality: total
  Visibility: public export
  Constructor: 
MkAND' : (Lbls : Type) -> (Sts : Type) -> f depth tree -> g depth tree -> AND' f g depth tree

  Projections:
  
.fst : (Lbls : Type) -> (Sts : Type) -> AND' f g depth tree -> f depth tree
  
.snd : (Lbls : Type) -> (Sts : Type) -> AND' f g depth tree -> g depth tree

  Hint: 
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (AND' f g)
.fst : (Lbls : Type) -> (Sts : Type) -> AND' f g depth tree -> f depth tree
  Totality: total
  Visibility: public export
fst : (Lbls : Type) -> (Sts : Type) -> AND' f g depth tree -> f depth tree
  Totality: total
  Visibility: public export
.snd : (Lbls : Type) -> (Sts : Type) -> AND' f g depth tree -> g depth tree
  Totality: total
  Visibility: public export
snd : (Lbls : Type) -> (Sts : Type) -> AND' f g depth tree -> g depth tree
  Totality: total
  Visibility: public export
diAND' : (Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (AND' f g)
  Conjunction is depth-invariant

  Totality: total
  Visibility: public export
data AlwaysUntil : (Lbls : Type) -> (Sts : Type) -> Formula -> Formula -> Formula
  A proof that for all paths in the tree, f holds until g does.

  Totality: total
  Visibility: public export
  Constructors:
  
Here : (Lbls : Type) -> (Sts : Type) -> g n t -> AlwaysUntil f g (S n) t
  We've found a place where g holds, so we're done.
  
There : (Lbls : Type) -> (Sts : Type) -> f n (At st infCTs) -> All (AlwaysUntil f g n) (Force infCTs) -> AlwaysUntil f g (S n) (At st infCTs)
  If f still holds and we can recursively show that g holds for all
  possible subpaths in the CT, then all branches have f hold until g
  does.

  Hint: 
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (AlwaysUntil f g)
diAU : (Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (AlwaysUntil f g)
  Provided `f` and `g` are depth-invariant, AlwaysUntil is
  depth-invariant.

  Totality: total
  Visibility: public export
data ExistsUntil : (Lbls : Type) -> (Sts : Type) -> Formula -> Formula -> Formula
  A proof that somewhere in the tree, there is a path for which f holds
  until g does.

  Totality: total
  Visibility: public export
  Constructors:
  
Here : (Lbls : Type) -> (Sts : Type) -> g n t -> ExistsUntil f g (S n) t
  If g holds here, we've found a branch where we can stop.
  
There : (Lbls : Type) -> (Sts : Type) -> f n (At st infCTs) -> Any (ExistsUntil f g n) (Force infCTs) -> ExistsUntil f g (S n) (At st infCTs)
  If f holds here and any of the further branches have a g, then there
  is a branch where f holds until g does.

  Hint: 
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (ExistsUntil f g)
diEU : (Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (ExistsUntil f g)
  Provided `f` and `g` are depth-invariant, ExistsUntil is
  depth-invariant.

  Totality: total
  Visibility: public export
AlwaysFinally : (Lbls : Type) -> (Sts : Type) -> Formula -> Formula
  "Always finally" means that for all paths, the formula f will eventually
  hold.
  
  This is equivalent to saying `A [TT U f]` (where TT is trivially true).

  Totality: total
  Visibility: public export
ExistsFinally : (Lbls : Type) -> (Sts : Type) -> Formula -> Formula
  "Exists finally" means that for some pathe, the formula f will eventually
  hold.
  
  This is equivalent to saying `E [TT U f]` (where TT is trivially true).

  Totality: total
  Visibility: public export
data Completed : (Lbls : Type) -> (Sts : Type) -> Formula
  A completed formula is a formula for which no more successor states exist.

  Totality: total
  Visibility: public export
  Constructor: 
IsCompleted : (Lbls : Type) -> (Sts : Type) -> (Force infCTs) = [] -> Completed n (At st infCTs)

  Hint: 
(Lbls : Type) -> (Sts : Type) -> DepthInv Completed
diCompleted : (Lbls : Type) -> (Sts : Type) -> DepthInv Completed
  A completed formula is depth-invariant (there is nothing more to do).

  Totality: total
  Visibility: public export
AlwaysGlobal : (Lbls : Type) -> (Sts : Type) -> Formula -> Formula
  We can only handle always global checks on finite paths.

  Totality: total
  Visibility: public export
ExistsGlobal : (Lbls : Type) -> (Sts : Type) -> Formula -> Formula
  We can only handle exists global checks on finite paths.

  Totality: total
  Visibility: public export
MC : (Lbls : Type) -> (Sts : Type) -> Formula -> Type
  Model-checking is a half-decider for the formula `f`

  Totality: total
  Visibility: public export
now : (Lbls : Type) -> (Sts : Type) -> AnHDec hdec => ((st : Sts) -> (l : Lbls) -> hdec (g st l)) -> MC (Guarded g)
  Proof-search combinator for guards.

  Totality: total
  Visibility: public export
isCompleted : (Lbls : Type) -> (Sts : Type) -> MC Completed
  Check if the current state has any successors.

  Totality: total
  Visibility: public export
mcAND' : (Lbls : Type) -> (Sts : Type) -> MC f -> MC g -> MC (AND' f g)
  Conjunction of model-checking procedures.

  Totality: total
  Visibility: public export
auSearch : (Lbls : Type) -> (Sts : Type) -> MC f -> MC g -> MC (AlwaysUntil f g)
  Proof-search for `AlwaysUntil`.
  
  Evaluates the entire `Inf (List CT)` of the state-space, since we need
  `f U g` to hold across every path.

  Totality: total
  Visibility: public export
euSearch : (Lbls : Type) -> (Sts : Type) -> MC f -> MC g -> MC (ExistsUntil f g)
  Proof-search for `ExistsUntil`.
  
  `Inf` over the state-space, since `E [f U g]` holds as soon as `f U g` is
  found.

  Totality: total
  Visibility: public export
efSearch : (Lbls : Type) -> (Sts : Type) -> MC f -> MC (ExistsFinally f)
  Proof-search for Exists Finally

  Totality: total
  Visibility: public export
afSearch : (Lbls : Type) -> (Sts : Type) -> MC f -> MC (AlwaysFinally f)
  Proof-search for Always Finally

  Totality: total
  Visibility: public export
egSearch : (Lbls : Type) -> (Sts : Type) -> MC f -> MC (ExistsGlobal f)
  Proof-search for Exists Global

  Totality: total
  Visibility: public export
agSearch : (Lbls : Type) -> (Sts : Type) -> MC f -> MC (AlwaysGlobal f)
  Proof-search for Always Global

  Totality: total
  Visibility: public export
tree : CT
  This CT is a model of composing the `HiHorse` and `LoRoad` programs.

  Totality: total
  Visibility: public export
reaches10 : HDec (ExistsFinally (\depth, tree => Guarded (\st, l => st = 10) depth tree) 20 tree)
  A half-decider for proving that there exists a path where the shared
  `HiHorse || LoRoad` state reaches 10.

  Totality: total
  Visibility: public export
r10Proof : Models tree (ExistsFinally (Guarded (\st, {_:8769} => st = 10)))
  Prove that the shared state of `HiHorse || LoRoad` reaches 10, using the
  previously defined half-decider.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Reexports
import public Search.Negation
import public Search.HDecidable
import public Search.Properties
Definitions
record Diagram : Type -> Type -> Type
  Labeled transition diagram

  Totality: total
  Visibility: public export
  Constructor: 
TD : ((labels, state) -> List (labels, state)) -> labels -> Diagram labels state

  Projections:
  
.iState : Diagram labels state -> labels
  Initial state
  
.transFn : Diagram labels state -> (labels, state) -> List (labels, state)
  Transition function
.transFn : Diagram labels state -> (labels, state) -> List (labels, state)
  Transition function

  Totality: total
  Visibility: public export
transFn : Diagram labels state -> (labels, state) -> List (labels, state)
  Transition function

  Totality: total
  Visibility: public export
.iState : Diagram labels state -> labels
  Initial state

  Totality: total
  Visibility: public export
iState : Diagram labels state -> labels
  Initial state

  Totality: total
  Visibility: public export
pComp : {Lbls1 : Type} -> {Lbls2 : Type} -> {Sts : Type} -> Diagram Lbls1 Sts -> Diagram Lbls2 Sts -> Diagram (Lbls1, Lbls2) Sts
  Parallel composition of transition diagrams

  Totality: total
  Visibility: public export
HiHorse : Diagram () Nat
  A process which always increases the shared number.

  Totality: total
  Visibility: public export
LoRoad : Diagram () Nat
  A process which always decreases the shared number.

  Totality: total
  Visibility: public export
data LTE' : Nat -> Nat -> Type
  Totality: total
  Visibility: public export
  Constructors:
  
LTERefl : LTE' m m
  
LTEStep : LTE' n m -> LTE' n (S m)
data CT : Type -> Type -> Type
  A computation tree (corecursive rose tree?)

  Totality: total
  Visibility: public export
  Constructor: 
At : (Lbls : Type) -> (Sts : Type) -> (Lbls, Sts) -> Inf (List CT) -> CT

  Hints:
  
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (AlwaysUntil f g)
  
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (ExistsUntil f g)
model : (Lbls : Type) -> (Sts : Type) -> Diagram Lbls Sts -> Sts -> CT
  Given a transition diagram and a starting value for the shared state,
  construct the computation tree of the given transition diagram.

  Totality: total
  Visibility: public export
Formula : Type -> Type -> Type
  A formula has a bound (for Bounded Model Checking; BMC) and a computation
  tree to check against.

  Totality: total
  Visibility: public export
data Models : (Lbls : Type) -> (Sts : Type) -> CT -> Formula -> Type
  A tree models a formula if there exists a depth d0 for which the property
  holds for all depths d >= d0.

  Totality: total
  Visibility: public export
  Constructor: 
ItModels : (Lbls : Type) -> (Sts : Type) -> (d0 : Nat) -> (LTE' d0 d -> f d m) -> Models m f
record DepthInv : (Lbls : Type) -> (Sts : Type) -> Formula -> Type
  Depth-invariance (DI) is when a formula cannot be falsified by increasing
  the search depth.

  Totality: total
  Visibility: public export
  Constructor: 
DI : (Lbls : Type) -> (Sts : Type) -> (f n m -> f (S n) m) -> DepthInv f

  Projection: 
.prf : (Lbls : Type) -> (Sts : Type) -> DepthInv f -> f n m -> f (S n) m

  Hints:
  
(Lbls : Type) -> (Sts : Type) -> DepthInv TrueF
  
(Lbls : Type) -> (Sts : Type) -> DepthInv (Guarded p)
  
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (AND' f g)
  
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (AlwaysUntil f g)
  
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (ExistsUntil f g)
  
(Lbls : Type) -> (Sts : Type) -> DepthInv Completed
.prf : (Lbls : Type) -> (Sts : Type) -> DepthInv f -> f n m -> f (S n) m
  Totality: total
  Visibility: public export
prf : (Lbls : Type) -> (Sts : Type) -> DepthInv f -> f n m -> f (S n) m
  Totality: total
  Visibility: public export
diModels : (Lbls : Type) -> (Sts : Type) -> DepthInv f => f n m -> Models m f
  A DI-formula holding for a specific depth means the CT models the formula
  in general (we could increase the search depth and still be fine).

  Totality: total
  Visibility: public export
data TrueF : (Lbls : Type) -> (Sts : Type) -> Formula
  A trivially true (TT) formula.

  Totality: total
  Visibility: public export
  Constructor: 
TT : (Lbls : Type) -> (Sts : Type) -> TrueF n m

  Hint: 
(Lbls : Type) -> (Sts : Type) -> DepthInv TrueF
TrueDI : (Lbls : Type) -> (Sts : Type) -> DepthInv TrueF
  A tt formula is depth-invariant.

  Totality: total
  Visibility: public export
data Guarded : (Lbls : Type) -> (Sts : Type) -> (Sts -> Lbls -> Type) -> Formula
  The formula `Guarded g` is true when the current state satisfies the
  guard `g`.

  Totality: total
  Visibility: public export
  Constructor: 
Here : (Lbls : Type) -> (Sts : Type) -> g st l -> Guarded g depth (At (l, st) ms)

  Hint: 
(Lbls : Type) -> (Sts : Type) -> DepthInv (Guarded p)
diGuarded : (Lbls : Type) -> (Sts : Type) -> DepthInv (Guarded p)
  Guarded expressions are depth-invariant as the guard does not care about
  depth.

  Totality: total
  Visibility: public export
record AND' : (Lbls : Type) -> (Sts : Type) -> Formula -> Formula -> Nat -> CT -> Type
  Conjunction of two `Formula`s

  Totality: total
  Visibility: public export
  Constructor: 
MkAND' : (Lbls : Type) -> (Sts : Type) -> f depth tree -> g depth tree -> AND' f g depth tree

  Projections:
  
.fst : (Lbls : Type) -> (Sts : Type) -> AND' f g depth tree -> f depth tree
  
.snd : (Lbls : Type) -> (Sts : Type) -> AND' f g depth tree -> g depth tree

  Hint: 
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (AND' f g)
.fst : (Lbls : Type) -> (Sts : Type) -> AND' f g depth tree -> f depth tree
  Totality: total
  Visibility: public export
fst : (Lbls : Type) -> (Sts : Type) -> AND' f g depth tree -> f depth tree
  Totality: total
  Visibility: public export
.snd : (Lbls : Type) -> (Sts : Type) -> AND' f g depth tree -> g depth tree
  Totality: total
  Visibility: public export
snd : (Lbls : Type) -> (Sts : Type) -> AND' f g depth tree -> g depth tree
  Totality: total
  Visibility: public export
diAND' : (Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (AND' f g)
  Conjunction is depth-invariant

  Totality: total
  Visibility: public export
data AlwaysUntil : (Lbls : Type) -> (Sts : Type) -> Formula -> Formula -> Formula
  A proof that for all paths in the tree, f holds until g does.

  Totality: total
  Visibility: public export
  Constructors:
  
Here : (Lbls : Type) -> (Sts : Type) -> g n t -> AlwaysUntil f g (S n) t
  We've found a place where g holds, so we're done.
  
There : (Lbls : Type) -> (Sts : Type) -> f n (At st infCTs) -> All (AlwaysUntil f g n) (Force infCTs) -> AlwaysUntil f g (S n) (At st infCTs)
  If f still holds and we can recursively show that g holds for all
  possible subpaths in the CT, then all branches have f hold until g
  does.

  Hint: 
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (AlwaysUntil f g)
diAU : (Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (AlwaysUntil f g)
  Provided `f` and `g` are depth-invariant, AlwaysUntil is
  depth-invariant.

  Totality: total
  Visibility: public export
data ExistsUntil : (Lbls : Type) -> (Sts : Type) -> Formula -> Formula -> Formula
  A proof that somewhere in the tree, there is a path for which f holds
  until g does.

  Totality: total
  Visibility: public export
  Constructors:
  
Here : (Lbls : Type) -> (Sts : Type) -> g n t -> ExistsUntil f g (S n) t
  If g holds here, we've found a branch where we can stop.
  
There : (Lbls : Type) -> (Sts : Type) -> f n (At st infCTs) -> Any (ExistsUntil f g n) (Force infCTs) -> ExistsUntil f g (S n) (At st infCTs)
  If f holds here and any of the further branches have a g, then there
  is a branch where f holds until g does.

  Hint: 
(Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (ExistsUntil f g)
diEU : (Lbls : Type) -> (Sts : Type) -> DepthInv f => DepthInv g => DepthInv (ExistsUntil f g)
  Provided `f` and `g` are depth-invariant, ExistsUntil is
  depth-invariant.

  Totality: total
  Visibility: public export
AlwaysFinally : (Lbls : Type) -> (Sts : Type) -> Formula -> Formula
  "Always finally" means that for all paths, the formula f will eventually
  hold.
  
  This is equivalent to saying `A [TT U f]` (where TT is trivially true).

  Totality: total
  Visibility: public export
ExistsFinally : (Lbls : Type) -> (Sts : Type) -> Formula -> Formula
  "Exists finally" means that for some pathe, the formula f will eventually
  hold.
  
  This is equivalent to saying `E [TT U f]` (where TT is trivially true).

  Totality: total
  Visibility: public export
data Completed : (Lbls : Type) -> (Sts : Type) -> Formula
  A completed formula is a formula for which no more successor states exist.

  Totality: total
  Visibility: public export
  Constructor: 
IsCompleted : (Lbls : Type) -> (Sts : Type) -> (Force infCTs) = [] -> Completed n (At st infCTs)

  Hint: 
(Lbls : Type) -> (Sts : Type) -> DepthInv Completed
diCompleted : (Lbls : Type) -> (Sts : Type) -> DepthInv Completed
  A completed formula is depth-invariant (there is nothing more to do).

  Totality: total
  Visibility: public export
AlwaysGlobal : (Lbls : Type) -> (Sts : Type) -> Formula -> Formula
  We can only handle always global checks on finite paths.

  Totality: total
  Visibility: public export
ExistsGlobal : (Lbls : Type) -> (Sts : Type) -> Formula -> Formula
  We can only handle exists global checks on finite paths.

  Totality: total
  Visibility: public export
MC : (Lbls : Type) -> (Sts : Type) -> Formula -> Type
  Model-checking is a half-decider for the formula `f`

  Totality: total
  Visibility: public export
now : (Lbls : Type) -> (Sts : Type) -> AnHDec hdec => ((st : Sts) -> (l : Lbls) -> hdec (g st l)) -> MC (Guarded g)
  Proof-search combinator for guards.

  Totality: total
  Visibility: public export
isCompleted : (Lbls : Type) -> (Sts : Type) -> MC Completed
  Check if the current state has any successors.

  Totality: total
  Visibility: public export
mcAND' : (Lbls : Type) -> (Sts : Type) -> MC f -> MC g -> MC (AND' f g)
  Conjunction of model-checking procedures.

  Totality: total
  Visibility: public export
auSearch : (Lbls : Type) -> (Sts : Type) -> MC f -> MC g -> MC (AlwaysUntil f g)
  Proof-search for `AlwaysUntil`.
  
  Evaluates the entire `Inf (List CT)` of the state-space, since we need
  `f U g` to hold across every path.

  Totality: total
  Visibility: public export
euSearch : (Lbls : Type) -> (Sts : Type) -> MC f -> MC g -> MC (ExistsUntil f g)
  Proof-search for `ExistsUntil`.
  
  `Inf` over the state-space, since `E [f U g]` holds as soon as `f U g` is
  found.

  Totality: total
  Visibility: public export
efSearch : (Lbls : Type) -> (Sts : Type) -> MC f -> MC (ExistsFinally f)
  Proof-search for Exists Finally

  Totality: total
  Visibility: public export
afSearch : (Lbls : Type) -> (Sts : Type) -> MC f -> MC (AlwaysFinally f)
  Proof-search for Always Finally

  Totality: total
  Visibility: public export
egSearch : (Lbls : Type) -> (Sts : Type) -> MC f -> MC (ExistsGlobal f)
  Proof-search for Exists Global

  Totality: total
  Visibility: public export
agSearch : (Lbls : Type) -> (Sts : Type) -> MC f -> MC (AlwaysGlobal f)
  Proof-search for Always Global

  Totality: total
  Visibility: public export
tree : CT
  This CT is a model of composing the `HiHorse` and `LoRoad` programs.

  Totality: total
  Visibility: public export
reaches10 : HDec (ExistsFinally (\depth, tree => Guarded (\st, l => st = 10) depth tree) 20 tree)
  A half-decider for proving that there exists a path where the shared
  `HiHorse || LoRoad` state reaches 10.

  Totality: total
  Visibility: public export
r10Proof : Models tree (ExistsFinally (Guarded (\st, {_:8769} => st = 10)))
  Prove that the shared state of `HiHorse || LoRoad` reaches 10, using the
  previously defined half-decider.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/papers/docs/Search.GCL.html b/papers/docs/Search.GCL.html
index 4067c5d459..341f9be754 100644
--- a/papers/docs/Search.GCL.html
+++ b/papers/docs/Search.GCL.html
@@ -65,4 +65,4 @@
 Applications of Applicative Proof Search
 by Liam O'Connor
 https://doi.org/10.1145/2976022.2976030
-
Reexports
import public Search.CTL
Definitions
weaken : Dec {_:6603} -> Bool
  Weaken a Dec to a Bool.

  Totality: total
  Visibility: public export
data GCL : Type -> Type
  Guarded Command Language

  Totality: total
  Visibility: public export
  Constructors:
  
IF : (Sts : Type) -> List GUARD -> GCL
  
DOT : (Sts : Type) -> GCL -> GCL -> GCL
  
DO : (Sts : Type) -> List GUARD -> GCL
  
UPDATE : (Sts : Type) -> (Sts -> Sts) -> GCL
  
SKIP : (Sts : Type) -> GCL
  Termination

  Hints:
  
(Sts : Type) -> Uninhabited (IF {_:6700} = SKIP)
  
(Sts : Type) -> Uninhabited (DOT {_:6725} {_:6724} = SKIP)
  
(Sts : Type) -> Uninhabited (DO {_:6753} = SKIP)
  
(Sts : Type) -> Uninhabited (UPDATE {_:6776} = SKIP)
Pred : Type -> Type
  A predicate

  Totality: total
  Visibility: public export
record GUARD : Type -> Type
  Guards are checks on the current state

  Totality: total
  Visibility: public export
  Constructor: 
MkGUARD : (Sts : Type) -> Pred -> GCL -> GUARD

  Projections:
  
.g : (Sts : Type) -> GUARD -> Pred
  The check to confirm
  
.x : (Sts : Type) -> GUARD -> GCL
  The current state

  Hints:
  
(Sts : Type) -> Uninhabited (IF {_:6700} = SKIP)
  
(Sts : Type) -> Uninhabited (DO {_:6753} = SKIP)
.g : (Sts : Type) -> GUARD -> Pred
  The check to confirm

  Totality: total
  Visibility: public export
g : (Sts : Type) -> GUARD -> Pred
  The check to confirm

  Totality: total
  Visibility: public export
.x : (Sts : Type) -> GUARD -> GCL
  The current state

  Totality: total
  Visibility: public export
x : (Sts : Type) -> GUARD -> GCL
  The current state

  Totality: total
  Visibility: public export
isSkip : (Sts : Type) -> (l : GCL) -> Dec (l = SKIP)
  Prove that the given program terminated (i.e. reached a `SKIP`).

  Totality: total
  Visibility: public export
ops' : (Sts : Type) -> GCL -> Sts -> List (GCL, Sts)
  Operational semantics of GCL.
  (curried version to pass the termination checker)

  Totality: total
  Visibility: public export
ops : (Sts : Type) -> (GCL, Sts) -> List (GCL, Sts)
  Operational semantics of GCL.

  Totality: total
  Visibility: public export
gclToDiag : (Sts : Type) -> GCL -> Diagram GCL Sts
  We can convert a GCL program to a transition digram by using the program
  as the state and the operational semantics as the transition function.

  Totality: total
  Visibility: public export
while : (Sts : Type) -> Pred -> GCL -> GCL
  While loops are GCL do loops with a single guard.

  Totality: total
  Visibility: public export
await : (Sts : Type) -> Pred -> GCL
  Await halts progress unless the predicate is satisfied.

  Totality: total
  Visibility: public export
ifThenElse : (Sts : Type) -> Pred -> GCL -> GCL -> GCL
  If statements translate into GCL if statements by having an unmodified and
  a negated version of the predicate in the list of `IF` GCL statements.

  Totality: total
  Visibility: public export
record State : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkState : Bool -> Bool -> Nat -> Bool -> Bool -> State

  Projections:
  
.inCS1 : State -> Bool
  
.inCS2 : State -> Bool
  
.intent1 : State -> Bool
  
.intent2 : State -> Bool
  
.turn : State -> Nat
.intent2 : State -> Bool
  Totality: total
  Visibility: public export
.intent1 : State -> Bool
  Totality: total
  Visibility: public export
intent2 : State -> Bool
  Totality: total
  Visibility: public export
intent1 : State -> Bool
  Totality: total
  Visibility: public export
.turn : State -> Nat
  Totality: total
  Visibility: public export
turn : State -> Nat
  Totality: total
  Visibility: public export
.inCS2 : State -> Bool
  Totality: total
  Visibility: public export
.inCS1 : State -> Bool
  Totality: total
  Visibility: public export
inCS2 : State -> Bool
  Totality: total
  Visibility: public export
inCS1 : State -> Bool
  Totality: total
  Visibility: public export
CS1 : GCL
  First critical section

  Totality: total
  Visibility: public export
CS2 : GCL
  Second critical section

  Totality: total
  Visibility: public export
petersons1 : GCL
  First Peterson's algorithm process

  Totality: total
  Visibility: public export
petersons2 : GCL
  Second Peterson's algorithm process

  Totality: total
  Visibility: public export
petersons : Diagram (GCL, GCL) State
  The parallel composition of the two Peterson's processes, to be
  model-checked.

  Totality: total
  Visibility: public export
IsTT : (b : Bool) -> Dec (So b)
  Type-level decider for booleans.

  Totality: total
  Visibility: public export
Mutex : Formula
  Mutual exclusion, i.e. both critical sections not simultaneously active.

  Totality: total
  Visibility: public export
checkMutex : MC Mutex
  Model-check (search) whether the mutex condition is satisfied.

  Totality: total
  Visibility: public export
SF : Formula
  Starvation freedom

  Totality: total
  Visibility: public export
checkSF : MC SF
  Model-check (search) whether starvation freedom holds.

  Totality: total
  Visibility: public export
Termination : Formula
  Deadlock freedom, aka. termination for all possible paths/traces

  Totality: total
  Visibility: public export
checkTermination : MC Termination
  Model-check (search) whether termination holds.

  Totality: total
  Visibility: public export
init : State
  Initial state for model-checking Peterson's algorithm.

  Totality: total
  Visibility: public export
tree : CT
  The computational tree for the two Peterson's processes.

  Totality: total
  Visibility: public export
CSP : Type
  The Critical Section Problem:
  1) a process's critical section (CS) is only ever accessed by that process
     and no other
  2) any process which wishes to gain access to its CS eventually
     does so
  3) the composition of the processes is deadlock free
     (we use a stronger requirement: that all process composition must
     terminate successfully)

  Totality: total
  Visibility: public export
checkPetersons : Prop (Nat :: Constraints) CSP
  A `Prop` (property) containing all the conditions necessary for proving that
  Peterson's Algorithm is a correct solution to the Critical Section Problem.
  When evaluated (e.g. through the `auto` search in a `Properties.check`
  call; specifically `runProp`), it will produce the required proof (which is
  **very** big).

  Totality: total
  Visibility: public export
dekkers1 : GCL
  First Dekker's algorithm process

  Totality: total
  Visibility: public export
dekkers2 : GCL
  First Dekker's algorithm process

  Totality: total
  Visibility: public export
dekkers : Diagram (GCL, GCL) State
  The parallel composition of the two Dekker's processes, to be model-checked.

  Totality: total
  Visibility: public export
checkDekkers : HDec (ExistsFinally ?f 100 (model dekkers init))
  An attempt at finding a violation of Mutual Exclusion.
  THIS WILL NOT FIND A PROOF due to the lack of fairness in the unfolding of
  the traces. Dekker's algorithm requires fair scheduling in order to be
  correct, but since we don't have that, we cannot find a proof that no
  violations of mutex exist.
  
  /!\ Trying to evaluate this did not finish after 10 minutes /!\

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Reexports
import public Search.CTL
Definitions
weaken : Dec {_:6603} -> Bool
  Weaken a Dec to a Bool.

  Totality: total
  Visibility: public export
data GCL : Type -> Type
  Guarded Command Language

  Totality: total
  Visibility: public export
  Constructors:
  
IF : (Sts : Type) -> List GUARD -> GCL
  
DOT : (Sts : Type) -> GCL -> GCL -> GCL
  
DO : (Sts : Type) -> List GUARD -> GCL
  
UPDATE : (Sts : Type) -> (Sts -> Sts) -> GCL
  
SKIP : (Sts : Type) -> GCL
  Termination

  Hints:
  
(Sts : Type) -> Uninhabited (IF {_:6700} = SKIP)
  
(Sts : Type) -> Uninhabited (DOT {_:6725} {_:6724} = SKIP)
  
(Sts : Type) -> Uninhabited (DO {_:6753} = SKIP)
  
(Sts : Type) -> Uninhabited (UPDATE {_:6776} = SKIP)
Pred : Type -> Type
  A predicate

  Totality: total
  Visibility: public export
record GUARD : Type -> Type
  Guards are checks on the current state

  Totality: total
  Visibility: public export
  Constructor: 
MkGUARD : (Sts : Type) -> Pred -> GCL -> GUARD

  Projections:
  
.g : (Sts : Type) -> GUARD -> Pred
  The check to confirm
  
.x : (Sts : Type) -> GUARD -> GCL
  The current state

  Hints:
  
(Sts : Type) -> Uninhabited (IF {_:6700} = SKIP)
  
(Sts : Type) -> Uninhabited (DO {_:6753} = SKIP)
.g : (Sts : Type) -> GUARD -> Pred
  The check to confirm

  Totality: total
  Visibility: public export
g : (Sts : Type) -> GUARD -> Pred
  The check to confirm

  Totality: total
  Visibility: public export
.x : (Sts : Type) -> GUARD -> GCL
  The current state

  Totality: total
  Visibility: public export
x : (Sts : Type) -> GUARD -> GCL
  The current state

  Totality: total
  Visibility: public export
isSkip : (Sts : Type) -> (l : GCL) -> Dec (l = SKIP)
  Prove that the given program terminated (i.e. reached a `SKIP`).

  Totality: total
  Visibility: public export
ops' : (Sts : Type) -> GCL -> Sts -> List (GCL, Sts)
  Operational semantics of GCL.
  (curried version to pass the termination checker)

  Totality: total
  Visibility: public export
ops : (Sts : Type) -> (GCL, Sts) -> List (GCL, Sts)
  Operational semantics of GCL.

  Totality: total
  Visibility: public export
gclToDiag : (Sts : Type) -> GCL -> Diagram GCL Sts
  We can convert a GCL program to a transition digram by using the program
  as the state and the operational semantics as the transition function.

  Totality: total
  Visibility: public export
while : (Sts : Type) -> Pred -> GCL -> GCL
  While loops are GCL do loops with a single guard.

  Totality: total
  Visibility: public export
await : (Sts : Type) -> Pred -> GCL
  Await halts progress unless the predicate is satisfied.

  Totality: total
  Visibility: public export
ifThenElse : (Sts : Type) -> Pred -> GCL -> GCL -> GCL
  If statements translate into GCL if statements by having an unmodified and
  a negated version of the predicate in the list of `IF` GCL statements.

  Totality: total
  Visibility: public export
record State : Type
  Totality: total
  Visibility: public export
  Constructor: 
MkState : Bool -> Bool -> Nat -> Bool -> Bool -> State

  Projections:
  
.inCS1 : State -> Bool
  
.inCS2 : State -> Bool
  
.intent1 : State -> Bool
  
.intent2 : State -> Bool
  
.turn : State -> Nat
.intent2 : State -> Bool
  Totality: total
  Visibility: public export
.intent1 : State -> Bool
  Totality: total
  Visibility: public export
intent2 : State -> Bool
  Totality: total
  Visibility: public export
intent1 : State -> Bool
  Totality: total
  Visibility: public export
.turn : State -> Nat
  Totality: total
  Visibility: public export
turn : State -> Nat
  Totality: total
  Visibility: public export
.inCS2 : State -> Bool
  Totality: total
  Visibility: public export
.inCS1 : State -> Bool
  Totality: total
  Visibility: public export
inCS2 : State -> Bool
  Totality: total
  Visibility: public export
inCS1 : State -> Bool
  Totality: total
  Visibility: public export
CS1 : GCL
  First critical section

  Totality: total
  Visibility: public export
CS2 : GCL
  Second critical section

  Totality: total
  Visibility: public export
petersons1 : GCL
  First Peterson's algorithm process

  Totality: total
  Visibility: public export
petersons2 : GCL
  Second Peterson's algorithm process

  Totality: total
  Visibility: public export
petersons : Diagram (GCL, GCL) State
  The parallel composition of the two Peterson's processes, to be
  model-checked.

  Totality: total
  Visibility: public export
IsTT : (b : Bool) -> Dec (So b)
  Type-level decider for booleans.

  Totality: total
  Visibility: public export
Mutex : Formula
  Mutual exclusion, i.e. both critical sections not simultaneously active.

  Totality: total
  Visibility: public export
checkMutex : MC Mutex
  Model-check (search) whether the mutex condition is satisfied.

  Totality: total
  Visibility: public export
SF : Formula
  Starvation freedom

  Totality: total
  Visibility: public export
checkSF : MC SF
  Model-check (search) whether starvation freedom holds.

  Totality: total
  Visibility: public export
Termination : Formula
  Deadlock freedom, aka. termination for all possible paths/traces

  Totality: total
  Visibility: public export
checkTermination : MC Termination
  Model-check (search) whether termination holds.

  Totality: total
  Visibility: public export
init : State
  Initial state for model-checking Peterson's algorithm.

  Totality: total
  Visibility: public export
tree : CT
  The computational tree for the two Peterson's processes.

  Totality: total
  Visibility: public export
CSP : Type
  The Critical Section Problem:
  1) a process's critical section (CS) is only ever accessed by that process
     and no other
  2) any process which wishes to gain access to its CS eventually
     does so
  3) the composition of the processes is deadlock free
     (we use a stronger requirement: that all process composition must
     terminate successfully)

  Totality: total
  Visibility: public export
checkPetersons : Prop (Nat :: Constraints) CSP
  A `Prop` (property) containing all the conditions necessary for proving that
  Peterson's Algorithm is a correct solution to the Critical Section Problem.
  When evaluated (e.g. through the `auto` search in a `Properties.check`
  call; specifically `runProp`), it will produce the required proof (which is
  **very** big).

  Totality: total
  Visibility: public export
dekkers1 : GCL
  First Dekker's algorithm process

  Totality: total
  Visibility: public export
dekkers2 : GCL
  First Dekker's algorithm process

  Totality: total
  Visibility: public export
dekkers : Diagram (GCL, GCL) State
  The parallel composition of the two Dekker's processes, to be model-checked.

  Totality: total
  Visibility: public export
checkDekkers : HDec (ExistsFinally ?f 100 (model dekkers init))
  An attempt at finding a violation of Mutual Exclusion.
  THIS WILL NOT FIND A PROOF due to the lack of fairness in the unfolding of
  the traces. Dekker's algorithm requires fair scheduling in order to be
  correct, but since we don't have that, we cannot find a proof that no
  violations of mutex exist.
  
  /!\ Trying to evaluate this did not finish after 10 minutes /!\

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Search.Generator.html b/papers/docs/Search.Generator.html
index 760d6fb2fb..e650e9deb6 100644
--- a/papers/docs/Search.Generator.html
+++ b/papers/docs/Search.Generator.html
@@ -71,4 +71,4 @@
 many duplicates when dealing with finite types which are common in
 programming (Bool) but even more so in dependently typed programming
 (Vect 0, Fin (S n), etc.).
-
Definitions
interface Generator : Type -> Type
  A generator for a given type is a non-empty colist of values of that
  type.

  Parameters: a
Methods:
  
generate : Colist1 a

Implementations:
  
Generator Nat
  
Generator Bool
  
Generator (Fin (S n))
  
Generator a => Generator (a, ())
  
(Generator a, Generator b) => Generator (a, b)
  
{0 b : a -> Type} -> (Generator a, (x : a) -> Generator (b x)) => Generator (x : a ** b x)
  
Generator a => Generator (Vect n a)
  
Generator a => Generator (List a)
generate : Generator a => Colist1 a
  Visibility: public export

\ No newline at end of file
+
Definitions
interface Generator : Type -> Type
  A generator for a given type is a non-empty colist of values of that
  type.

  Parameters: a
Methods:
  
generate : Colist1 a

Implementations:
  
Generator Nat
  
Generator Bool
  
Generator (Fin (S n))
  
Generator a => Generator (a, ())
  
(Generator a, Generator b) => Generator (a, b)
  
{0 b : a -> Type} -> (Generator a, (x : a) -> Generator (b x)) => Generator (x : a ** b x)
  
Generator a => Generator (Vect n a)
  
Generator a => Generator (List a)
generate : Generator a => Colist1 a
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Search.HDecidable.html b/papers/docs/Search.HDecidable.html
index 478ecc2e85..5187897b34 100644
--- a/papers/docs/Search.HDecidable.html
+++ b/papers/docs/Search.HDecidable.html
@@ -65,4 +65,4 @@
 Applications of Applicative Proof Search
 by Liam O'Connor
 https://doi.org/10.1145/2976022.2976030
-
Definitions
record HDec : Type -> Type
  Half a decider: when the search succeeds we bother building the proof

  Totality: total
  Visibility: public export
  Constructor: 
MkHDec : (isTrue : Bool) -> (So isTrue -> a) -> HDec a

  Projections:
  
.evidence : ({rec:0} : HDec a) -> So (isTrue {rec:0}) -> a
  
.isTrue : HDec a -> Bool

  Hints:
  
Alternative HDec
  
AnHDec HDec
  
Applicative HDec
  
Functor HDec
  
Monad HDec
  
Show f => Show (HDec f)
.isTrue : HDec a -> Bool
  Totality: total
  Visibility: public export
isTrue : HDec a -> Bool
  Totality: total
  Visibility: public export
.evidence : ({rec:0} : HDec a) -> So (isTrue {rec:0}) -> a
  Totality: total
  Visibility: public export
evidence : ({rec:0} : HDec a) -> So (isTrue {rec:0}) -> a
  Totality: total
  Visibility: public export
yes : a -> HDec a
  Happy path: we have found a proof!

  Totality: total
  Visibility: public export
no : HDec a
  Giving up

  Totality: total
  Visibility: public export
fromDec : Dec a -> HDec a
  Totality: total
  Visibility: public export
fromMaybe : Maybe a -> HDec a
  Totality: total
  Visibility: public export
toMaybe : HDec a -> Maybe a
  Totality: total
  Visibility: public export
interface AnHDec : (Type -> Type) -> Type
  A type constructor satisfying AnHdec is morally an HDec i.e. we can
  turn values of this type constructor into half deciders
  It may be more powerful (like Dec) or more basic (like Maybe).

  Parameters: t
Methods:
  
toHDec : t a -> HDec a

Implementations:
  
AnHDec Dec
  
AnHDec HDec
  
AnHDec Maybe
toHDec : AnHDec t => t a -> HDec a
  Totality: total
  Visibility: public export
(&&) : (AnHDec l, AnHDec r) => l a -> r b -> HDec (a, b)
  Half deciders are closed under product

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 5
(||) : (AnHDec l, AnHDec r) => l a -> r b -> HDec (Either a b)
  Half deciders are closed under sum

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 4
not : (AnHDec l, Negates na a) => l na -> HDec (Not a)
  Half deciders are closed negation. Here we use the `Negates` interface
  so that we end up looking for *positive* evidence of something which is
  much easier to find than negative one.

  Totality: total
  Visibility: public export
(==>) : (AnHDec l, (AnHDec r, Negates na a)) => l na -> r b -> HDec (a -> b)
  Half deciders are closed under implication

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 3
any : AnHDec l => (xs : List a) -> ((x : a) -> l (p x)) -> HDec (Any p xs)
  Half deciders are closed under the list quantifier any

  Totality: total
  Visibility: public export
all : AnHDec l => (xs : List a) -> ((x : a) -> l (p x)) -> HDec (All p xs)
  Half deciders are closed under the list quantifier all

  Totality: total
  Visibility: public export
any : AnHDec l => (xs : LazyList a) -> ((x : a) -> l (p x)) -> HDec (Any p xs)
  Half deciders are closed under the lazy list quantifier any

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
record HDec : Type -> Type
  Half a decider: when the search succeeds we bother building the proof

  Totality: total
  Visibility: public export
  Constructor: 
MkHDec : (isTrue : Bool) -> (So isTrue -> a) -> HDec a

  Projections:
  
.evidence : ({rec:0} : HDec a) -> So (isTrue {rec:0}) -> a
  
.isTrue : HDec a -> Bool

  Hints:
  
Alternative HDec
  
AnHDec HDec
  
Applicative HDec
  
Functor HDec
  
Monad HDec
  
Show f => Show (HDec f)
.isTrue : HDec a -> Bool
  Totality: total
  Visibility: public export
isTrue : HDec a -> Bool
  Totality: total
  Visibility: public export
.evidence : ({rec:0} : HDec a) -> So (isTrue {rec:0}) -> a
  Totality: total
  Visibility: public export
evidence : ({rec:0} : HDec a) -> So (isTrue {rec:0}) -> a
  Totality: total
  Visibility: public export
yes : a -> HDec a
  Happy path: we have found a proof!

  Totality: total
  Visibility: public export
no : HDec a
  Giving up

  Totality: total
  Visibility: public export
fromDec : Dec a -> HDec a
  Totality: total
  Visibility: public export
fromMaybe : Maybe a -> HDec a
  Totality: total
  Visibility: public export
toMaybe : HDec a -> Maybe a
  Totality: total
  Visibility: public export
interface AnHDec : (Type -> Type) -> Type
  A type constructor satisfying AnHdec is morally an HDec i.e. we can
  turn values of this type constructor into half deciders
  It may be more powerful (like Dec) or more basic (like Maybe).

  Parameters: t
Methods:
  
toHDec : t a -> HDec a

Implementations:
  
AnHDec Dec
  
AnHDec HDec
  
AnHDec Maybe
toHDec : AnHDec t => t a -> HDec a
  Totality: total
  Visibility: public export
(&&) : (AnHDec l, AnHDec r) => l a -> r b -> HDec (a, b)
  Half deciders are closed under product

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 5
(||) : (AnHDec l, AnHDec r) => l a -> r b -> HDec (Either a b)
  Half deciders are closed under sum

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 4
not : (AnHDec l, Negates na a) => l na -> HDec (Not a)
  Half deciders are closed negation. Here we use the `Negates` interface
  so that we end up looking for *positive* evidence of something which is
  much easier to find than negative one.

  Totality: total
  Visibility: public export
(==>) : (AnHDec l, (AnHDec r, Negates na a)) => l na -> r b -> HDec (a -> b)
  Half deciders are closed under implication

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 3
any : AnHDec l => (xs : List a) -> ((x : a) -> l (p x)) -> HDec (Any p xs)
  Half deciders are closed under the list quantifier any

  Totality: total
  Visibility: public export
all : AnHDec l => (xs : List a) -> ((x : a) -> l (p x)) -> HDec (All p xs)
  Half deciders are closed under the list quantifier all

  Totality: total
  Visibility: public export
any : AnHDec l => (xs : LazyList a) -> ((x : a) -> l (p x)) -> HDec (Any p xs)
  Half deciders are closed under the lazy list quantifier any

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Search.Negation.html b/papers/docs/Search.Negation.html
index 485be915a3..c6b5b73476 100644
--- a/papers/docs/Search.Negation.html
+++ b/papers/docs/Search.Negation.html
@@ -61,4 +61,4 @@
 
 
 
-
Search.Negation(source)
Definitions
interface Negates : Type -> Type -> Type
  It is much easier to look for positive evidence than it is to look
  for negative evidence. So instead of looking for `Not q`, we may
  want to look for `p` instead

  Parameters: p, q
Methods:
  
toNegation : p -> Not q

Implementations:
  
Negates (p x) (q x) => Negates (All p xs) (Any q xs)
  
Negates (p x) (q x) => Negates (Any p xs) (All q xs)
  
Negates (LT m n) (GTE m n)
  
Negates (LTE m n) (GT m n)
toNegation : Negates p q => p -> Not q
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Search.Negation(source)
Definitions
interface Negates : Type -> Type -> Type
  It is much easier to look for positive evidence than it is to look
  for negative evidence. So instead of looking for `Not q`, we may
  want to look for `p` instead

  Parameters: p, q
Methods:
  
toNegation : p -> Not q

Implementations:
  
Negates (p x) (q x) => Negates (All p xs) (Any q xs)
  
Negates (p x) (q x) => Negates (Any p xs) (All q xs)
  
Negates (LT m n) (GTE m n)
  
Negates (LTE m n) (GT m n)
toNegation : Negates p q => p -> Not q
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Search.Properties.html b/papers/docs/Search.Properties.html
index 331e560ba1..c2e0c4cfd0 100644
--- a/papers/docs/Search.Properties.html
+++ b/papers/docs/Search.Properties.html
@@ -65,4 +65,4 @@
 Applications of Applicative Proof Search
 by Liam O'Connor
 https://doi.org/10.1145/2976022.2976030
-
Reexports
import public Data.Stream
import public Data.Colist
import public Data.Colist1
import public Search.Negation
import public Search.HDecidable
import public Search.Generator
Definitions
Product : List Type -> Type
  Take the product of a list of types

  Totality: total
  Visibility: public export
record Prop : List Type -> Type -> Type
  A property amenable to testing
  @cs is the list of generators we need (inferrable)
  @a  is the type we hope is inhabited
  NB: the longer the list of generators, the bigger the search space!

  Totality: total
  Visibility: public export
  Constructor: 
MkProp : (Colist1 (Product cs) -> Fuel -> HDec a) -> Prop cs a

  Projection: 
.runProp : Prop cs a -> Colist1 (Product cs) -> Fuel -> HDec a
  The function trying to find an `a` provided generators for `cs`.
  Made total by consuming some fuel along the way.

  Hint: 
AProp (Prop cs)
.runProp : Prop cs a -> Colist1 (Product cs) -> Fuel -> HDec a
  The function trying to find an `a` provided generators for `cs`.
  Made total by consuming some fuel along the way.

  Totality: total
  Visibility: public export
runProp : Prop cs a -> Colist1 (Product cs) -> Fuel -> HDec a
  The function trying to find an `a` provided generators for `cs`.
  Made total by consuming some fuel along the way.

  Totality: total
  Visibility: public export
interface AProp : (Type -> Type) -> Type
  A type constructor satisfying the AProp interface is morally a Prop
  It may not make use of all of the powers granted by Prop, hence the
  associated `Constraints` list of types.

  Parameters: t
Methods:
  
0 Constraints : List Type
  
toProp : t a -> Prop Constraints a

Implementations:
  
AProp (Prop cs)
  
AProp HDec
  
AProp Dec
0 Constraints : AProp t => List Type
  Totality: total
  Visibility: public export
toProp : {auto __con : AProp t} -> t a -> Prop Constraints a
  Totality: total
  Visibility: public export
check : {auto gen : Generator (Product cs)} -> (f : Fuel) -> (p : Prop cs a) -> So (isTrue (runProp p generate f)) => a
  We can run an AProp to try to generate a value of type a

  Totality: total
  Visibility: public export
exists : {auto aPropt : AProp t} -> ((x : a) -> t (p x)) -> Prop (a :: Constraints) (DPair a p)
  Provided that we know how to generate candidates of type `a`, we can look
  for a witness satisfying a given predicate over `a`.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Reexports
import public Data.Stream
import public Data.Colist
import public Data.Colist1
import public Search.Negation
import public Search.HDecidable
import public Search.Generator
Definitions
Product : List Type -> Type
  Take the product of a list of types

  Totality: total
  Visibility: public export
record Prop : List Type -> Type -> Type
  A property amenable to testing
  @cs is the list of generators we need (inferrable)
  @a  is the type we hope is inhabited
  NB: the longer the list of generators, the bigger the search space!

  Totality: total
  Visibility: public export
  Constructor: 
MkProp : (Colist1 (Product cs) -> Fuel -> HDec a) -> Prop cs a

  Projection: 
.runProp : Prop cs a -> Colist1 (Product cs) -> Fuel -> HDec a
  The function trying to find an `a` provided generators for `cs`.
  Made total by consuming some fuel along the way.

  Hint: 
AProp (Prop cs)
.runProp : Prop cs a -> Colist1 (Product cs) -> Fuel -> HDec a
  The function trying to find an `a` provided generators for `cs`.
  Made total by consuming some fuel along the way.

  Totality: total
  Visibility: public export
runProp : Prop cs a -> Colist1 (Product cs) -> Fuel -> HDec a
  The function trying to find an `a` provided generators for `cs`.
  Made total by consuming some fuel along the way.

  Totality: total
  Visibility: public export
interface AProp : (Type -> Type) -> Type
  A type constructor satisfying the AProp interface is morally a Prop
  It may not make use of all of the powers granted by Prop, hence the
  associated `Constraints` list of types.

  Parameters: t
Methods:
  
0 Constraints : List Type
  
toProp : t a -> Prop Constraints a

Implementations:
  
AProp (Prop cs)
  
AProp HDec
  
AProp Dec
0 Constraints : AProp t => List Type
  Totality: total
  Visibility: public export
toProp : {auto __con : AProp t} -> t a -> Prop Constraints a
  Totality: total
  Visibility: public export
check : {auto gen : Generator (Product cs)} -> (f : Fuel) -> (p : Prop cs a) -> So (isTrue (runProp p generate f)) => a
  We can run an AProp to try to generate a value of type a

  Totality: total
  Visibility: public export
exists : {auto aPropt : AProp t} -> ((x : a) -> t (p x)) -> Prop (a :: Constraints) (DPair a p)
  Provided that we know how to generate candidates of type `a`, we can look
  for a witness satisfying a given predicate over `a`.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/papers/docs/Search.Tychonoff.PartI.html b/papers/docs/Search.Tychonoff.PartI.html
index 612938fe63..12c0318d41 100644
--- a/papers/docs/Search.Tychonoff.PartI.html
+++ b/papers/docs/Search.Tychonoff.PartI.html
@@ -65,4 +65,4 @@
 "Search over uniformly continuous decidable predicates on
 infinite collections of types"
 https://www.cs.bham.ac.uk/~txw467/tychonoff/
-
Definitions
dsc : Discrete x => (Nat -> x) -> (Nat -> x) -> NatInf
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Definitions
dsc : Discrete x => (Nat -> x) -> (Nat -> x) -> NatInf
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/papers/index.html b/papers/index.html
index 02ecb2c1d9..66ed02f66b 100644
--- a/papers/index.html
+++ b/papers/index.html
@@ -61,4 +61,4 @@
 
 
 
-
Package papers - Namespaces

\ No newline at end of file
+
Package papers - Namespaces

\ No newline at end of file
diff --git a/prelude/docs/Builtin.html b/prelude/docs/Builtin.html
index 734ff4a221..c03b26d45f 100644
--- a/prelude/docs/Builtin.html
+++ b/prelude/docs/Builtin.html
@@ -61,4 +61,4 @@
 
 
 
-
Builtin(source)
Definitions
assert_total : (1 _ : a) -> a
  Assert to the totality checker that the given expression will always
  terminate.
  
  The multiplicity of its argument is 1, so `assert_total` won't affect how
  many times variables are used. If you're not writing a linear function,
  this doesn't make a difference.
  
  Note: assert_total can reduce at compile time, if required for unification,
  which might mean that it's no longer guarded a subexpression. Therefore,
  it is best to use it around the smallest possible subexpression.

  Totality: total
  Visibility: public export
assert_smaller : (0 _ : a) -> (1 _ : b) -> b
  Assert to the totality checker that y is always structurally smaller than x
  (which is typically a pattern argument, and *must* be in normal form for
  this to work).
  
  The multiplicity of x is 0, so in a linear function, you can pass values to
  x even if they have already been used.
  The multiplicity of y is 1, so `assert_smaller` won't affect how many times
  its y argument is used.
  If you're not writing a linear function, the multiplicities don't make a
  difference.
  
  @ x the larger value (typically a pattern argument)
  @ y the smaller value (typically an argument to a recursive call)

  Totality: total
  Visibility: public export
data Unit : Type
  The canonical single-element type, also known as the trivially true
  proposition.

  Totality: total
  Visibility: public export
  Constructor: 
MkUnit : ()
  The trivial constructor for `()`.
data Pair : Type -> Type -> Type
  The non-dependent pair type, also known as conjunction.

  Totality: total
  Visibility: public export
  Constructor: 
MkPair : a -> b -> (a, b)
  A pair of elements.
  @ a the left element of the pair
  @ b the right element of the pair
fst : (a, b) -> a
  Return the first element of a pair.

  Totality: total
  Visibility: public export
snd : (a, b) -> b
  Return the second element of a pair.

  Totality: total
  Visibility: public export
swap : (a, b) -> (b, a)
  Swap the elements in a pair

  Totality: total
  Visibility: public export
data LPair : Type -> Type -> Type
  A pair type where each component is linear

  Totality: total
  Visibility: public export
  Constructor: 
(#) : (1 _ : a) -> (1 _ : b) -> LPair a b
  A linear pair of elements.
  If you take one copy of the linear pair apart
  then you only get one copy of its left and right elements.
  @ a the left element of the pair
  @ b the right element of the pair
record DPair : (a : Type) -> (a -> Type) -> Type
  Dependent pairs aid in the construction of dependent types by providing
  evidence that some value resides in the type.
  
  Formally, speaking, dependent pairs represent existential quantification -
  they consist of a witness for the existential claim and a proof that the
  property holds for it.
  
  @ a the value to place in the type.
  @ p the dependent type that requires the value.

  Totality: total
  Visibility: public export
  Constructor: 
MkDPair : (fst : a) -> p fst -> DPair a p

  Projections:
  
.fst : DPair a p -> a
  
.snd : ({rec:0} : DPair a p) -> p (fst {rec:0})
.fst : DPair a p -> a
  Totality: total
  Visibility: public export
fst : DPair a p -> a
  Totality: total
  Visibility: public export
.snd : ({rec:0} : DPair a p) -> p (fst {rec:0})
  Totality: total
  Visibility: public export
snd : ({rec:0} : DPair a p) -> p (fst {rec:0})
  Totality: total
  Visibility: public export
data Res : (a : Type) -> (a -> Type) -> Type
  A dependent variant of LPair, pairing a result value with a resource
  that depends on the result value

  Totality: total
  Visibility: public export
  Constructor: 
(#) : (val : a) -> (1 _ : t val) -> Res a t
data Void : Type
  The empty type, also known as the trivially false proposition.
  
  Use `void` or `absurd` to prove anything if you have a variable of type
  `Void` in scope.

  Totality: total
  Visibility: public export
data Equal : a -> b -> Type
  Totality: total
  Visibility: public export
  Constructor: 
Refl : x = x
(===) : a -> a -> Type
  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
(~=~) : a -> b -> Type
  Explicit heterogeneous ("John Major") equality.  Use this when Idris
  incorrectly chooses homogeneous equality for `(=)`.
  @ a the type of the left side
  @ b the type of the right side
  @ x the left side
  @ y the right side

  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
rewrite__impl : (0 p : (a -> Type)) -> (0 _ : x = y) -> (1 _ : p y) -> p x
  Perform substitution in a term according to some equality.
  
  Like `replace`, but with an explicit predicate, and applying the rewrite in
  the other direction, which puts it in a form usable by the `rewrite` tactic
  and term.

  Totality: total
  Visibility: public export
replace : {0 p : {_:423} -> Type} -> (0 _ : x = y) -> (1 _ : p x) -> p y
  Perform substitution in a term according to some equality.

  Totality: total
  Visibility: public export
sym : (0 _ : x = y) -> y = x
  Symmetry of propositional equality.

  Totality: total
  Visibility: public export
trans : (0 _ : a = b) -> (0 _ : b = c) -> a = c
  Transitivity of propositional equality.

  Totality: total
  Visibility: public export
mkDPairInjectiveFst : (a ** pa) = (b ** qb) -> a = b
  Injectivity of MkDPair (first components)

  Totality: total
  Visibility: export
mkDPairInjectiveSnd : (a ** pa) = (a ** qa) -> pa = qa
  Injectivity of MkDPair (snd components)

  Totality: total
  Visibility: export
believe_me : a -> b
  Subvert the type checker.  This function is abstract, so it will not reduce
  in the type checker.  Use it with care - it can result in segfaults or
  worse!

  Totality: total
  Visibility: public export
assert_linear : (1 _ : (a -> b)) -> (1 _ : a) -> b
  Assert to the usage checker that the given function uses its argument linearly.

  Totality: total
  Visibility: public export
idris_crash : String -> a
  Visibility: export
delay : a -> Lazy a
  Totality: total
  Visibility: public export
force : Lazy a -> a
  Totality: total
  Visibility: public export
interface FromString : Type -> Type
  Interface for types that can be constructed from string literals.

  Parameters: ty
Constructor: 
MkFromString

Methods:
  
fromString : String -> ty
  Conversion from String.

Implementation: 
FromString String
fromString : FromString ty => String -> ty
  Conversion from String.

  Totality: total
  Visibility: public export
defaultString : FromString String
  Totality: total
  Visibility: public export
interface FromChar : Type -> Type
  Interface for types that can be constructed from char literals.

  Parameters: ty
Constructor: 
MkFromChar

Methods:
  
fromChar : Char -> ty
  Conversion from Char.

Implementation: 
FromChar Char
fromChar : FromChar ty => Char -> ty
  Conversion from Char.

  Totality: total
  Visibility: public export
defaultChar : FromChar Char
  Totality: total
  Visibility: public export
interface FromDouble : Type -> Type
  Interface for types that can be constructed from double literals.

  Parameters: ty
Constructor: 
MkFromDouble

Methods:
  
fromDouble : Double -> ty
  Conversion from Double.

Implementation: 
FromDouble Double
fromDouble : FromDouble ty => Double -> ty
  Conversion from Double.

  Totality: total
  Visibility: public export
defaultDouble : FromDouble Double
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Builtin(source)
Definitions
assert_total : (1 _ : a) -> a
  Assert to the totality checker that the given expression will always
  terminate.
  
  The multiplicity of its argument is 1, so `assert_total` won't affect how
  many times variables are used. If you're not writing a linear function,
  this doesn't make a difference.
  
  Note: assert_total can reduce at compile time, if required for unification,
  which might mean that it's no longer guarded a subexpression. Therefore,
  it is best to use it around the smallest possible subexpression.

  Totality: total
  Visibility: public export
assert_smaller : (0 _ : a) -> (1 _ : b) -> b
  Assert to the totality checker that y is always structurally smaller than x
  (which is typically a pattern argument, and *must* be in normal form for
  this to work).
  
  The multiplicity of x is 0, so in a linear function, you can pass values to
  x even if they have already been used.
  The multiplicity of y is 1, so `assert_smaller` won't affect how many times
  its y argument is used.
  If you're not writing a linear function, the multiplicities don't make a
  difference.
  
  @ x the larger value (typically a pattern argument)
  @ y the smaller value (typically an argument to a recursive call)

  Totality: total
  Visibility: public export
data Unit : Type
  The canonical single-element type, also known as the trivially true
  proposition.

  Totality: total
  Visibility: public export
  Constructor: 
MkUnit : ()
  The trivial constructor for `()`.
data Pair : Type -> Type -> Type
  The non-dependent pair type, also known as conjunction.

  Totality: total
  Visibility: public export
  Constructor: 
MkPair : a -> b -> (a, b)
  A pair of elements.
  @ a the left element of the pair
  @ b the right element of the pair
fst : (a, b) -> a
  Return the first element of a pair.

  Totality: total
  Visibility: public export
snd : (a, b) -> b
  Return the second element of a pair.

  Totality: total
  Visibility: public export
swap : (a, b) -> (b, a)
  Swap the elements in a pair

  Totality: total
  Visibility: public export
data LPair : Type -> Type -> Type
  A pair type where each component is linear

  Totality: total
  Visibility: public export
  Constructor: 
(#) : (1 _ : a) -> (1 _ : b) -> LPair a b
  A linear pair of elements.
  If you take one copy of the linear pair apart
  then you only get one copy of its left and right elements.
  @ a the left element of the pair
  @ b the right element of the pair
record DPair : (a : Type) -> (a -> Type) -> Type
  Dependent pairs aid in the construction of dependent types by providing
  evidence that some value resides in the type.
  
  Formally, speaking, dependent pairs represent existential quantification -
  they consist of a witness for the existential claim and a proof that the
  property holds for it.
  
  @ a the value to place in the type.
  @ p the dependent type that requires the value.

  Totality: total
  Visibility: public export
  Constructor: 
MkDPair : (fst : a) -> p fst -> DPair a p

  Projections:
  
.fst : DPair a p -> a
  
.snd : ({rec:0} : DPair a p) -> p (fst {rec:0})
.fst : DPair a p -> a
  Totality: total
  Visibility: public export
fst : DPair a p -> a
  Totality: total
  Visibility: public export
.snd : ({rec:0} : DPair a p) -> p (fst {rec:0})
  Totality: total
  Visibility: public export
snd : ({rec:0} : DPair a p) -> p (fst {rec:0})
  Totality: total
  Visibility: public export
data Res : (a : Type) -> (a -> Type) -> Type
  A dependent variant of LPair, pairing a result value with a resource
  that depends on the result value

  Totality: total
  Visibility: public export
  Constructor: 
(#) : (val : a) -> (1 _ : t val) -> Res a t
data Void : Type
  The empty type, also known as the trivially false proposition.
  
  Use `void` or `absurd` to prove anything if you have a variable of type
  `Void` in scope.

  Totality: total
  Visibility: public export
data Equal : a -> b -> Type
  Totality: total
  Visibility: public export
  Constructor: 
Refl : x = x
(===) : a -> a -> Type
  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
(~=~) : a -> b -> Type
  Explicit heterogeneous ("John Major") equality.  Use this when Idris
  incorrectly chooses homogeneous equality for `(=)`.
  @ a the type of the left side
  @ b the type of the right side
  @ x the left side
  @ y the right side

  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
rewrite__impl : (0 p : (a -> Type)) -> (0 _ : x = y) -> (1 _ : p y) -> p x
  Perform substitution in a term according to some equality.
  
  Like `replace`, but with an explicit predicate, and applying the rewrite in
  the other direction, which puts it in a form usable by the `rewrite` tactic
  and term.

  Totality: total
  Visibility: public export
replace : {0 p : {_:423} -> Type} -> (0 _ : x = y) -> (1 _ : p x) -> p y
  Perform substitution in a term according to some equality.

  Totality: total
  Visibility: public export
sym : (0 _ : x = y) -> y = x
  Symmetry of propositional equality.

  Totality: total
  Visibility: public export
trans : (0 _ : a = b) -> (0 _ : b = c) -> a = c
  Transitivity of propositional equality.

  Totality: total
  Visibility: public export
mkDPairInjectiveFst : (a ** pa) = (b ** qb) -> a = b
  Injectivity of MkDPair (first components)

  Totality: total
  Visibility: export
mkDPairInjectiveSnd : (a ** pa) = (a ** qa) -> pa = qa
  Injectivity of MkDPair (snd components)

  Totality: total
  Visibility: export
believe_me : a -> b
  Subvert the type checker.  This function is abstract, so it will not reduce
  in the type checker.  Use it with care - it can result in segfaults or
  worse!

  Totality: total
  Visibility: public export
assert_linear : (1 _ : (a -> b)) -> (1 _ : a) -> b
  Assert to the usage checker that the given function uses its argument linearly.

  Totality: total
  Visibility: public export
idris_crash : String -> a
  Visibility: export
delay : a -> Lazy a
  Totality: total
  Visibility: public export
force : Lazy a -> a
  Totality: total
  Visibility: public export
interface FromString : Type -> Type
  Interface for types that can be constructed from string literals.

  Parameters: ty
Constructor: 
MkFromString

Methods:
  
fromString : String -> ty
  Conversion from String.

Implementation: 
FromString String
fromString : FromString ty => String -> ty
  Conversion from String.

  Totality: total
  Visibility: public export
defaultString : FromString String
  Totality: total
  Visibility: public export
interface FromChar : Type -> Type
  Interface for types that can be constructed from char literals.

  Parameters: ty
Constructor: 
MkFromChar

Methods:
  
fromChar : Char -> ty
  Conversion from Char.

Implementation: 
FromChar Char
fromChar : FromChar ty => Char -> ty
  Conversion from Char.

  Totality: total
  Visibility: public export
defaultChar : FromChar Char
  Totality: total
  Visibility: public export
interface FromDouble : Type -> Type
  Interface for types that can be constructed from double literals.

  Parameters: ty
Constructor: 
MkFromDouble

Methods:
  
fromDouble : Double -> ty
  Conversion from Double.

Implementation: 
FromDouble Double
fromDouble : FromDouble ty => Double -> ty
  Conversion from Double.

  Totality: total
  Visibility: public export
defaultDouble : FromDouble Double
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/prelude/docs/Prelude.Basics.html b/prelude/docs/Prelude.Basics.html
index c233b33f25..05bc63cd20 100644
--- a/prelude/docs/Prelude.Basics.html
+++ b/prelude/docs/Prelude.Basics.html
@@ -61,4 +61,4 @@
 
 
 
-
Prelude.Basics(source)
Definitions
Not : Type -> Type
  `Not x` is an alias for `x -> Void`, indicating that any term of type `x`
  leads to a contradiction. It can be used in conjunction with `void` or
  `absurd`.

  Totality: total
  Visibility: public export
the : (0 a : Type) -> a -> a
  Manually assign a type to an expression.
  @ a the type to assign
  @ x the element to get the type

  Totality: total
  Visibility: public export
id : a -> a
  Identity function.

  Totality: total
  Visibility: public export
dup : a -> (a, a)
  Function that duplicates its input

  Totality: total
  Visibility: public export
const : a -> b -> a
  Constant function.  Ignores its second argument.

  Totality: total
  Visibility: public export
(.) : (b -> c) -> (a -> b) -> a -> c
  Function composition.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 9
(.:) : (c -> d) -> (a -> b -> c) -> a -> b -> d
  Composition of a two-argument function with a single-argument one.
  `(.:)` is like `(.)` but the second argument and the result are two-argument functions.
  This operator is also known as "blackbird operator".

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 9
on : (b -> b -> c) -> (a -> b) -> a -> a -> c
  `on b u x y` runs the binary function b on the results of applying
  unary function u to two arguments x and y. From the opposite perspective,
  it transforms two inputs and combines the outputs.
  
  ```idris example
  ((+) `on` f) x y = f x + f y
  ```
  
  Typical usage:
  
  ```idris example
  sortBy (compare `on` fst).
  ```

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 0
flip : (a -> b -> c) -> b -> a -> c
  Takes in the first two arguments in reverse order.
  @ f the function to flip

  Totality: total
  Visibility: public export
apply : (a -> b) -> a -> b
  Function application.

  Totality: total
  Visibility: public export
curry : ((a, b) -> c) -> a -> b -> c
  Totality: total
  Visibility: public export
uncurry : (a -> b -> c) -> (a, b) -> c
  Totality: total
  Visibility: public export
($) : {0 b : a -> Type} -> ((x : a) -> b x) -> (x : a) -> b x
  ($) is compiled specially to shortcut any tricky unification issues, but if
  it did have a type this is what it would be, and it might be useful to
  use directly sometimes (e.g. in higher order functions)

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 0
cong : (0 f : (t -> u)) -> (0 _ : a = b) -> f a = f b
  Equality is a congruence.

  Totality: total
  Visibility: public export
cong2 : (0 f : (t1 -> t2 -> u)) -> (0 _ : a = b) -> (0 _ : c = d) -> f a c = f b d
  Two-holed congruence.

  Totality: total
  Visibility: export
depCong : {0 p : a -> Type} -> (0 f : ((x : a) -> p x)) -> x1 = x2 -> f x1 = f x2
  Dependent version of `cong`.

  Totality: total
  Visibility: public export
depCong2 : {0 p : a -> Type} -> {0 q : (x : a) -> p x -> Type} -> (0 f : ((x : a) -> (y : p x) -> q x y)) -> x1 = x2 -> y1 = y2 -> f x1 y1 = f x2 y2
  Dependent version of `cong2`.

  Totality: total
  Visibility: public export
irrelevantEq : (0 _ : a = b) -> a = b
  Irrelevant equalities can always be made relevant

  Totality: total
  Visibility: export
data Bool : Type
  Boolean Data Type.

  Totality: total
  Visibility: public export
  Constructors:
  
False : Bool
  
True : Bool

  Hints:
  
Eq Bool
  
Ord Bool
  
Show Bool
  
Uninhabited (True = False)
  
Uninhabited (False = True)
not : Bool -> Bool
  Boolean NOT.

  Totality: total
  Visibility: public export
(&&) : Bool -> Lazy Bool -> Bool
  Boolean AND only evaluates the second argument if the first is `True`.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 5
(||) : Bool -> Lazy Bool -> Bool
  Boolean OR only evaluates the second argument if the first is `False`.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 4
ifThenElse : Bool -> Lazy a -> Lazy a -> a
  Non-dependent if-then-else

  Totality: total
  Visibility: public export
intToBool : Int -> Bool
  Totality: total
  Visibility: public export
data List : Type -> Type
  Generic lists.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : List a
  Empty list
  
(::) : a -> List a -> List a
  A non-empty list, consisting of a head element and the rest of the list.

  Hints:
  
Alternative List
  
Applicative List
  
Eq a => Eq (List a)
  
Foldable List
  
Functor List
  
Monad List
  
Monoid (List a)
  
Ord a => Ord (List a)
  
Semigroup (List a)
  
Show a => Show (List a)
  
Traversable List
data SnocList : Type -> Type
  Snoc lists.

  Totality: total
  Visibility: public export
  Constructors:
  
Lin : SnocList a
  Empty snoc-list
  
(:<) : SnocList a -> a -> SnocList a
  A non-empty snoc-list, consisting of the rest of the snoc-list and the final element.

  Hints:
  
Eq a => Eq (SnocList a)
  
Ord a => Ord (SnocList a)

\ No newline at end of file
+
Prelude.Basics(source)
Definitions
Not : Type -> Type
  `Not x` is an alias for `x -> Void`, indicating that any term of type `x`
  leads to a contradiction. It can be used in conjunction with `void` or
  `absurd`.

  Totality: total
  Visibility: public export
the : (0 a : Type) -> a -> a
  Manually assign a type to an expression.
  @ a the type to assign
  @ x the element to get the type

  Totality: total
  Visibility: public export
id : a -> a
  Identity function.

  Totality: total
  Visibility: public export
dup : a -> (a, a)
  Function that duplicates its input

  Totality: total
  Visibility: public export
const : a -> b -> a
  Constant function.  Ignores its second argument.

  Totality: total
  Visibility: public export
(.) : (b -> c) -> (a -> b) -> a -> c
  Function composition.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 9
(.:) : (c -> d) -> (a -> b -> c) -> a -> b -> d
  Composition of a two-argument function with a single-argument one.
  `(.:)` is like `(.)` but the second argument and the result are two-argument functions.
  This operator is also known as "blackbird operator".

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 9
on : (b -> b -> c) -> (a -> b) -> a -> a -> c
  `on b u x y` runs the binary function b on the results of applying
  unary function u to two arguments x and y. From the opposite perspective,
  it transforms two inputs and combines the outputs.
  
  ```idris example
  ((+) `on` f) x y = f x + f y
  ```
  
  Typical usage:
  
  ```idris example
  sortBy (compare `on` fst).
  ```

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 0
flip : (a -> b -> c) -> b -> a -> c
  Takes in the first two arguments in reverse order.
  @ f the function to flip

  Totality: total
  Visibility: public export
apply : (a -> b) -> a -> b
  Function application.

  Totality: total
  Visibility: public export
curry : ((a, b) -> c) -> a -> b -> c
  Totality: total
  Visibility: public export
uncurry : (a -> b -> c) -> (a, b) -> c
  Totality: total
  Visibility: public export
($) : {0 b : a -> Type} -> ((x : a) -> b x) -> (x : a) -> b x
  ($) is compiled specially to shortcut any tricky unification issues, but if
  it did have a type this is what it would be, and it might be useful to
  use directly sometimes (e.g. in higher order functions)

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 0
cong : (0 f : (t -> u)) -> (0 _ : a = b) -> f a = f b
  Equality is a congruence.

  Totality: total
  Visibility: public export
cong2 : (0 f : (t1 -> t2 -> u)) -> (0 _ : a = b) -> (0 _ : c = d) -> f a c = f b d
  Two-holed congruence.

  Totality: total
  Visibility: export
depCong : {0 p : a -> Type} -> (0 f : ((x : a) -> p x)) -> x1 = x2 -> f x1 = f x2
  Dependent version of `cong`.

  Totality: total
  Visibility: public export
depCong2 : {0 p : a -> Type} -> {0 q : (x : a) -> p x -> Type} -> (0 f : ((x : a) -> (y : p x) -> q x y)) -> x1 = x2 -> y1 = y2 -> f x1 y1 = f x2 y2
  Dependent version of `cong2`.

  Totality: total
  Visibility: public export
irrelevantEq : (0 _ : a = b) -> a = b
  Irrelevant equalities can always be made relevant

  Totality: total
  Visibility: export
data Bool : Type
  Boolean Data Type.

  Totality: total
  Visibility: public export
  Constructors:
  
False : Bool
  
True : Bool

  Hints:
  
Eq Bool
  
Ord Bool
  
Show Bool
  
Uninhabited (True = False)
  
Uninhabited (False = True)
not : Bool -> Bool
  Boolean NOT.

  Totality: total
  Visibility: public export
(&&) : Bool -> Lazy Bool -> Bool
  Boolean AND only evaluates the second argument if the first is `True`.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 5
(||) : Bool -> Lazy Bool -> Bool
  Boolean OR only evaluates the second argument if the first is `False`.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 4
ifThenElse : Bool -> Lazy a -> Lazy a -> a
  Non-dependent if-then-else

  Totality: total
  Visibility: public export
intToBool : Int -> Bool
  Totality: total
  Visibility: public export
data List : Type -> Type
  Generic lists.

  Totality: total
  Visibility: public export
  Constructors:
  
Nil : List a
  Empty list
  
(::) : a -> List a -> List a
  A non-empty list, consisting of a head element and the rest of the list.

  Hints:
  
Alternative List
  
Applicative List
  
Eq a => Eq (List a)
  
Foldable List
  
Functor List
  
Monad List
  
Monoid (List a)
  
Ord a => Ord (List a)
  
Semigroup (List a)
  
Show a => Show (List a)
  
Traversable List
data SnocList : Type -> Type
  Snoc lists.

  Totality: total
  Visibility: public export
  Constructors:
  
Lin : SnocList a
  Empty snoc-list
  
(:<) : SnocList a -> a -> SnocList a
  A non-empty snoc-list, consisting of the rest of the snoc-list and the final element.

  Hints:
  
Eq a => Eq (SnocList a)
  
Ord a => Ord (SnocList a)

\ No newline at end of file
diff --git a/prelude/docs/Prelude.Cast.html b/prelude/docs/Prelude.Cast.html
index 9ef6a6a038..169556e713 100644
--- a/prelude/docs/Prelude.Cast.html
+++ b/prelude/docs/Prelude.Cast.html
@@ -61,4 +61,4 @@
 
 
 
-
Prelude.Cast(source)
Definitions
interface Cast : Type -> Type -> Type
  Interface for transforming an instance of a data type to another type.

  Parameters: from, to
Constructor: 
MkCast

Methods:
  
cast : from -> to
  Perform a (potentially lossy!) cast operation.
  @ orig The original type

Implementations:
  
Cast a a
  
Cast Int String
  
Cast Integer String
  
Cast Char String
  
Cast Double String
  
Cast Nat String
  
Cast Int8 String
  
Cast Int16 String
  
Cast Int32 String
  
Cast Int64 String
  
Cast Bits8 String
  
Cast Bits16 String
  
Cast Bits32 String
  
Cast Bits64 String
  
Cast Int Integer
  
Cast Char Integer
  
Cast Double Integer
  
Cast String Integer
  
Cast Nat Integer
  
Cast Bits8 Integer
  
Cast Bits16 Integer
  
Cast Bits32 Integer
  
Cast Bits64 Integer
  
Cast Int8 Integer
  
Cast Int16 Integer
  
Cast Int32 Integer
  
Cast Int64 Integer
  
Cast Integer Int
  
Cast Char Int
  
Cast Double Int
  
Cast String Int
  
Cast Nat Int
  
Cast Bits8 Int
  
Cast Bits16 Int
  
Cast Bits32 Int
  
Cast Bits64 Int
  
Cast Int8 Int
  
Cast Int16 Int
  
Cast Int32 Int
  
Cast Int64 Int
  
Cast Int Char
  
Cast Integer Char
  
Cast Nat Char
  
Cast Bits8 Char
  
Cast Bits16 Char
  
Cast Bits32 Char
  
Cast Bits64 Char
  
Cast Int8 Char
  
Cast Int16 Char
  
Cast Int32 Char
  
Cast Int64 Char
  
Cast Int Double
  
Cast Integer Double
  
Cast String Double
  
Cast Nat Double
  
Cast Bits8 Double
  
Cast Bits16 Double
  
Cast Bits32 Double
  
Cast Bits64 Double
  
Cast Int8 Double
  
Cast Int16 Double
  
Cast Int32 Double
  
Cast Int64 Double
  
Cast Int Bits8
  
Cast Integer Bits8
  
Cast Bits16 Bits8
  
Cast Bits32 Bits8
  
Cast Bits64 Bits8
  
Cast String Bits8
  
Cast Double Bits8
  
Cast Char Bits8
  
Cast Nat Bits8
  
Cast Int8 Bits8
  
Cast Int16 Bits8
  
Cast Int32 Bits8
  
Cast Int64 Bits8
  
Cast Int Bits16
  
Cast Integer Bits16
  
Cast Bits8 Bits16
  
Cast Bits32 Bits16
  
Cast Bits64 Bits16
  
Cast String Bits16
  
Cast Double Bits16
  
Cast Char Bits16
  
Cast Nat Bits16
  
Cast Int8 Bits16
  
Cast Int16 Bits16
  
Cast Int32 Bits16
  
Cast Int64 Bits16
  
Cast Int Bits32
  
Cast Integer Bits32
  
Cast Bits8 Bits32
  
Cast Bits16 Bits32
  
Cast Bits64 Bits32
  
Cast String Bits32
  
Cast Double Bits32
  
Cast Char Bits32
  
Cast Nat Bits32
  
Cast Int8 Bits32
  
Cast Int16 Bits32
  
Cast Int32 Bits32
  
Cast Int64 Bits32
  
Cast Int Bits64
  
Cast Integer Bits64
  
Cast Bits8 Bits64
  
Cast Bits16 Bits64
  
Cast Bits32 Bits64
  
Cast String Bits64
  
Cast Double Bits64
  
Cast Char Bits64
  
Cast Nat Bits64
  
Cast Int8 Bits64
  
Cast Int16 Bits64
  
Cast Int32 Bits64
  
Cast Int64 Bits64
  
Cast String Int8
  
Cast Double Int8
  
Cast Char Int8
  
Cast Int Int8
  
Cast Integer Int8
  
Cast Nat Int8
  
Cast Bits8 Int8
  
Cast Bits16 Int8
  
Cast Bits32 Int8
  
Cast Bits64 Int8
  
Cast Int16 Int8
  
Cast Int32 Int8
  
Cast Int64 Int8
  
Cast String Int16
  
Cast Double Int16
  
Cast Char Int16
  
Cast Int Int16
  
Cast Integer Int16
  
Cast Nat Int16
  
Cast Bits8 Int16
  
Cast Bits16 Int16
  
Cast Bits32 Int16
  
Cast Bits64 Int16
  
Cast Int8 Int16
  
Cast Int32 Int16
  
Cast Int64 Int16
  
Cast String Int32
  
Cast Double Int32
  
Cast Char Int32
  
Cast Int Int32
  
Cast Integer Int32
  
Cast Nat Int32
  
Cast Bits8 Int32
  
Cast Bits16 Int32
  
Cast Bits32 Int32
  
Cast Bits64 Int32
  
Cast Int8 Int32
  
Cast Int16 Int32
  
Cast Int64 Int32
  
Cast String Int64
  
Cast Double Int64
  
Cast Char Int64
  
Cast Int Int64
  
Cast Integer Int64
  
Cast Nat Int64
  
Cast Bits8 Int64
  
Cast Bits16 Int64
  
Cast Bits32 Int64
  
Cast Bits64 Int64
  
Cast Int8 Int64
  
Cast Int16 Int64
  
Cast Int32 Int64
  
Cast String Nat
  
Cast Double Nat
  
Cast Char Nat
  
Cast Int Nat
  
Cast Integer Nat
  
Cast Bits8 Nat
  
Cast Bits16 Nat
  
Cast Bits32 Nat
  
Cast Bits64 Nat
  
Cast Int8 Nat
  
Cast Int16 Nat
  
Cast Int32 Nat
  
Cast Int64 Nat
cast : Cast from to => from -> to
  Perform a (potentially lossy!) cast operation.
  @ orig The original type

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Prelude.Cast(source)
Definitions
interface Cast : Type -> Type -> Type
  Interface for transforming an instance of a data type to another type.

  Parameters: from, to
Constructor: 
MkCast

Methods:
  
cast : from -> to
  Perform a (potentially lossy!) cast operation.
  @ orig The original type

Implementations:
  
Cast a a
  
Cast Int String
  
Cast Integer String
  
Cast Char String
  
Cast Double String
  
Cast Nat String
  
Cast Int8 String
  
Cast Int16 String
  
Cast Int32 String
  
Cast Int64 String
  
Cast Bits8 String
  
Cast Bits16 String
  
Cast Bits32 String
  
Cast Bits64 String
  
Cast Int Integer
  
Cast Char Integer
  
Cast Double Integer
  
Cast String Integer
  
Cast Nat Integer
  
Cast Bits8 Integer
  
Cast Bits16 Integer
  
Cast Bits32 Integer
  
Cast Bits64 Integer
  
Cast Int8 Integer
  
Cast Int16 Integer
  
Cast Int32 Integer
  
Cast Int64 Integer
  
Cast Integer Int
  
Cast Char Int
  
Cast Double Int
  
Cast String Int
  
Cast Nat Int
  
Cast Bits8 Int
  
Cast Bits16 Int
  
Cast Bits32 Int
  
Cast Bits64 Int
  
Cast Int8 Int
  
Cast Int16 Int
  
Cast Int32 Int
  
Cast Int64 Int
  
Cast Int Char
  
Cast Integer Char
  
Cast Nat Char
  
Cast Bits8 Char
  
Cast Bits16 Char
  
Cast Bits32 Char
  
Cast Bits64 Char
  
Cast Int8 Char
  
Cast Int16 Char
  
Cast Int32 Char
  
Cast Int64 Char
  
Cast Int Double
  
Cast Integer Double
  
Cast String Double
  
Cast Nat Double
  
Cast Bits8 Double
  
Cast Bits16 Double
  
Cast Bits32 Double
  
Cast Bits64 Double
  
Cast Int8 Double
  
Cast Int16 Double
  
Cast Int32 Double
  
Cast Int64 Double
  
Cast Int Bits8
  
Cast Integer Bits8
  
Cast Bits16 Bits8
  
Cast Bits32 Bits8
  
Cast Bits64 Bits8
  
Cast String Bits8
  
Cast Double Bits8
  
Cast Char Bits8
  
Cast Nat Bits8
  
Cast Int8 Bits8
  
Cast Int16 Bits8
  
Cast Int32 Bits8
  
Cast Int64 Bits8
  
Cast Int Bits16
  
Cast Integer Bits16
  
Cast Bits8 Bits16
  
Cast Bits32 Bits16
  
Cast Bits64 Bits16
  
Cast String Bits16
  
Cast Double Bits16
  
Cast Char Bits16
  
Cast Nat Bits16
  
Cast Int8 Bits16
  
Cast Int16 Bits16
  
Cast Int32 Bits16
  
Cast Int64 Bits16
  
Cast Int Bits32
  
Cast Integer Bits32
  
Cast Bits8 Bits32
  
Cast Bits16 Bits32
  
Cast Bits64 Bits32
  
Cast String Bits32
  
Cast Double Bits32
  
Cast Char Bits32
  
Cast Nat Bits32
  
Cast Int8 Bits32
  
Cast Int16 Bits32
  
Cast Int32 Bits32
  
Cast Int64 Bits32
  
Cast Int Bits64
  
Cast Integer Bits64
  
Cast Bits8 Bits64
  
Cast Bits16 Bits64
  
Cast Bits32 Bits64
  
Cast String Bits64
  
Cast Double Bits64
  
Cast Char Bits64
  
Cast Nat Bits64
  
Cast Int8 Bits64
  
Cast Int16 Bits64
  
Cast Int32 Bits64
  
Cast Int64 Bits64
  
Cast String Int8
  
Cast Double Int8
  
Cast Char Int8
  
Cast Int Int8
  
Cast Integer Int8
  
Cast Nat Int8
  
Cast Bits8 Int8
  
Cast Bits16 Int8
  
Cast Bits32 Int8
  
Cast Bits64 Int8
  
Cast Int16 Int8
  
Cast Int32 Int8
  
Cast Int64 Int8
  
Cast String Int16
  
Cast Double Int16
  
Cast Char Int16
  
Cast Int Int16
  
Cast Integer Int16
  
Cast Nat Int16
  
Cast Bits8 Int16
  
Cast Bits16 Int16
  
Cast Bits32 Int16
  
Cast Bits64 Int16
  
Cast Int8 Int16
  
Cast Int32 Int16
  
Cast Int64 Int16
  
Cast String Int32
  
Cast Double Int32
  
Cast Char Int32
  
Cast Int Int32
  
Cast Integer Int32
  
Cast Nat Int32
  
Cast Bits8 Int32
  
Cast Bits16 Int32
  
Cast Bits32 Int32
  
Cast Bits64 Int32
  
Cast Int8 Int32
  
Cast Int16 Int32
  
Cast Int64 Int32
  
Cast String Int64
  
Cast Double Int64
  
Cast Char Int64
  
Cast Int Int64
  
Cast Integer Int64
  
Cast Nat Int64
  
Cast Bits8 Int64
  
Cast Bits16 Int64
  
Cast Bits32 Int64
  
Cast Bits64 Int64
  
Cast Int8 Int64
  
Cast Int16 Int64
  
Cast Int32 Int64
  
Cast String Nat
  
Cast Double Nat
  
Cast Char Nat
  
Cast Int Nat
  
Cast Integer Nat
  
Cast Bits8 Nat
  
Cast Bits16 Nat
  
Cast Bits32 Nat
  
Cast Bits64 Nat
  
Cast Int8 Nat
  
Cast Int16 Nat
  
Cast Int32 Nat
  
Cast Int64 Nat
cast : Cast from to => from -> to
  Perform a (potentially lossy!) cast operation.
  @ orig The original type

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/prelude/docs/Prelude.EqOrd.html b/prelude/docs/Prelude.EqOrd.html
index 8edadf9009..2389de7993 100644
--- a/prelude/docs/Prelude.EqOrd.html
+++ b/prelude/docs/Prelude.EqOrd.html
@@ -61,4 +61,4 @@
 
 
 
-
Prelude.EqOrd(source)
Definitions
interface Eq : Type -> Type
  The Eq interface defines inequality and equality.
  A minimal definition includes either `(==)` or `(/=)`.

  Parameters: ty
Constructor: 
MkEq

Methods:
  
(==) : ty -> ty -> Bool
  Fixity Declaration: infix operator, level 6
  
(/=) : ty -> ty -> Bool
  Fixity Declaration: infix operator, level 6

Implementations:
  
Eq Prec
  
Eq Void
  
Eq ()
  
Eq Bool
  
Eq Int
  
Eq Integer
  
Eq Bits8
  
Eq Bits16
  
Eq Bits32
  
Eq Bits64
  
Eq Int8
  
Eq Int16
  
Eq Int32
  
Eq Int64
  
Eq Double
  
Eq Char
  
Eq String
  
Eq a => Eq b => Eq (a, b)
  
Eq Ordering
  
Eq Nat
  
Eq a => Eq (Maybe a)
  
(Eq a, Eq b) => Eq (Either a b)
  
Eq a => Eq (List a)
  
Eq a => Eq (SnocList a)
(==) : Eq ty => ty -> ty -> Bool
  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
(/=) : Eq ty => ty -> ty -> Bool
  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
data Ordering : Type
  Totality: total
  Visibility: public export
  Constructors:
  
LT : Ordering
  
EQ : Ordering
  
GT : Ordering

  Hints:
  
Eq Ordering
  
Monoid Ordering
  
Semigroup Ordering
  
Show Ordering
contra : Ordering -> Ordering
  Totality: total
  Visibility: public export
interface Ord : Type -> Type
  The Ord interface defines comparison operations on ordered data types.
  A minimal definition includes either `compare` or `(<)`.

  Parameters: ty
Constraints: Eq ty
Constructor: 
MkOrd

Methods:
  
compare : ty -> ty -> Ordering
  
(<) : ty -> ty -> Bool
  Fixity Declaration: infix operator, level 6
  
(>) : ty -> ty -> Bool
  Fixity Declaration: infix operator, level 6
  
(<=) : ty -> ty -> Bool
  Fixity Declaration: infix operator, level 6
  
(>=) : ty -> ty -> Bool
  Fixity Declaration: infix operator, level 6
  
max : ty -> ty -> ty
  
min : ty -> ty -> ty

Implementations:
  
Ord Prec
  
Ord Void
  
Ord ()
  
Ord Bool
  
Ord Int
  
Ord Integer
  
Ord Bits8
  
Ord Bits16
  
Ord Bits32
  
Ord Bits64
  
Ord Int8
  
Ord Int16
  
Ord Int32
  
Ord Int64
  
Ord Double
  
Ord String
  
Ord Char
  
Ord a => Ord b => Ord (a, b)
  
Ord Nat
  
Ord a => Ord (Maybe a)
  
(Ord a, Ord b) => Ord (Either a b)
  
Ord a => Ord (List a)
  
Ord a => Ord (SnocList a)
compare : Ord ty => ty -> ty -> Ordering
  Totality: total
  Visibility: public export
(<) : Ord ty => ty -> ty -> Bool
  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
(>) : Ord ty => ty -> ty -> Bool
  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
(<=) : Ord ty => ty -> ty -> Bool
  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
(>=) : Ord ty => ty -> ty -> Bool
  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
max : Ord ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
min : Ord ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
comparing : Ord a => (b -> a) -> b -> b -> Ordering
  Totality: total
  Visibility: export
compareInteger : Integer -> Integer -> Ordering
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Prelude.EqOrd(source)
Definitions
interface Eq : Type -> Type
  The Eq interface defines inequality and equality.
  A minimal definition includes either `(==)` or `(/=)`.

  Parameters: ty
Constructor: 
MkEq

Methods:
  
(==) : ty -> ty -> Bool
  Fixity Declaration: infix operator, level 6
  
(/=) : ty -> ty -> Bool
  Fixity Declaration: infix operator, level 6

Implementations:
  
Eq Prec
  
Eq Void
  
Eq ()
  
Eq Bool
  
Eq Int
  
Eq Integer
  
Eq Bits8
  
Eq Bits16
  
Eq Bits32
  
Eq Bits64
  
Eq Int8
  
Eq Int16
  
Eq Int32
  
Eq Int64
  
Eq Double
  
Eq Char
  
Eq String
  
Eq a => Eq b => Eq (a, b)
  
Eq Ordering
  
Eq Nat
  
Eq a => Eq (Maybe a)
  
(Eq a, Eq b) => Eq (Either a b)
  
Eq a => Eq (List a)
  
Eq a => Eq (SnocList a)
(==) : Eq ty => ty -> ty -> Bool
  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
(/=) : Eq ty => ty -> ty -> Bool
  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
data Ordering : Type
  Totality: total
  Visibility: public export
  Constructors:
  
LT : Ordering
  
EQ : Ordering
  
GT : Ordering

  Hints:
  
Eq Ordering
  
Monoid Ordering
  
Semigroup Ordering
  
Show Ordering
contra : Ordering -> Ordering
  Totality: total
  Visibility: public export
interface Ord : Type -> Type
  The Ord interface defines comparison operations on ordered data types.
  A minimal definition includes either `compare` or `(<)`.

  Parameters: ty
Constraints: Eq ty
Constructor: 
MkOrd

Methods:
  
compare : ty -> ty -> Ordering
  
(<) : ty -> ty -> Bool
  Fixity Declaration: infix operator, level 6
  
(>) : ty -> ty -> Bool
  Fixity Declaration: infix operator, level 6
  
(<=) : ty -> ty -> Bool
  Fixity Declaration: infix operator, level 6
  
(>=) : ty -> ty -> Bool
  Fixity Declaration: infix operator, level 6
  
max : ty -> ty -> ty
  
min : ty -> ty -> ty

Implementations:
  
Ord Prec
  
Ord Void
  
Ord ()
  
Ord Bool
  
Ord Int
  
Ord Integer
  
Ord Bits8
  
Ord Bits16
  
Ord Bits32
  
Ord Bits64
  
Ord Int8
  
Ord Int16
  
Ord Int32
  
Ord Int64
  
Ord Double
  
Ord String
  
Ord Char
  
Ord a => Ord b => Ord (a, b)
  
Ord Nat
  
Ord a => Ord (Maybe a)
  
(Ord a, Ord b) => Ord (Either a b)
  
Ord a => Ord (List a)
  
Ord a => Ord (SnocList a)
compare : Ord ty => ty -> ty -> Ordering
  Totality: total
  Visibility: public export
(<) : Ord ty => ty -> ty -> Bool
  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
(>) : Ord ty => ty -> ty -> Bool
  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
(<=) : Ord ty => ty -> ty -> Bool
  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
(>=) : Ord ty => ty -> ty -> Bool
  Totality: total
  Visibility: public export
  Fixity Declaration: infix operator, level 6
max : Ord ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
min : Ord ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
comparing : Ord a => (b -> a) -> b -> b -> Ordering
  Totality: total
  Visibility: export
compareInteger : Integer -> Integer -> Ordering
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/prelude/docs/Prelude.IO.html b/prelude/docs/Prelude.IO.html
index 6554c1f708..9059dcea0d 100644
--- a/prelude/docs/Prelude.IO.html
+++ b/prelude/docs/Prelude.IO.html
@@ -61,4 +61,4 @@
 
 
 
-
Prelude.IO(source)
Definitions
interface HasIO : (Type -> Type) -> Type
  Parameters: io
Constraints: Monad io
Constructor: 
MkHasIO

Methods:
  
liftIO : IO a -> io a

Implementation: 
HasLinearIO io => HasIO io
liftIO : HasIO io => IO a -> io a
  Totality: total
  Visibility: public export
interface HasLinearIO : (Type -> Type) -> Type
  Parameters: io
Constraints: Monad io
Constructor: 
MkHasLinearIO

Methods:
  
liftIO1 : (1 _ : IO a) -> io a

Implementation: 
HasLinearIO IO
liftIO1 : HasLinearIO io => (1 _ : IO a) -> io a
  Totality: total
  Visibility: public export
primIO : HasIO io => ((1 _ : %World) -> IORes a) -> io a
  Totality: total
  Visibility: export
primIO1 : HasLinearIO io => (1 _ : ((1 _ : %World) -> IORes a)) -> io a
  Totality: total
  Visibility: export
onCollectAny : HasIO io => AnyPtr -> (AnyPtr -> IO ()) -> io GCAnyPtr
  Totality: total
  Visibility: export
onCollect : HasIO io => Ptr t -> (Ptr t -> IO ()) -> io (GCPtr t)
  Totality: total
  Visibility: export
prim__getString : Ptr String -> String
putStr : HasIO io => String -> io ()
  Output a string to stdout without a trailing newline.

  Totality: total
  Visibility: export
putStrLn : HasIO io => String -> io ()
  Output a string to stdout with a trailing newline.

  Totality: total
  Visibility: export
getLine : HasIO io => io String
  Read one line of input from stdin, without the trailing newline.

  Totality: total
  Visibility: export
putChar : HasIO io => Char -> io ()
  Write one single-byte character to stdout.

  Totality: total
  Visibility: export
putCharLn : HasIO io => Char -> io ()
  Write one multi-byte character to stdout, with a trailing newline.

  Totality: total
  Visibility: export
getChar : HasIO io => io Char
  Read one single-byte character from stdin.

  Totality: total
  Visibility: export
prim__fork : (1 _ : PrimIO ()) -> PrimIO ThreadID
fork : (1 _ : IO ()) -> IO ThreadID
  Totality: total
  Visibility: export
prim__threadWait : (1 _ : ThreadID) -> PrimIO ()
threadWait : (1 _ : ThreadID) -> IO ()
  Totality: total
  Visibility: export
print : HasIO io => Show a => a -> io ()
  Output something showable to stdout, without a trailing newline.

  Totality: total
  Visibility: export
printLn : HasIO io => Show a => a -> io ()
  Output something showable to stdout, with a trailing newline.

  Totality: total
  Visibility: export

\ No newline at end of file
+
Prelude.IO(source)
Definitions
interface HasIO : (Type -> Type) -> Type
  Parameters: io
Constraints: Monad io
Constructor: 
MkHasIO

Methods:
  
liftIO : IO a -> io a

Implementation: 
HasLinearIO io => HasIO io
liftIO : HasIO io => IO a -> io a
  Totality: total
  Visibility: public export
interface HasLinearIO : (Type -> Type) -> Type
  Parameters: io
Constraints: Monad io
Constructor: 
MkHasLinearIO

Methods:
  
liftIO1 : (1 _ : IO a) -> io a

Implementation: 
HasLinearIO IO
liftIO1 : HasLinearIO io => (1 _ : IO a) -> io a
  Totality: total
  Visibility: public export
primIO : HasIO io => ((1 _ : %World) -> IORes a) -> io a
  Totality: total
  Visibility: export
primIO1 : HasLinearIO io => (1 _ : ((1 _ : %World) -> IORes a)) -> io a
  Totality: total
  Visibility: export
onCollectAny : HasIO io => AnyPtr -> (AnyPtr -> IO ()) -> io GCAnyPtr
  Totality: total
  Visibility: export
onCollect : HasIO io => Ptr t -> (Ptr t -> IO ()) -> io (GCPtr t)
  Totality: total
  Visibility: export
prim__getString : Ptr String -> String
putStr : HasIO io => String -> io ()
  Output a string to stdout without a trailing newline.

  Totality: total
  Visibility: export
putStrLn : HasIO io => String -> io ()
  Output a string to stdout with a trailing newline.

  Totality: total
  Visibility: export
getLine : HasIO io => io String
  Read one line of input from stdin, without the trailing newline.

  Totality: total
  Visibility: export
putChar : HasIO io => Char -> io ()
  Write one single-byte character to stdout.

  Totality: total
  Visibility: export
putCharLn : HasIO io => Char -> io ()
  Write one multi-byte character to stdout, with a trailing newline.

  Totality: total
  Visibility: export
getChar : HasIO io => io Char
  Read one single-byte character from stdin.

  Totality: total
  Visibility: export
prim__fork : (1 _ : PrimIO ()) -> PrimIO ThreadID
fork : (1 _ : IO ()) -> IO ThreadID
  Totality: total
  Visibility: export
prim__threadWait : (1 _ : ThreadID) -> PrimIO ()
threadWait : (1 _ : ThreadID) -> IO ()
  Totality: total
  Visibility: export
print : HasIO io => Show a => a -> io ()
  Output something showable to stdout, without a trailing newline.

  Totality: total
  Visibility: export
printLn : HasIO io => Show a => a -> io ()
  Output something showable to stdout, with a trailing newline.

  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/prelude/docs/Prelude.Interfaces.html b/prelude/docs/Prelude.Interfaces.html
index 76b82a105c..1802f8aaa7 100644
--- a/prelude/docs/Prelude.Interfaces.html
+++ b/prelude/docs/Prelude.Interfaces.html
@@ -61,4 +61,4 @@
 
 
 
-
Prelude.Interfaces(source)
Definitions
interface Semigroup : Type -> Type
  Sets equipped with a single binary operation that is associative.  Must
  satisfy the following laws:
  
  + Associativity of `<+>`:
      forall a b c, a <+> (b <+> c) == (a <+> b) <+> c

  Parameters: ty
Constructor: 
MkSemigroup

Methods:
  
(<+>) : ty -> ty -> ty
  Fixity Declaration: infixl operator, level 8

Implementations:
  
Semigroup ()
  
Semigroup a => Semigroup b => Semigroup (a, b)
  
Semigroup Ordering
  
Semigroup b => Semigroup (a -> b)
  
Semigroup (Maybe a)
  
Semigroup (List a)
  
Semigroup String
(<+>) : Semigroup ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 8
interface Monoid : Type -> Type
  Sets equipped with a single binary operation that is associative, along with
  a neutral element for that binary operation.  Must satisfy the following
  laws:
  
  + Associativity of `<+>`:
      forall a b c, a <+> (b <+> c) == (a <+> b) <+> c
  + Neutral for `<+>`:
      forall a, a <+> neutral == a
      forall a, neutral <+> a == a

  Parameters: ty
Constraints: Semigroup ty
Constructor: 
MkMonoid

Methods:
  
neutral : ty

Implementations:
  
Monoid ()
  
Monoid a => Monoid b => Monoid (a, b)
  
Monoid Ordering
  
Monoid b => Monoid (a -> b)
  
Monoid (Maybe a)
  
Monoid (List a)
  
Monoid String
neutral : Monoid ty => ty
  Totality: total
  Visibility: public export
interface Functor : (Type -> Type) -> Type
  Functors allow a uniform action over a parameterised type.
  @ f a parameterised type

  Parameters: f
Constructor: 
MkFunctor

Methods:
  
map : (a -> b) -> f a -> f b
  Apply a function across everything of type 'a' in a parameterised type
  @ f the parameterised type
  @ func the function to apply

Implementations:
  
Functor IO
  
Functor (Pair a)
  
Functor Maybe
  
Functor (Either e)
  
Functor List
  
Functor Stream
map : Functor f => (a -> b) -> f a -> f b
  Apply a function across everything of type 'a' in a parameterised type
  @ f the parameterised type
  @ func the function to apply

  Totality: total
  Visibility: public export
(<$>) : Functor f => (a -> b) -> f a -> f b
  An infix alias for `map`, applying a function across everything of type 'a'
  in a parameterised type.
  @ f the parameterised type
  @ func the function to apply

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 4
(<&>) : Functor f => f a -> (a -> b) -> f b
  Flipped version of `<$>`, an infix alias for `map`, applying a function across
  everything of type 'a' in a parameterised type.
  @ f the parameterised type
  @ func the function to apply

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
(<$) : Functor f => b -> f a -> f b
  Run something for effects, replacing the return value with a given parameter.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 4
($>) : Functor f => f a -> b -> f b
  Flipped version of `<$`.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 4
ignore : Functor f => f a -> f ()
  Run something for effects, throwing away the return value.

  Totality: total
  Visibility: public export
interface Bifunctor : (Type -> Type -> Type) -> Type
  Bifunctors
  @f The action of the Bifunctor on pairs of objects
  A minimal definition includes either `bimap` or both `mapFst` and `mapSnd`.

  Parameters: f
Constructor: 
MkBifunctor

Methods:
  
bimap : (a -> c) -> (b -> d) -> f a b -> f c d
  The action of the Bifunctor on pairs of morphisms
  
  ````idris example
  bimap (\x => x + 1) reverse (1, "hello") == (2, "olleh")
  ````
  
  
mapFst : (a -> c) -> f a b -> f c b
  The action of the Bifunctor on morphisms pertaining to the first object
  
  ````idris example
  mapFst (\x => x + 1) (1, "hello") == (2, "hello")
  ````
  
  
mapSnd : (b -> d) -> f a b -> f a d
  The action of the Bifunctor on morphisms pertaining to the second object
  
  ````idris example
  mapSnd reverse (1, "hello") == (1, "olleh")
  ````
  

Implementations:
  
Bifunctor Pair
  
Bifunctor Either
bimap : Bifunctor f => (a -> c) -> (b -> d) -> f a b -> f c d
  The action of the Bifunctor on pairs of morphisms
  
  ````idris example
  bimap (\x => x + 1) reverse (1, "hello") == (2, "olleh")
  ````
  

  Totality: total
  Visibility: public export
mapFst : Bifunctor f => (a -> c) -> f a b -> f c b
  The action of the Bifunctor on morphisms pertaining to the first object
  
  ````idris example
  mapFst (\x => x + 1) (1, "hello") == (2, "hello")
  ````
  

  Totality: total
  Visibility: public export
mapSnd : Bifunctor f => (b -> d) -> f a b -> f a d
  The action of the Bifunctor on morphisms pertaining to the second object
  
  ````idris example
  mapSnd reverse (1, "hello") == (1, "olleh")
  ````
  

  Totality: total
  Visibility: public export
mapHom : Bifunctor f => (a -> b) -> f a a -> f b b
  Totality: total
  Visibility: public export
interface Applicative : (Type -> Type) -> Type
  Parameters: f
Constraints: Functor f
Constructor: 
MkApplicative

Methods:
  
pure : a -> f a
  
(<*>) : f (a -> b) -> f a -> f b
  Fixity Declaration: infixl operator, level 3

Implementations:
  
Applicative IO
  
Monoid a => Applicative (Pair a)
  
Applicative Maybe
  
Applicative (Either e)
  
Applicative List
pure : Applicative f => a -> f a
  Totality: total
  Visibility: public export
(<*>) : Applicative f => f (a -> b) -> f a -> f b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 3
(<*) : Applicative f => f a -> f b -> f a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 3
(*>) : Applicative f => f a -> f b -> f b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 3
interface Alternative : (Type -> Type) -> Type
  An alternative functor has a notion of disjunction.
  @f is the underlying applicative functor
  We expect (f a, empty, (<|>)) to be a type family of monoids.

  Parameters: f
Constraints: Applicative f
Constructor: 
MkAlternative

Methods:
  
empty : f a
  
(<|>) : f a -> Lazy (f a) -> f a
  Fixity Declaration: infixr operator, level 2

Implementations:
  
Alternative Maybe
  
Alternative List
empty : Alternative f => f a
  Totality: total
  Visibility: public export
(<|>) : Alternative f => f a -> Lazy (f a) -> f a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 2
interface Monad : (Type -> Type) -> Type
  Monad
  @m The underlying functor
  A minimal definition includes either `(>>=)` or `join`.

  Parameters: m
Constraints: Applicative m
Constructor: 
MkMonad

Methods:
  
(>>=) : m a -> (a -> m b) -> m b
  Also called `bind`.

  Fixity Declaration: infixl operator, level 1
  
join : m (m a) -> m a
  Also called `flatten` or mu.

Implementations:
  
Monad IO
  
Monoid a => Monad (Pair a)
  
Monad Maybe
  
Monad (Either e)
  
Monad List
(>>=) : Monad m => m a -> (a -> m b) -> m b
  Also called `bind`.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
join : Monad m => m (m a) -> m a
  Also called `flatten` or mu.

  Totality: total
  Visibility: public export
(=<<) : Monad m => (a -> m b) -> m a -> m b
  Right-to-left monadic bind, flipped version of `>>=`.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
(>>) : Monad m => m () -> Lazy (m b) -> m b
  Sequencing of effectful composition

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
(>=>) : Monad m => (a -> m b) -> (b -> m c) -> a -> m c
  Left-to-right Kleisli composition of monads.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
(<=<) : Monad m => (b -> m c) -> (a -> m b) -> a -> m c
  Right-to-left Kleisli composition of monads, flipped version of `>=>`.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
guard : Alternative f => Bool -> f ()
  `guard a` is `pure ()` if `a` is `True` and `empty` if `a` is `False`.

  Totality: total
  Visibility: public export
when : Applicative f => Bool -> Lazy (f ()) -> f ()
  Conditionally execute an applicative expression when the boolean is true.

  Totality: total
  Visibility: public export
unless : Applicative f => Bool -> Lazy (f ()) -> f ()
  Execute an applicative expression unless the boolean is true.

  Totality: total
  Visibility: public export
interface Foldable : (Type -> Type) -> Type
  The `Foldable` interface describes how you can iterate over the elements in
  a parameterised type and combine the elements together, using a provided
  function, into a single result.
  @ t The type of the 'Foldable' parameterised type.
  A minimal definition includes `foldr`

  Parameters: t
Constructor: 
MkFoldable

Methods:
  
foldr : (elem -> acc -> acc) -> acc -> t elem -> acc
  Successively combine the elements in a parameterised type using the
  provided function, starting with the element that is in the final position
  i.e. the right-most position.
  @ func  The function used to 'fold' an element into the accumulated result
  @ init  The starting value the results are being combined into
  @ input The parameterised type
  
foldl : (acc -> elem -> acc) -> acc -> t elem -> acc
  The same as `foldr` but begins the folding from the element at the initial
  position in the data structure i.e. the left-most position.
  @ func  The function used to 'fold' an element into the accumulated result
  @ init  The starting value the results are being combined into
  @ input The parameterised type
  
null : t elem -> Bool
  Test whether the structure is empty.
  @ acc The accumulator value which is specified to be lazy
  
foldlM : Monad m => (acc -> elem -> m acc) -> acc -> t elem -> m acc
  Similar to `foldl`, but uses a function wrapping its result in a `Monad`.
  Consequently, the final value is wrapped in the same `Monad`.
  
toList : t elem -> List elem
  Produce a list of the elements contained in the parametrised type.
  
foldMap : Monoid m => (a -> m) -> t a -> m
  Maps each element to a value and combine them.
  For performance reasons, this should wherever
  be implemented with tail recursion.
  @ f The function to apply to each element.

Implementations:
  
Foldable (Pair a)
  
Foldable Maybe
  
Foldable (Either e)
  
Foldable List
foldr : Foldable t => (elem -> acc -> acc) -> acc -> t elem -> acc
  Successively combine the elements in a parameterised type using the
  provided function, starting with the element that is in the final position
  i.e. the right-most position.
  @ func  The function used to 'fold' an element into the accumulated result
  @ init  The starting value the results are being combined into
  @ input The parameterised type

  Totality: total
  Visibility: public export
foldl : Foldable t => (acc -> elem -> acc) -> acc -> t elem -> acc
  The same as `foldr` but begins the folding from the element at the initial
  position in the data structure i.e. the left-most position.
  @ func  The function used to 'fold' an element into the accumulated result
  @ init  The starting value the results are being combined into
  @ input The parameterised type

  Totality: total
  Visibility: public export
null : Foldable t => t elem -> Bool
  Test whether the structure is empty.
  @ acc The accumulator value which is specified to be lazy

  Totality: total
  Visibility: public export
foldlM : Foldable t => Monad m => (acc -> elem -> m acc) -> acc -> t elem -> m acc
  Similar to `foldl`, but uses a function wrapping its result in a `Monad`.
  Consequently, the final value is wrapped in the same `Monad`.

  Totality: total
  Visibility: public export
toList : Foldable t => t elem -> List elem
  Produce a list of the elements contained in the parametrised type.

  Totality: total
  Visibility: public export
foldMap : Foldable t => Monoid m => (a -> m) -> t a -> m
  Maps each element to a value and combine them.
  For performance reasons, this should wherever
  be implemented with tail recursion.
  @ f The function to apply to each element.

  Totality: total
  Visibility: public export
concat : Monoid a => Foldable t => t a -> a
  Combine each element of a structure into a monoid.

  Totality: total
  Visibility: public export
concatMap : Monoid m => Foldable t => (a -> m) -> t a -> m
  Combine into a monoid the collective results of applying a function to each
  element of a structure.

  Totality: total
  Visibility: public export
and : Foldable t => t (Lazy Bool) -> Bool
  The conjunction of all elements of a structure containing lazy boolean
  values.  `and` short-circuits from left to right, evaluating until either an
  element is `False` or no elements remain.

  Totality: total
  Visibility: public export
or : Foldable t => t (Lazy Bool) -> Bool
  The disjunction of all elements of a structure containing lazy boolean
  values.  `or` short-circuits from left to right, evaluating either until an
  element is `True` or no elements remain.

  Totality: total
  Visibility: public export
any : Foldable t => (a -> Bool) -> t a -> Bool
  The disjunction of the collective results of applying a predicate to all
  elements of a structure.  `any` short-circuits from left to right.

  Totality: total
  Visibility: public export
all : Foldable t => (a -> Bool) -> t a -> Bool
  The conjunction of the collective results of applying a predicate to all
  elements of a structure.  `all` short-circuits from left to right.

  Totality: total
  Visibility: public export
sum : Num a => Foldable t => t a -> a
  Add together all the elements of a structure.

  Totality: total
  Visibility: public export
sum' : Num a => Foldable t => t a -> a
  Add together all the elements of a structure.
  Same as `sum` but tail recursive.

  Totality: total
  Visibility: export
product : Num a => Foldable t => t a -> a
  Multiply together all elements of a structure.

  Totality: total
  Visibility: public export
product' : Num a => Foldable t => t a -> a
  Multiply together all elements of a structure.
  Same as `product` but tail recursive.

  Totality: total
  Visibility: export
traverse_ : Applicative f => Foldable t => (a -> f b) -> t a -> f ()
  Map each element of a structure to a computation, evaluate those
  computations and discard the results.

  Totality: total
  Visibility: public export
sequence_ : Applicative f => Foldable t => t (f a) -> f ()
  Evaluate each computation in a structure and discard the results.

  Totality: total
  Visibility: public export
for_ : Applicative f => Foldable t => t a -> (a -> f b) -> f ()
  Like `traverse_` but with the arguments flipped.

  Totality: total
  Visibility: public export
choice : Alternative f => Foldable t => t (Lazy (f a)) -> f a
  Fold using Alternative.
  
  If you have a left-biased alternative operator `<|>`, then `choice` performs
  left-biased choice from a list of alternatives, which means that it
  evaluates to the left-most non-`empty` alternative.
  
  If the list is empty, or all values in it are `empty`, then it evaluates to
  `empty`.
  
  Example:
  
  ```
  -- given a parser expression like:
  expr = literal <|> keyword <|> funcall
  
  -- choice lets you write this as:
  expr = choice [literal, keyword, funcall]
  ```
  
  Note: In Haskell, `choice` is called `asum`.

  Totality: total
  Visibility: public export
choiceMap : Alternative f => Foldable t => (a -> f b) -> t a -> f b
  A fused version of `choice` and `map`.

  Totality: total
  Visibility: public export
interface Bifoldable : (Type -> Type -> Type) -> Type
  `Bifoldable` identifies foldable structures with two different varieties
  of elements (as opposed to `Foldable`, which has one variety of element).
  Common examples are `Either` and `Pair`.
  A minimal definition includes `bifoldr`

  Parameters: p
Constructor: 
MkBifoldable

Methods:
  
bifoldr : (a -> acc -> acc) -> (b -> acc -> acc) -> acc -> p a b -> acc
  
bifoldl : (acc -> a -> acc) -> (acc -> b -> acc) -> acc -> p a b -> acc
  
binull : p a b -> Bool

Implementations:
  
Bifoldable Pair
  
Bifoldable Either
bifoldr : Bifoldable p => (a -> acc -> acc) -> (b -> acc -> acc) -> acc -> p a b -> acc
  Totality: total
  Visibility: public export
bifoldl : Bifoldable p => (acc -> a -> acc) -> (acc -> b -> acc) -> acc -> p a b -> acc
  Totality: total
  Visibility: public export
binull : Bifoldable p => p a b -> Bool
  Totality: total
  Visibility: public export
bifoldMap : Monoid acc => Bifoldable p => (a -> acc) -> (b -> acc) -> p a b -> acc
  Analogous to `foldMap` but for `Bifoldable` structures

  Totality: total
  Visibility: public export
bifoldMapFst : Monoid acc => Bifoldable p => (a -> acc) -> p a b -> acc
  Like Bifunctor's `mapFst` but for `Bifoldable` structures

  Totality: total
  Visibility: public export
interface Traversable : (Type -> Type) -> Type
  Parameters: t
Constraints: Functor t, Foldable t
Constructor: 
MkTraversable

Methods:
  
traverse : Applicative f => (a -> f b) -> t a -> f (t b)
  Map each element of a structure to a computation, evaluate those
  computations and combine the results.

Implementations:
  
Traversable (Pair a)
  
Traversable Maybe
  
Traversable (Either e)
  
Traversable List
traverse : Traversable t => Applicative f => (a -> f b) -> t a -> f (t b)
  Map each element of a structure to a computation, evaluate those
  computations and combine the results.

  Totality: total
  Visibility: public export
sequence : Applicative f => Traversable t => t (f a) -> f (t a)
  Evaluate each computation in a structure and collect the results.

  Totality: total
  Visibility: public export
for : Applicative f => Traversable t => t a -> (a -> f b) -> f (t b)
  Like `traverse` but with the arguments flipped.

  Totality: total
  Visibility: public export
interface Bitraversable : (Type -> Type -> Type) -> Type
  Parameters: p
Constraints: Bifunctor p, Bifoldable p
Constructor: 
MkBitraversable

Methods:
  
bitraverse : Applicative f => (a -> f c) -> (b -> f d) -> p a b -> f (p c d)
  Map each element of a structure to a computation, evaluate those
  computations and combine the results.

Implementations:
  
Bitraversable Pair
  
Bitraversable Either
bitraverse : Bitraversable p => Applicative f => (a -> f c) -> (b -> f d) -> p a b -> f (p c d)
  Map each element of a structure to a computation, evaluate those
  computations and combine the results.

  Totality: total
  Visibility: public export
bisequence : Applicative f => Bitraversable p => p (f a) (f b) -> f (p a b)
  Evaluate each computation in a structure and collect the results.

  Totality: total
  Visibility: public export
bifor : Applicative f => Bitraversable p => p a b -> (a -> f c) -> (b -> f d) -> f (p c d)
  Like `bitraverse` but with the arguments flipped.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Prelude.Interfaces(source)
Definitions
interface Semigroup : Type -> Type
  Sets equipped with a single binary operation that is associative.  Must
  satisfy the following laws:
  
  + Associativity of `<+>`:
      forall a b c, a <+> (b <+> c) == (a <+> b) <+> c

  Parameters: ty
Constructor: 
MkSemigroup

Methods:
  
(<+>) : ty -> ty -> ty
  Fixity Declaration: infixl operator, level 8

Implementations:
  
Semigroup ()
  
Semigroup a => Semigroup b => Semigroup (a, b)
  
Semigroup Ordering
  
Semigroup b => Semigroup (a -> b)
  
Semigroup (Maybe a)
  
Semigroup (List a)
  
Semigroup String
(<+>) : Semigroup ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 8
interface Monoid : Type -> Type
  Sets equipped with a single binary operation that is associative, along with
  a neutral element for that binary operation.  Must satisfy the following
  laws:
  
  + Associativity of `<+>`:
      forall a b c, a <+> (b <+> c) == (a <+> b) <+> c
  + Neutral for `<+>`:
      forall a, a <+> neutral == a
      forall a, neutral <+> a == a

  Parameters: ty
Constraints: Semigroup ty
Constructor: 
MkMonoid

Methods:
  
neutral : ty

Implementations:
  
Monoid ()
  
Monoid a => Monoid b => Monoid (a, b)
  
Monoid Ordering
  
Monoid b => Monoid (a -> b)
  
Monoid (Maybe a)
  
Monoid (List a)
  
Monoid String
neutral : Monoid ty => ty
  Totality: total
  Visibility: public export
interface Functor : (Type -> Type) -> Type
  Functors allow a uniform action over a parameterised type.
  @ f a parameterised type

  Parameters: f
Constructor: 
MkFunctor

Methods:
  
map : (a -> b) -> f a -> f b
  Apply a function across everything of type 'a' in a parameterised type
  @ f the parameterised type
  @ func the function to apply

Implementations:
  
Functor IO
  
Functor (Pair a)
  
Functor Maybe
  
Functor (Either e)
  
Functor List
  
Functor Stream
map : Functor f => (a -> b) -> f a -> f b
  Apply a function across everything of type 'a' in a parameterised type
  @ f the parameterised type
  @ func the function to apply

  Totality: total
  Visibility: public export
(<$>) : Functor f => (a -> b) -> f a -> f b
  An infix alias for `map`, applying a function across everything of type 'a'
  in a parameterised type.
  @ f the parameterised type
  @ func the function to apply

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 4
(<&>) : Functor f => f a -> (a -> b) -> f b
  Flipped version of `<$>`, an infix alias for `map`, applying a function across
  everything of type 'a' in a parameterised type.
  @ f the parameterised type
  @ func the function to apply

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
(<$) : Functor f => b -> f a -> f b
  Run something for effects, replacing the return value with a given parameter.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 4
($>) : Functor f => f a -> b -> f b
  Flipped version of `<$`.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 4
ignore : Functor f => f a -> f ()
  Run something for effects, throwing away the return value.

  Totality: total
  Visibility: public export
interface Bifunctor : (Type -> Type -> Type) -> Type
  Bifunctors
  @f The action of the Bifunctor on pairs of objects
  A minimal definition includes either `bimap` or both `mapFst` and `mapSnd`.

  Parameters: f
Constructor: 
MkBifunctor

Methods:
  
bimap : (a -> c) -> (b -> d) -> f a b -> f c d
  The action of the Bifunctor on pairs of morphisms
  
  ````idris example
  bimap (\x => x + 1) reverse (1, "hello") == (2, "olleh")
  ````
  
  
mapFst : (a -> c) -> f a b -> f c b
  The action of the Bifunctor on morphisms pertaining to the first object
  
  ````idris example
  mapFst (\x => x + 1) (1, "hello") == (2, "hello")
  ````
  
  
mapSnd : (b -> d) -> f a b -> f a d
  The action of the Bifunctor on morphisms pertaining to the second object
  
  ````idris example
  mapSnd reverse (1, "hello") == (1, "olleh")
  ````
  

Implementations:
  
Bifunctor Pair
  
Bifunctor Either
bimap : Bifunctor f => (a -> c) -> (b -> d) -> f a b -> f c d
  The action of the Bifunctor on pairs of morphisms
  
  ````idris example
  bimap (\x => x + 1) reverse (1, "hello") == (2, "olleh")
  ````
  

  Totality: total
  Visibility: public export
mapFst : Bifunctor f => (a -> c) -> f a b -> f c b
  The action of the Bifunctor on morphisms pertaining to the first object
  
  ````idris example
  mapFst (\x => x + 1) (1, "hello") == (2, "hello")
  ````
  

  Totality: total
  Visibility: public export
mapSnd : Bifunctor f => (b -> d) -> f a b -> f a d
  The action of the Bifunctor on morphisms pertaining to the second object
  
  ````idris example
  mapSnd reverse (1, "hello") == (1, "olleh")
  ````
  

  Totality: total
  Visibility: public export
mapHom : Bifunctor f => (a -> b) -> f a a -> f b b
  Totality: total
  Visibility: public export
interface Applicative : (Type -> Type) -> Type
  Parameters: f
Constraints: Functor f
Constructor: 
MkApplicative

Methods:
  
pure : a -> f a
  
(<*>) : f (a -> b) -> f a -> f b
  Fixity Declaration: infixl operator, level 3

Implementations:
  
Applicative IO
  
Monoid a => Applicative (Pair a)
  
Applicative Maybe
  
Applicative (Either e)
  
Applicative List
pure : Applicative f => a -> f a
  Totality: total
  Visibility: public export
(<*>) : Applicative f => f (a -> b) -> f a -> f b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 3
(<*) : Applicative f => f a -> f b -> f a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 3
(*>) : Applicative f => f a -> f b -> f b
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 3
interface Alternative : (Type -> Type) -> Type
  An alternative functor has a notion of disjunction.
  @f is the underlying applicative functor
  We expect (f a, empty, (<|>)) to be a type family of monoids.

  Parameters: f
Constraints: Applicative f
Constructor: 
MkAlternative

Methods:
  
empty : f a
  
(<|>) : f a -> Lazy (f a) -> f a
  Fixity Declaration: infixr operator, level 2

Implementations:
  
Alternative Maybe
  
Alternative List
empty : Alternative f => f a
  Totality: total
  Visibility: public export
(<|>) : Alternative f => f a -> Lazy (f a) -> f a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 2
interface Monad : (Type -> Type) -> Type
  Monad
  @m The underlying functor
  A minimal definition includes either `(>>=)` or `join`.

  Parameters: m
Constraints: Applicative m
Constructor: 
MkMonad

Methods:
  
(>>=) : m a -> (a -> m b) -> m b
  Also called `bind`.

  Fixity Declaration: infixl operator, level 1
  
join : m (m a) -> m a
  Also called `flatten` or mu.

Implementations:
  
Monad IO
  
Monoid a => Monad (Pair a)
  
Monad Maybe
  
Monad (Either e)
  
Monad List
(>>=) : Monad m => m a -> (a -> m b) -> m b
  Also called `bind`.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
join : Monad m => m (m a) -> m a
  Also called `flatten` or mu.

  Totality: total
  Visibility: public export
(=<<) : Monad m => (a -> m b) -> m a -> m b
  Right-to-left monadic bind, flipped version of `>>=`.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
(>>) : Monad m => m () -> Lazy (m b) -> m b
  Sequencing of effectful composition

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
(>=>) : Monad m => (a -> m b) -> (b -> m c) -> a -> m c
  Left-to-right Kleisli composition of monads.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
(<=<) : Monad m => (b -> m c) -> (a -> m b) -> a -> m c
  Right-to-left Kleisli composition of monads, flipped version of `>=>`.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 1
guard : Alternative f => Bool -> f ()
  `guard a` is `pure ()` if `a` is `True` and `empty` if `a` is `False`.

  Totality: total
  Visibility: public export
when : Applicative f => Bool -> Lazy (f ()) -> f ()
  Conditionally execute an applicative expression when the boolean is true.

  Totality: total
  Visibility: public export
unless : Applicative f => Bool -> Lazy (f ()) -> f ()
  Execute an applicative expression unless the boolean is true.

  Totality: total
  Visibility: public export
interface Foldable : (Type -> Type) -> Type
  The `Foldable` interface describes how you can iterate over the elements in
  a parameterised type and combine the elements together, using a provided
  function, into a single result.
  @ t The type of the 'Foldable' parameterised type.
  A minimal definition includes `foldr`

  Parameters: t
Constructor: 
MkFoldable

Methods:
  
foldr : (elem -> acc -> acc) -> acc -> t elem -> acc
  Successively combine the elements in a parameterised type using the
  provided function, starting with the element that is in the final position
  i.e. the right-most position.
  @ func  The function used to 'fold' an element into the accumulated result
  @ init  The starting value the results are being combined into
  @ input The parameterised type
  
foldl : (acc -> elem -> acc) -> acc -> t elem -> acc
  The same as `foldr` but begins the folding from the element at the initial
  position in the data structure i.e. the left-most position.
  @ func  The function used to 'fold' an element into the accumulated result
  @ init  The starting value the results are being combined into
  @ input The parameterised type
  
null : t elem -> Bool
  Test whether the structure is empty.
  @ acc The accumulator value which is specified to be lazy
  
foldlM : Monad m => (acc -> elem -> m acc) -> acc -> t elem -> m acc
  Similar to `foldl`, but uses a function wrapping its result in a `Monad`.
  Consequently, the final value is wrapped in the same `Monad`.
  
toList : t elem -> List elem
  Produce a list of the elements contained in the parametrised type.
  
foldMap : Monoid m => (a -> m) -> t a -> m
  Maps each element to a value and combine them.
  For performance reasons, this should wherever
  be implemented with tail recursion.
  @ f The function to apply to each element.

Implementations:
  
Foldable (Pair a)
  
Foldable Maybe
  
Foldable (Either e)
  
Foldable List
foldr : Foldable t => (elem -> acc -> acc) -> acc -> t elem -> acc
  Successively combine the elements in a parameterised type using the
  provided function, starting with the element that is in the final position
  i.e. the right-most position.
  @ func  The function used to 'fold' an element into the accumulated result
  @ init  The starting value the results are being combined into
  @ input The parameterised type

  Totality: total
  Visibility: public export
foldl : Foldable t => (acc -> elem -> acc) -> acc -> t elem -> acc
  The same as `foldr` but begins the folding from the element at the initial
  position in the data structure i.e. the left-most position.
  @ func  The function used to 'fold' an element into the accumulated result
  @ init  The starting value the results are being combined into
  @ input The parameterised type

  Totality: total
  Visibility: public export
null : Foldable t => t elem -> Bool
  Test whether the structure is empty.
  @ acc The accumulator value which is specified to be lazy

  Totality: total
  Visibility: public export
foldlM : Foldable t => Monad m => (acc -> elem -> m acc) -> acc -> t elem -> m acc
  Similar to `foldl`, but uses a function wrapping its result in a `Monad`.
  Consequently, the final value is wrapped in the same `Monad`.

  Totality: total
  Visibility: public export
toList : Foldable t => t elem -> List elem
  Produce a list of the elements contained in the parametrised type.

  Totality: total
  Visibility: public export
foldMap : Foldable t => Monoid m => (a -> m) -> t a -> m
  Maps each element to a value and combine them.
  For performance reasons, this should wherever
  be implemented with tail recursion.
  @ f The function to apply to each element.

  Totality: total
  Visibility: public export
concat : Monoid a => Foldable t => t a -> a
  Combine each element of a structure into a monoid.

  Totality: total
  Visibility: public export
concatMap : Monoid m => Foldable t => (a -> m) -> t a -> m
  Combine into a monoid the collective results of applying a function to each
  element of a structure.

  Totality: total
  Visibility: public export
and : Foldable t => t (Lazy Bool) -> Bool
  The conjunction of all elements of a structure containing lazy boolean
  values.  `and` short-circuits from left to right, evaluating until either an
  element is `False` or no elements remain.

  Totality: total
  Visibility: public export
or : Foldable t => t (Lazy Bool) -> Bool
  The disjunction of all elements of a structure containing lazy boolean
  values.  `or` short-circuits from left to right, evaluating either until an
  element is `True` or no elements remain.

  Totality: total
  Visibility: public export
any : Foldable t => (a -> Bool) -> t a -> Bool
  The disjunction of the collective results of applying a predicate to all
  elements of a structure.  `any` short-circuits from left to right.

  Totality: total
  Visibility: public export
all : Foldable t => (a -> Bool) -> t a -> Bool
  The conjunction of the collective results of applying a predicate to all
  elements of a structure.  `all` short-circuits from left to right.

  Totality: total
  Visibility: public export
sum : Num a => Foldable t => t a -> a
  Add together all the elements of a structure.

  Totality: total
  Visibility: public export
sum' : Num a => Foldable t => t a -> a
  Add together all the elements of a structure.
  Same as `sum` but tail recursive.

  Totality: total
  Visibility: export
product : Num a => Foldable t => t a -> a
  Multiply together all elements of a structure.

  Totality: total
  Visibility: public export
product' : Num a => Foldable t => t a -> a
  Multiply together all elements of a structure.
  Same as `product` but tail recursive.

  Totality: total
  Visibility: export
traverse_ : Applicative f => Foldable t => (a -> f b) -> t a -> f ()
  Map each element of a structure to a computation, evaluate those
  computations and discard the results.

  Totality: total
  Visibility: public export
sequence_ : Applicative f => Foldable t => t (f a) -> f ()
  Evaluate each computation in a structure and discard the results.

  Totality: total
  Visibility: public export
for_ : Applicative f => Foldable t => t a -> (a -> f b) -> f ()
  Like `traverse_` but with the arguments flipped.

  Totality: total
  Visibility: public export
choice : Alternative f => Foldable t => t (Lazy (f a)) -> f a
  Fold using Alternative.
  
  If you have a left-biased alternative operator `<|>`, then `choice` performs
  left-biased choice from a list of alternatives, which means that it
  evaluates to the left-most non-`empty` alternative.
  
  If the list is empty, or all values in it are `empty`, then it evaluates to
  `empty`.
  
  Example:
  
  ```
  -- given a parser expression like:
  expr = literal <|> keyword <|> funcall
  
  -- choice lets you write this as:
  expr = choice [literal, keyword, funcall]
  ```
  
  Note: In Haskell, `choice` is called `asum`.

  Totality: total
  Visibility: public export
choiceMap : Alternative f => Foldable t => (a -> f b) -> t a -> f b
  A fused version of `choice` and `map`.

  Totality: total
  Visibility: public export
interface Bifoldable : (Type -> Type -> Type) -> Type
  `Bifoldable` identifies foldable structures with two different varieties
  of elements (as opposed to `Foldable`, which has one variety of element).
  Common examples are `Either` and `Pair`.
  A minimal definition includes `bifoldr`

  Parameters: p
Constructor: 
MkBifoldable

Methods:
  
bifoldr : (a -> acc -> acc) -> (b -> acc -> acc) -> acc -> p a b -> acc
  
bifoldl : (acc -> a -> acc) -> (acc -> b -> acc) -> acc -> p a b -> acc
  
binull : p a b -> Bool

Implementations:
  
Bifoldable Pair
  
Bifoldable Either
bifoldr : Bifoldable p => (a -> acc -> acc) -> (b -> acc -> acc) -> acc -> p a b -> acc
  Totality: total
  Visibility: public export
bifoldl : Bifoldable p => (acc -> a -> acc) -> (acc -> b -> acc) -> acc -> p a b -> acc
  Totality: total
  Visibility: public export
binull : Bifoldable p => p a b -> Bool
  Totality: total
  Visibility: public export
bifoldMap : Monoid acc => Bifoldable p => (a -> acc) -> (b -> acc) -> p a b -> acc
  Analogous to `foldMap` but for `Bifoldable` structures

  Totality: total
  Visibility: public export
bifoldMapFst : Monoid acc => Bifoldable p => (a -> acc) -> p a b -> acc
  Like Bifunctor's `mapFst` but for `Bifoldable` structures

  Totality: total
  Visibility: public export
interface Traversable : (Type -> Type) -> Type
  Parameters: t
Constraints: Functor t, Foldable t
Constructor: 
MkTraversable

Methods:
  
traverse : Applicative f => (a -> f b) -> t a -> f (t b)
  Map each element of a structure to a computation, evaluate those
  computations and combine the results.

Implementations:
  
Traversable (Pair a)
  
Traversable Maybe
  
Traversable (Either e)
  
Traversable List
traverse : Traversable t => Applicative f => (a -> f b) -> t a -> f (t b)
  Map each element of a structure to a computation, evaluate those
  computations and combine the results.

  Totality: total
  Visibility: public export
sequence : Applicative f => Traversable t => t (f a) -> f (t a)
  Evaluate each computation in a structure and collect the results.

  Totality: total
  Visibility: public export
for : Applicative f => Traversable t => t a -> (a -> f b) -> f (t b)
  Like `traverse` but with the arguments flipped.

  Totality: total
  Visibility: public export
interface Bitraversable : (Type -> Type -> Type) -> Type
  Parameters: p
Constraints: Bifunctor p, Bifoldable p
Constructor: 
MkBitraversable

Methods:
  
bitraverse : Applicative f => (a -> f c) -> (b -> f d) -> p a b -> f (p c d)
  Map each element of a structure to a computation, evaluate those
  computations and combine the results.

Implementations:
  
Bitraversable Pair
  
Bitraversable Either
bitraverse : Bitraversable p => Applicative f => (a -> f c) -> (b -> f d) -> p a b -> f (p c d)
  Map each element of a structure to a computation, evaluate those
  computations and combine the results.

  Totality: total
  Visibility: public export
bisequence : Applicative f => Bitraversable p => p (f a) (f b) -> f (p a b)
  Evaluate each computation in a structure and collect the results.

  Totality: total
  Visibility: public export
bifor : Applicative f => Bitraversable p => p a b -> (a -> f c) -> (b -> f d) -> f (p c d)
  Like `bitraverse` but with the arguments flipped.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/prelude/docs/Prelude.Interpolation.html b/prelude/docs/Prelude.Interpolation.html
index f5f9774986..8310546468 100644
--- a/prelude/docs/Prelude.Interpolation.html
+++ b/prelude/docs/Prelude.Interpolation.html
@@ -61,4 +61,4 @@
 
 
 
-
Prelude.Interpolation(source)
Definitions
interface Interpolation : Type -> Type
  Interpolated strings are of the form `"xxxx \{ expr } yyyy"`.
  In this example the string `"xxxx "` is concatenated with `expr` and
  `" yyyy"`, since `expr` is not necessarily a string, the generated
  code looks like this:
  ```
  concat [interpolate "xxxx ", interpolate expr, interpolate " yyyy"]
  ```
  This allows to customise the interpolation behaviour by providing
  an instance of `Interpolation` for a type.

  Parameters: a
Constructor: 
MkInterpolation

Methods:
  
interpolate : a -> String

Implementations:
  
Interpolation String
  
Interpolation Void
interpolate : Interpolation a => a -> String
  Visibility: public export

\ No newline at end of file
+
Prelude.Interpolation(source)
Definitions
interface Interpolation : Type -> Type
  Interpolated strings are of the form `"xxxx \{ expr } yyyy"`.
  In this example the string `"xxxx "` is concatenated with `expr` and
  `" yyyy"`, since `expr` is not necessarily a string, the generated
  code looks like this:
  ```
  concat [interpolate "xxxx ", interpolate expr, interpolate " yyyy"]
  ```
  This allows to customise the interpolation behaviour by providing
  an instance of `Interpolation` for a type.

  Parameters: a
Constructor: 
MkInterpolation

Methods:
  
interpolate : a -> String

Implementations:
  
Interpolation String
  
Interpolation Void
interpolate : Interpolation a => a -> String
  Visibility: public export

\ No newline at end of file
diff --git a/prelude/docs/Prelude.Num.html b/prelude/docs/Prelude.Num.html
index 6261d8e662..e7c8447366 100644
--- a/prelude/docs/Prelude.Num.html
+++ b/prelude/docs/Prelude.Num.html
@@ -61,4 +61,4 @@
 
 
 
-
Prelude.Num(source)
Definitions
interface Num : Type -> Type
  The Num interface defines basic numerical arithmetic.

  Parameters: ty
Constructor: 
MkNum

Methods:
  
(+) : ty -> ty -> ty
  Fixity Declaration: infixl operator, level 8
  
(*) : ty -> ty -> ty
  Fixity Declaration: infixl operator, level 9
  
fromInteger : Integer -> ty
  Conversion from Integer.

Implementations:
  
Num Integer
  
Num Int
  
Num Int8
  
Num Int16
  
Num Int32
  
Num Int64
  
Num Bits8
  
Num Bits16
  
Num Bits32
  
Num Bits64
  
Num Double
  
Num Nat
(+) : Num ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 8
(*) : Num ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 9
fromInteger : Num ty => Integer -> ty
  Conversion from Integer.

  Totality: total
  Visibility: public export
interface Neg : Type -> Type
  The `Neg` interface defines operations on numbers which can be negative.

  Parameters: ty
Constraints: Num ty
Constructor: 
MkNeg

Methods:
  
negate : ty -> ty
  The underlying of unary minus. `-5` desugars to `negate (fromInteger 5)`.

  Fixity Declaration: prefix operator, level 10
  
(-) : ty -> ty -> ty
  Fixity Declarations:
  infixl operator, level 8
prefix operator, level 10

Implementations:
  
Neg Integer
  
Neg Int
  
Neg Int8
  
Neg Int16
  
Neg Int32
  
Neg Int64
  
Neg Bits8
  
Neg Bits16
  
Neg Bits32
  
Neg Bits64
  
Neg Double
negate : Neg ty => ty -> ty
  The underlying of unary minus. `-5` desugars to `negate (fromInteger 5)`.

  Totality: total
  Visibility: public export
  Fixity Declaration: prefix operator, level 10
negate : Neg ty => ty -> ty
  The underlying of unary minus. `-5` desugars to `negate (fromInteger 5)`.

  Totality: total
  Visibility: public export
  Fixity Declaration: prefix operator, level 10
(-) : Neg ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
  Fixity Declarations:
  infixl operator, level 8
prefix operator, level 10
subtract : Neg ty => ty -> ty -> ty
  A convenience alias for `(-)`, this function enables partial application of subtraction on the
  right-hand operand as
  ```idris example
  (`subtract` 1)
  ```
  This contrasts with `(- 1)`, which is parsed as `-1`.

  Totality: total
  Visibility: export
interface Abs : Type -> Type
  Numbers for which the absolute value is defined should implement `Abs`.

  Parameters: ty
Constraints: Num ty
Constructor: 
MkAbs

Methods:
  
abs : ty -> ty
  Absolute value.

Implementations:
  
Abs Integer
  
Abs Int
  
Abs Int8
  
Abs Int16
  
Abs Int32
  
Abs Int64
  
Abs Bits8
  
Abs Bits16
  
Abs Bits32
  
Abs Bits64
  
Abs Double
abs : Abs ty => ty -> ty
  Absolute value.

  Totality: total
  Visibility: public export
interface Fractional : Type -> Type
  Parameters: ty
Constraints: Num ty
Constructor: 
MkFractional

Methods:
  
(/) : ty -> ty -> ty
  Fixity Declaration: infixl operator, level 9
  
recip : ty -> ty

Implementation: 
Fractional Double
(/) : Fractional ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 9
recip : Fractional ty => ty -> ty
  Totality: total
  Visibility: public export
interface Integral : Type -> Type
  Parameters: ty
Constraints: Num ty
Constructor: 
MkIntegral

Methods:
  
div : ty -> ty -> ty
  Fixity Declaration: infixl operator, level 9
  
mod : ty -> ty -> ty
  Fixity Declaration: infixl operator, level 9

Implementations:
  
Integral Integer
  
Integral Int
  
Integral Int8
  
Integral Int16
  
Integral Int32
  
Integral Int64
  
Integral Bits8
  
Integral Bits16
  
Integral Bits32
  
Integral Bits64
div : Integral ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 9
mod : Integral ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 9
defaultInteger : Num Integer
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Prelude.Num(source)
Definitions
interface Num : Type -> Type
  The Num interface defines basic numerical arithmetic.

  Parameters: ty
Constructor: 
MkNum

Methods:
  
(+) : ty -> ty -> ty
  Fixity Declaration: infixl operator, level 8
  
(*) : ty -> ty -> ty
  Fixity Declaration: infixl operator, level 9
  
fromInteger : Integer -> ty
  Conversion from Integer.

Implementations:
  
Num Integer
  
Num Int
  
Num Int8
  
Num Int16
  
Num Int32
  
Num Int64
  
Num Bits8
  
Num Bits16
  
Num Bits32
  
Num Bits64
  
Num Double
  
Num Nat
(+) : Num ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 8
(*) : Num ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 9
fromInteger : Num ty => Integer -> ty
  Conversion from Integer.

  Totality: total
  Visibility: public export
interface Neg : Type -> Type
  The `Neg` interface defines operations on numbers which can be negative.

  Parameters: ty
Constraints: Num ty
Constructor: 
MkNeg

Methods:
  
negate : ty -> ty
  The underlying of unary minus. `-5` desugars to `negate (fromInteger 5)`.

  Fixity Declaration: prefix operator, level 10
  
(-) : ty -> ty -> ty
  Fixity Declarations:
  infixl operator, level 8
prefix operator, level 10

Implementations:
  
Neg Integer
  
Neg Int
  
Neg Int8
  
Neg Int16
  
Neg Int32
  
Neg Int64
  
Neg Bits8
  
Neg Bits16
  
Neg Bits32
  
Neg Bits64
  
Neg Double
negate : Neg ty => ty -> ty
  The underlying of unary minus. `-5` desugars to `negate (fromInteger 5)`.

  Totality: total
  Visibility: public export
  Fixity Declaration: prefix operator, level 10
negate : Neg ty => ty -> ty
  The underlying of unary minus. `-5` desugars to `negate (fromInteger 5)`.

  Totality: total
  Visibility: public export
  Fixity Declaration: prefix operator, level 10
(-) : Neg ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
  Fixity Declarations:
  infixl operator, level 8
prefix operator, level 10
subtract : Neg ty => ty -> ty -> ty
  A convenience alias for `(-)`, this function enables partial application of subtraction on the
  right-hand operand as
  ```idris example
  (`subtract` 1)
  ```
  This contrasts with `(- 1)`, which is parsed as `-1`.

  Totality: total
  Visibility: export
interface Abs : Type -> Type
  Numbers for which the absolute value is defined should implement `Abs`.

  Parameters: ty
Constraints: Num ty
Constructor: 
MkAbs

Methods:
  
abs : ty -> ty
  Absolute value.

Implementations:
  
Abs Integer
  
Abs Int
  
Abs Int8
  
Abs Int16
  
Abs Int32
  
Abs Int64
  
Abs Bits8
  
Abs Bits16
  
Abs Bits32
  
Abs Bits64
  
Abs Double
abs : Abs ty => ty -> ty
  Absolute value.

  Totality: total
  Visibility: public export
interface Fractional : Type -> Type
  Parameters: ty
Constraints: Num ty
Constructor: 
MkFractional

Methods:
  
(/) : ty -> ty -> ty
  Fixity Declaration: infixl operator, level 9
  
recip : ty -> ty

Implementation: 
Fractional Double
(/) : Fractional ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 9
recip : Fractional ty => ty -> ty
  Totality: total
  Visibility: public export
interface Integral : Type -> Type
  Parameters: ty
Constraints: Num ty
Constructor: 
MkIntegral

Methods:
  
div : ty -> ty -> ty
  Fixity Declaration: infixl operator, level 9
  
mod : ty -> ty -> ty
  Fixity Declaration: infixl operator, level 9

Implementations:
  
Integral Integer
  
Integral Int
  
Integral Int8
  
Integral Int16
  
Integral Int32
  
Integral Int64
  
Integral Bits8
  
Integral Bits16
  
Integral Bits32
  
Integral Bits64
div : Integral ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 9
mod : Integral ty => ty -> ty -> ty
  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 9
defaultInteger : Num Integer
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/prelude/docs/Prelude.Ops.html b/prelude/docs/Prelude.Ops.html
index 1851ff1aa8..3ede82e385 100644
--- a/prelude/docs/Prelude.Ops.html
+++ b/prelude/docs/Prelude.Ops.html
@@ -61,4 +61,4 @@
 
 
 
-
Prelude.Ops(source)

\ No newline at end of file
+
Prelude.Ops(source)

\ No newline at end of file
diff --git a/prelude/docs/Prelude.Show.html b/prelude/docs/Prelude.Show.html
index 6111fa6450..2e5ec1ed52 100644
--- a/prelude/docs/Prelude.Show.html
+++ b/prelude/docs/Prelude.Show.html
@@ -61,4 +61,4 @@
 
 
 
-
Prelude.Show(source)
Definitions
data Prec : Type
  The precedence of an Idris operator or syntactic context.

  Totality: total
  Visibility: public export
  Constructors:
  
Open : Prec
  
Equal : Prec
  
Dollar : Prec
  
Backtick : Prec
  
User : Nat -> Prec
  
PrefixMinus : Prec
  
App : Prec

  Hints:
  
Eq Prec
  
Ord Prec
precCon : Prec -> Integer
  Gives the constructor index of the Prec as a helper for writing
  implementations.

  Totality: total
  Visibility: public export
interface Show : Type -> Type
  Things that have a canonical `String` representation.
  A minimal implementation includes either `show` or `showPrec`.

  Parameters: ty
Constructor: 
MkShow

Methods:
  
show : ty -> String
  Convert a value to its `String` representation.
  @ x the value to convert
  
showPrec : Prec -> ty -> String
  Convert a value to its `String` representation in a certain precedence
  context.
  
  A value should produce parentheses around itself if and only if the given
  precedence context is greater than or equal to the precedence of the
  outermost operation represented in the produced `String`.  *This is
  different from Haskell*, which requires it to be strictly greater.  `Open`
  should thus always produce *no* outermost parens, `App` should always
  produce outermost parens except on atomic values and those that provide
  their own bracketing, like `Pair` and `List`.
  @ d the precedence context.
  @ x the value to convert

Implementations:
  
Show Int
  
Show Integer
  
Show Bits8
  
Show Bits16
  
Show Bits32
  
Show Bits64
  
Show Int8
  
Show Int16
  
Show Int32
  
Show Int64
  
Show Double
  
Show Char
  
Show String
  
Show Nat
  
Show Bool
  
Show Void
  
Show ()
  
(Show a, Show b) => Show (a, b)
  
(Show a, Show (p y)) => Show (DPair a p)
  
Show a => Show (List a)
  
Show a => Show (Maybe a)
  
(Show a, Show b) => Show (Either a b)
  
Show Ordering
show : Show ty => ty -> String
  Convert a value to its `String` representation.
  @ x the value to convert

  Totality: total
  Visibility: public export
showPrec : Show ty => Prec -> ty -> String
  Convert a value to its `String` representation in a certain precedence
  context.
  
  A value should produce parentheses around itself if and only if the given
  precedence context is greater than or equal to the precedence of the
  outermost operation represented in the produced `String`.  *This is
  different from Haskell*, which requires it to be strictly greater.  `Open`
  should thus always produce *no* outermost parens, `App` should always
  produce outermost parens except on atomic values and those that provide
  their own bracketing, like `Pair` and `List`.
  @ d the precedence context.
  @ x the value to convert

  Totality: total
  Visibility: public export
showParens : Bool -> String -> String
  Surround a `String` with parentheses depending on a condition.
  @ b whether to add parentheses

  Totality: total
  Visibility: public export
showCon : Prec -> String -> String -> String
  A helper for the common case of showing a non-infix constructor with at
  least one argument, for use with `showArg`.
  
  Apply `showCon` to the precedence context, the constructor name, and the
  args shown with `showArg` and concatenated.  Example:
  ```idris example
  data Ann a = MkAnn String a
  
  Show a => Show (Ann a) where
    showPrec d (MkAnn s x) = showCon d "MkAnn" $ showArg s ++ showArg x
  ```

  Totality: total
  Visibility: public export
showArg : Show a => a -> String
  A helper for the common case of showing a non-infix constructor with at
  least one argument, for use with `showCon`.
  
  This adds a space to the front so the results can be directly concatenated.
  See `showCon` for details and an example.

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Prelude.Show(source)
Definitions
data Prec : Type
  The precedence of an Idris operator or syntactic context.

  Totality: total
  Visibility: public export
  Constructors:
  
Open : Prec
  
Equal : Prec
  
Dollar : Prec
  
Backtick : Prec
  
User : Nat -> Prec
  
PrefixMinus : Prec
  
App : Prec

  Hints:
  
Eq Prec
  
Ord Prec
precCon : Prec -> Integer
  Gives the constructor index of the Prec as a helper for writing
  implementations.

  Totality: total
  Visibility: public export
interface Show : Type -> Type
  Things that have a canonical `String` representation.
  A minimal implementation includes either `show` or `showPrec`.

  Parameters: ty
Constructor: 
MkShow

Methods:
  
show : ty -> String
  Convert a value to its `String` representation.
  @ x the value to convert
  
showPrec : Prec -> ty -> String
  Convert a value to its `String` representation in a certain precedence
  context.
  
  A value should produce parentheses around itself if and only if the given
  precedence context is greater than or equal to the precedence of the
  outermost operation represented in the produced `String`.  *This is
  different from Haskell*, which requires it to be strictly greater.  `Open`
  should thus always produce *no* outermost parens, `App` should always
  produce outermost parens except on atomic values and those that provide
  their own bracketing, like `Pair` and `List`.
  @ d the precedence context.
  @ x the value to convert

Implementations:
  
Show Int
  
Show Integer
  
Show Bits8
  
Show Bits16
  
Show Bits32
  
Show Bits64
  
Show Int8
  
Show Int16
  
Show Int32
  
Show Int64
  
Show Double
  
Show Char
  
Show String
  
Show Nat
  
Show Bool
  
Show Void
  
Show ()
  
(Show a, Show b) => Show (a, b)
  
(Show a, Show (p y)) => Show (DPair a p)
  
Show a => Show (List a)
  
Show a => Show (Maybe a)
  
(Show a, Show b) => Show (Either a b)
  
Show Ordering
show : Show ty => ty -> String
  Convert a value to its `String` representation.
  @ x the value to convert

  Totality: total
  Visibility: public export
showPrec : Show ty => Prec -> ty -> String
  Convert a value to its `String` representation in a certain precedence
  context.
  
  A value should produce parentheses around itself if and only if the given
  precedence context is greater than or equal to the precedence of the
  outermost operation represented in the produced `String`.  *This is
  different from Haskell*, which requires it to be strictly greater.  `Open`
  should thus always produce *no* outermost parens, `App` should always
  produce outermost parens except on atomic values and those that provide
  their own bracketing, like `Pair` and `List`.
  @ d the precedence context.
  @ x the value to convert

  Totality: total
  Visibility: public export
showParens : Bool -> String -> String
  Surround a `String` with parentheses depending on a condition.
  @ b whether to add parentheses

  Totality: total
  Visibility: public export
showCon : Prec -> String -> String -> String
  A helper for the common case of showing a non-infix constructor with at
  least one argument, for use with `showArg`.
  
  Apply `showCon` to the precedence context, the constructor name, and the
  args shown with `showArg` and concatenated.  Example:
  ```idris example
  data Ann a = MkAnn String a
  
  Show a => Show (Ann a) where
    showPrec d (MkAnn s x) = showCon d "MkAnn" $ showArg s ++ showArg x
  ```

  Totality: total
  Visibility: public export
showArg : Show a => a -> String
  A helper for the common case of showing a non-infix constructor with at
  least one argument, for use with `showCon`.
  
  This adds a space to the front so the results can be directly concatenated.
  See `showCon` for details and an example.

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/prelude/docs/Prelude.Types.html b/prelude/docs/Prelude.Types.html
index 7471ea4998..44981fcf14 100644
--- a/prelude/docs/Prelude.Types.html
+++ b/prelude/docs/Prelude.Types.html
@@ -61,4 +61,4 @@
 
 
 
-
Prelude.Types(source)
Definitions
data Nat : Type
  Natural numbers: unbounded, unsigned integers which can be pattern matched.

  Totality: total
  Visibility: public export
  Constructors:
  
Z : Nat
  Zero.
  
S : Nat -> Nat
  Successor.

  Hints:
  
Cast Nat String
  
Cast Nat Integer
  
Cast Nat Int
  
Cast Nat Char
  
Cast Nat Double
  
Cast Nat Bits8
  
Cast Nat Bits16
  
Cast Nat Bits32
  
Cast Nat Bits64
  
Cast Nat Int8
  
Cast Nat Int16
  
Cast Nat Int32
  
Cast Nat Int64
  
Cast String Nat
  
Cast Double Nat
  
Cast Char Nat
  
Cast Int Nat
  
Cast Integer Nat
  
Cast Bits8 Nat
  
Cast Bits16 Nat
  
Cast Bits32 Nat
  
Cast Bits64 Nat
  
Cast Int8 Nat
  
Cast Int16 Nat
  
Cast Int32 Nat
  
Cast Int64 Nat
  
Eq Nat
  
Num Nat
  
Ord Nat
  
Range Nat
  
Show Nat
integerToNat : Integer -> Nat
  Totality: total
  Visibility: public export
plus : Nat -> Nat -> Nat
  Add two natural numbers.
  @ x the number to case-split on
  @ y the other number

  Totality: total
  Visibility: public export
minus : Nat -> Nat -> Nat
  Subtract natural numbers.
  If the second number is larger than the first, return 0.

  Totality: total
  Visibility: public export
mult : Nat -> Nat -> Nat
  Multiply natural numbers.

  Totality: total
  Visibility: public export
equalNat : Nat -> Nat -> Bool
  Totality: total
  Visibility: public export
compareNat : Nat -> Nat -> Ordering
  Totality: total
  Visibility: public export
natToInteger : Nat -> Integer
  Totality: total
  Visibility: public export
count : Foldable t => (a -> Bool) -> t a -> Nat
  Counts the number of elements that satify a predicate.

  Totality: total
  Visibility: public export
data Maybe : Type -> Type
  An optional value.  This can be used to represent the possibility of
  failure, where a function may return a value, or not.

  Totality: total
  Visibility: public export
  Constructors:
  
Nothing : Maybe ty
  No value stored
  
Just : ty -> Maybe ty
  A value of type `ty` is stored

  Hints:
  
Alternative Maybe
  
Applicative Maybe
  
Eq a => Eq (Maybe a)
  
Foldable Maybe
  
Functor Maybe
  
Monad Maybe
  
Monoid (Maybe a)
  
Ord a => Ord (Maybe a)
  
Semigroup (Maybe a)
  
Show a => Show (Maybe a)
  
Traversable Maybe
  
Uninhabited (Nothing = Just x)
  
Uninhabited (Just x = Nothing)
maybe : Lazy b -> Lazy (a -> b) -> Maybe a -> b
  Totality: total
  Visibility: public export
whenJust : Applicative f => Maybe a -> (a -> f ()) -> f ()
  Execute an applicative expression when the Maybe is Just

  Totality: total
  Visibility: public export
record (<=>) : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkEquivalence : (a -> b) -> (b -> a) -> a <=> b

  Projections:
  
.leftToRight : a <=> b -> a -> b
  
.rightToLeft : a <=> b -> b -> a

  Fixity Declaration: infix operator, level 0
.leftToRight : a <=> b -> a -> b
  Totality: total
  Visibility: public export
leftToRight : a <=> b -> a -> b
  Totality: total
  Visibility: public export
.rightToLeft : a <=> b -> b -> a
  Totality: total
  Visibility: public export
rightToLeft : a <=> b -> b -> a
  Totality: total
  Visibility: public export
data Dec : Type -> Type
  Decidability.  A decidable property either holds or is a contradiction.

  Totality: total
  Visibility: public export
  Constructors:
  
Yes : prop -> Dec prop
  The case where the property holds.
  @ prf the proof
  
No : Not prop -> Dec prop
  The case where the property holding would be a contradiction.
  @ contra a demonstration that prop would be a contradiction

  Hints:
  
Uninhabited (Yes p = No q)
  
Uninhabited (No p = Yes q)
viaEquivalence : a <=> b -> Dec a -> Dec b
  Totality: total
  Visibility: public export
data Either : Type -> Type -> Type
  A sum type.

  Totality: total
  Visibility: public export
  Constructors:
  
Left : a -> Either a b
  One possibility of the sum, conventionally used to represent errors.
  
Right : b -> Either a b
  The other possibility, conventionally used to represent success.

  Hints:
  
Applicative (Either e)
  
Bifoldable Either
  
Bifunctor Either
  
Bitraversable Either
  
(Eq a, Eq b) => Eq (Either a b)
  
Foldable (Either e)
  
Functor (Either e)
  
Monad (Either e)
  
(Ord a, Ord b) => Ord (Either a b)
  
(Show a, Show b) => Show (Either a b)
  
Traversable (Either e)
  
Uninhabited (Left p = Right q)
  
Uninhabited (Right p = Left q)
  
Either (Uninhabited a) (Uninhabited b) => Uninhabited (a, b)
  
Uninhabited a => Uninhabited b => Uninhabited (Either a b)
either : Lazy (a -> c) -> Lazy (b -> c) -> Either a b -> c
  Simply-typed eliminator for Either.
  @ f the action to take on Left
  @ g the action to take on Right
  @ e the sum to analyze

  Totality: total
  Visibility: public export
(<><) : SnocList a -> List a -> SnocList a
  'fish': Action of lists on snoc-lists

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 7
(<>>) : SnocList a -> List a -> List a
  'chips': Action of snoc-lists on lists

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 6
(++) : SnocList a -> SnocList a -> SnocList a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
length : SnocList a -> Nat
  Totality: total
  Visibility: public export
filter : (a -> Bool) -> SnocList a -> SnocList a
  Filters a snoc-list according to a simple classifying function

  Totality: total
  Visibility: public export
mapMaybe : (a -> Maybe b) -> SnocList a -> SnocList b
  Apply a partial function to the elements of a list, keeping the ones at which
  it is defined.

  Totality: total
  Visibility: public export
reverseOnto : SnocList a -> SnocList a -> SnocList a
  Reverse the second snoclist, prepending its elements to the first.

  Totality: total
  Visibility: public export
reverse : SnocList a -> SnocList a
  Reverses the given list.

  Totality: total
  Visibility: public export
tailRecAppend : SnocList a -> SnocList a -> SnocList a
  Tail-recursive append. Uses of (++) are automatically transformed to
  this. The only reason this is exported is that the proof of equivalence
  lives in a different module.

  Totality: total
  Visibility: public export
lengthPlus : Nat -> SnocList a -> Nat
  Returns the first argument plus the length of the second.

  Totality: total
  Visibility: public export
lengthTR : SnocList a -> Nat
  `length` implementation that uses tail recursion. Exported so
  lengthTRIsLength can see it.

  Totality: total
  Visibility: public export
mapMaybeAppend : List b -> (a -> Maybe b) -> SnocList a -> SnocList b
  Utility for implementing `mapMaybeTR`

  Totality: total
  Visibility: public export
mapMaybeTR : (a -> Maybe b) -> SnocList a -> SnocList b
  Tail recursive version of `mapMaybe`. This is automatically used
  at runtime due to a `transform` rule.

  Totality: total
  Visibility: public export
filterAppend : List a -> (a -> Bool) -> SnocList a -> SnocList a
  Utility for implementing `filterTR`

  Totality: total
  Visibility: public export
filterTR : (a -> Bool) -> SnocList a -> SnocList a
  Tail recursive version of `filter`. This is automatically used
  at runtime due to a `transform` rule.

  Totality: total
  Visibility: public export
(++) : List a -> List a -> List a
  Concatenate one list with another.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
length : List a -> Nat
  Returns the length of the list.

  Totality: total
  Visibility: public export
filter : (a -> Bool) -> List a -> List a
  Applied to a predicate and a list, returns the list of those elements that
  satisfy the predicate.

  Totality: total
  Visibility: public export
mapMaybe : (a -> Maybe b) -> List a -> List b
  Apply a partial function to the elements of a list, keeping the ones at which it is defined.

  Totality: total
  Visibility: public export
reverseOnto : List a -> List a -> List a
  Reverse the second list, prepending its elements to the first.

  Totality: total
  Visibility: public export
reverse : List a -> List a
  Reverses the given list.

  Totality: total
  Visibility: public export
tailRecAppend : List a -> List a -> List a
  Tail-recursive append. Uses of (++) are automatically transformed to
  this. The only reason this is exported is that the proof of equivalence
  lives in a different module.

  Totality: total
  Visibility: public export
lengthPlus : Nat -> List a -> Nat
  Returns the first argument plus the length of the second.

  Totality: total
  Visibility: public export
lengthTR : List a -> Nat
  `length` implementation that uses tail recursion. Exported so
  lengthTRIsLength can see it.

  Totality: total
  Visibility: public export
mapImpl : (a -> b) -> List a -> List b
  Totality: total
  Visibility: public export
mapAppend : SnocList b -> (a -> b) -> List a -> List b
  Utility for implementing `mapTR`

  Totality: total
  Visibility: public export
mapTR : (a -> b) -> List a -> List b
  Tail recursive version of `map`. This is automatically used
  at runtime due to a `transform` rule.

  Totality: total
  Visibility: public export
mapMaybeAppend : SnocList b -> (a -> Maybe b) -> List a -> List b
  Utility for implementing `mapMaybeTR`

  Totality: total
  Visibility: public export
mapMaybeTR : (a -> Maybe b) -> List a -> List b
  Tail recursive version of `mapMaybe`. This is automatically used
  at runtime due to a `transform` rule.

  Totality: total
  Visibility: public export
filterAppend : SnocList a -> (a -> Bool) -> List a -> List a
  Utility for implementing `filterTR`

  Totality: total
  Visibility: public export
filterTR : (a -> Bool) -> List a -> List a
  Tail recursive version of `filter`. This is automatically used
  at runtime due to a `transform` rule.

  Totality: total
  Visibility: public export
listBindOnto : (a -> List b) -> List b -> List a -> List b
  Totality: total
  Visibility: public export
listBind : List a -> (a -> List b) -> List b
  Totality: total
  Visibility: public export
fastConcat : List String -> String
elemBy : Foldable t => (a -> a -> Bool) -> a -> t a -> Bool
  Check if something is a member of a list using a custom comparison.

  Totality: total
  Visibility: public export
elem : Foldable t => Eq a => a -> t a -> Bool
  Check if something is a member of a list using the default Boolean equality.

  Totality: total
  Visibility: public export
getAt : Nat -> List a -> Maybe a
  Lookup a value at a given position

  Totality: total
  Visibility: export
data Stream : Type -> Type
  An infinite stream.

  Totality: total
  Visibility: public export
  Constructor: 
(::) : a -> Inf (Stream a) -> Stream a

  Hint: 
Functor Stream
head : Stream a -> a
  The first element of an infinite stream.

  Totality: total
  Visibility: public export
tail : Stream a -> Stream a
  All but the first element.

  Totality: total
  Visibility: public export
take : Nat -> Stream a -> List a
  Take precisely n elements from the stream.
  @ n how many elements to take
  @ xs the stream

  Totality: total
  Visibility: public export
(++) : String -> String -> String
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
length : String -> Nat
  Returns the length of the string.
  
  ```idris example
  length ""
  ```
  ```idris example
  length "ABC"
  ```

  Totality: total
  Visibility: public export
reverse : String -> String
  Reverses the elements within a string.
  
  ```idris example
  reverse "ABC"
  ```
  ```idris example
  reverse ""
  ```

  Totality: total
  Visibility: public export
substr : Nat -> Nat -> String -> String
  Returns a substring of a given string
  
  @ index The (zero based) index of the string to extract.  If this is beyond
          the end of the string, the function returns the empty string.
  @ len The desired length of the substring.  Truncated if this exceeds the
        length of the input
  @ subject The string to return a portion of

  Totality: total
  Visibility: public export
strCons : Char -> String -> String
  Adds a character to the front of the specified string.
  
  ```idris example
  strCons 'A' "B"
  ```
  ```idris example
  strCons 'A' ""
  ```

  Totality: total
  Visibility: public export
strUncons : String -> Maybe (Char, String)
  Totality: total
  Visibility: public export
pack : List Char -> String
  Turns a list of characters into a string.

  Totality: total
  Visibility: public export
fastPack : List Char -> String
unpack : String -> List Char
  Turns a string into a list of characters.
  
  ```idris example
  unpack "ABC"
  ```

  Totality: total
  Visibility: public export
fastUnpack : String -> List Char
isUpper : Char -> Bool
  Returns true if the character is in the range [A-Z].

  Totality: total
  Visibility: public export
isLower : Char -> Bool
  Returns true if the character is in the range [a-z].

  Totality: total
  Visibility: public export
isAlpha : Char -> Bool
  Returns true if the character is in the ranges [A-Z][a-z].

  Totality: total
  Visibility: public export
isDigit : Char -> Bool
  Returns true if the character is in the range [0-9].

  Totality: total
  Visibility: public export
isAlphaNum : Char -> Bool
  Returns true if the character is in the ranges [A-Z][a-z][0-9].

  Totality: total
  Visibility: public export
isSpace : Char -> Bool
  Returns true if the character is a whitespace character.

  Totality: total
  Visibility: public export
isNL : Char -> Bool
  Returns true if the character represents a new line.

  Totality: total
  Visibility: public export
toUpper : Char -> Char
  Convert a letter to the corresponding upper-case letter, if any.
  Non-letters are ignored.

  Totality: total
  Visibility: public export
toLower : Char -> Char
  Convert a letter to the corresponding lower-case letter, if any.
  Non-letters are ignored.

  Totality: total
  Visibility: public export
isHexDigit : Char -> Bool
  Returns true if the character is a hexadecimal digit i.e. in the range
  [0-9][a-f][A-F].

  Totality: total
  Visibility: public export
isOctDigit : Char -> Bool
  Returns true if the character is an octal digit.

  Totality: total
  Visibility: public export
isControl : Char -> Bool
  Returns true if the character is a control character.

  Totality: total
  Visibility: public export
chr : Int -> Char
  Convert the number to its backend dependent (usually Unicode) Char
  equivalent.

  Totality: total
  Visibility: public export
ord : Char -> Int
  Return the backend dependent (usually Unicode) numerical equivalent of the Char.

  Totality: total
  Visibility: public export
pi : Double
  Totality: total
  Visibility: public export
euler : Double
  Totality: total
  Visibility: public export
exp : Double -> Double
  Totality: total
  Visibility: public export
log : Double -> Double
  Totality: total
  Visibility: public export
pow : Double -> Double -> Double
  Totality: total
  Visibility: public export
sin : Double -> Double
  Totality: total
  Visibility: public export
cos : Double -> Double
  Totality: total
  Visibility: public export
tan : Double -> Double
  Totality: total
  Visibility: public export
asin : Double -> Double
  Totality: total
  Visibility: public export
acos : Double -> Double
  Totality: total
  Visibility: public export
atan : Double -> Double
  Totality: total
  Visibility: public export
sinh : Double -> Double
  Totality: total
  Visibility: public export
cosh : Double -> Double
  Totality: total
  Visibility: public export
tanh : Double -> Double
  Totality: total
  Visibility: public export
sqrt : Double -> Double
  Totality: total
  Visibility: public export
floor : Double -> Double
  Totality: total
  Visibility: public export
ceiling : Double -> Double
  Totality: total
  Visibility: public export
countFrom : n -> (n -> n) -> Stream n
  Totality: total
  Visibility: public export
takeUntil : (n -> Bool) -> Stream n -> List n
  Visibility: public export
takeBefore : (n -> Bool) -> Stream n -> List n
  Visibility: public export
interface Range : Type -> Type
  Parameters: a
Constructor: 
MkRange

Methods:
  
rangeFromTo : a -> a -> List a
  
rangeFromThenTo : a -> a -> a -> List a
  
rangeFrom : a -> Stream a
  
rangeFromThen : a -> a -> Stream a

Implementations:
  
Range Nat
  
(Integral a, (Ord a, Neg a)) => Range a
  
Range Char
rangeFromTo : Range a => a -> a -> List a
  Totality: total
  Visibility: public export
rangeFromThenTo : Range a => a -> a -> a -> List a
  Totality: total
  Visibility: public export
rangeFrom : Range a => a -> Stream a
  Totality: total
  Visibility: public export
rangeFromThen : Range a => a -> a -> Stream a
  Totality: total
  Visibility: public export

\ No newline at end of file
+
Prelude.Types(source)
Definitions
data Nat : Type
  Natural numbers: unbounded, unsigned integers which can be pattern matched.

  Totality: total
  Visibility: public export
  Constructors:
  
Z : Nat
  Zero.
  
S : Nat -> Nat
  Successor.

  Hints:
  
Cast Nat String
  
Cast Nat Integer
  
Cast Nat Int
  
Cast Nat Char
  
Cast Nat Double
  
Cast Nat Bits8
  
Cast Nat Bits16
  
Cast Nat Bits32
  
Cast Nat Bits64
  
Cast Nat Int8
  
Cast Nat Int16
  
Cast Nat Int32
  
Cast Nat Int64
  
Cast String Nat
  
Cast Double Nat
  
Cast Char Nat
  
Cast Int Nat
  
Cast Integer Nat
  
Cast Bits8 Nat
  
Cast Bits16 Nat
  
Cast Bits32 Nat
  
Cast Bits64 Nat
  
Cast Int8 Nat
  
Cast Int16 Nat
  
Cast Int32 Nat
  
Cast Int64 Nat
  
Eq Nat
  
Num Nat
  
Ord Nat
  
Range Nat
  
Show Nat
integerToNat : Integer -> Nat
  Totality: total
  Visibility: public export
plus : Nat -> Nat -> Nat
  Add two natural numbers.
  @ x the number to case-split on
  @ y the other number

  Totality: total
  Visibility: public export
minus : Nat -> Nat -> Nat
  Subtract natural numbers.
  If the second number is larger than the first, return 0.

  Totality: total
  Visibility: public export
mult : Nat -> Nat -> Nat
  Multiply natural numbers.

  Totality: total
  Visibility: public export
equalNat : Nat -> Nat -> Bool
  Totality: total
  Visibility: public export
compareNat : Nat -> Nat -> Ordering
  Totality: total
  Visibility: public export
natToInteger : Nat -> Integer
  Totality: total
  Visibility: public export
count : Foldable t => (a -> Bool) -> t a -> Nat
  Counts the number of elements that satify a predicate.

  Totality: total
  Visibility: public export
data Maybe : Type -> Type
  An optional value.  This can be used to represent the possibility of
  failure, where a function may return a value, or not.

  Totality: total
  Visibility: public export
  Constructors:
  
Nothing : Maybe ty
  No value stored
  
Just : ty -> Maybe ty
  A value of type `ty` is stored

  Hints:
  
Alternative Maybe
  
Applicative Maybe
  
Eq a => Eq (Maybe a)
  
Foldable Maybe
  
Functor Maybe
  
Monad Maybe
  
Monoid (Maybe a)
  
Ord a => Ord (Maybe a)
  
Semigroup (Maybe a)
  
Show a => Show (Maybe a)
  
Traversable Maybe
  
Uninhabited (Nothing = Just x)
  
Uninhabited (Just x = Nothing)
maybe : Lazy b -> Lazy (a -> b) -> Maybe a -> b
  Totality: total
  Visibility: public export
whenJust : Applicative f => Maybe a -> (a -> f ()) -> f ()
  Execute an applicative expression when the Maybe is Just

  Totality: total
  Visibility: public export
record (<=>) : Type -> Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkEquivalence : (a -> b) -> (b -> a) -> a <=> b

  Projections:
  
.leftToRight : a <=> b -> a -> b
  
.rightToLeft : a <=> b -> b -> a

  Fixity Declaration: infix operator, level 0
.leftToRight : a <=> b -> a -> b
  Totality: total
  Visibility: public export
leftToRight : a <=> b -> a -> b
  Totality: total
  Visibility: public export
.rightToLeft : a <=> b -> b -> a
  Totality: total
  Visibility: public export
rightToLeft : a <=> b -> b -> a
  Totality: total
  Visibility: public export
data Dec : Type -> Type
  Decidability.  A decidable property either holds or is a contradiction.

  Totality: total
  Visibility: public export
  Constructors:
  
Yes : prop -> Dec prop
  The case where the property holds.
  @ prf the proof
  
No : Not prop -> Dec prop
  The case where the property holding would be a contradiction.
  @ contra a demonstration that prop would be a contradiction

  Hints:
  
Uninhabited (Yes p = No q)
  
Uninhabited (No p = Yes q)
viaEquivalence : a <=> b -> Dec a -> Dec b
  Totality: total
  Visibility: public export
data Either : Type -> Type -> Type
  A sum type.

  Totality: total
  Visibility: public export
  Constructors:
  
Left : a -> Either a b
  One possibility of the sum, conventionally used to represent errors.
  
Right : b -> Either a b
  The other possibility, conventionally used to represent success.

  Hints:
  
Applicative (Either e)
  
Bifoldable Either
  
Bifunctor Either
  
Bitraversable Either
  
(Eq a, Eq b) => Eq (Either a b)
  
Foldable (Either e)
  
Functor (Either e)
  
Monad (Either e)
  
(Ord a, Ord b) => Ord (Either a b)
  
(Show a, Show b) => Show (Either a b)
  
Traversable (Either e)
  
Uninhabited (Left p = Right q)
  
Uninhabited (Right p = Left q)
  
Either (Uninhabited a) (Uninhabited b) => Uninhabited (a, b)
  
Uninhabited a => Uninhabited b => Uninhabited (Either a b)
either : Lazy (a -> c) -> Lazy (b -> c) -> Either a b -> c
  Simply-typed eliminator for Either.
  @ f the action to take on Left
  @ g the action to take on Right
  @ e the sum to analyze

  Totality: total
  Visibility: public export
(<><) : SnocList a -> List a -> SnocList a
  'fish': Action of lists on snoc-lists

  Totality: total
  Visibility: public export
  Fixity Declaration: infixl operator, level 7
(<>>) : SnocList a -> List a -> List a
  'chips': Action of snoc-lists on lists

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 6
(++) : SnocList a -> SnocList a -> SnocList a
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
length : SnocList a -> Nat
  Totality: total
  Visibility: public export
filter : (a -> Bool) -> SnocList a -> SnocList a
  Filters a snoc-list according to a simple classifying function

  Totality: total
  Visibility: public export
mapMaybe : (a -> Maybe b) -> SnocList a -> SnocList b
  Apply a partial function to the elements of a list, keeping the ones at which
  it is defined.

  Totality: total
  Visibility: public export
reverseOnto : SnocList a -> SnocList a -> SnocList a
  Reverse the second snoclist, prepending its elements to the first.

  Totality: total
  Visibility: public export
reverse : SnocList a -> SnocList a
  Reverses the given list.

  Totality: total
  Visibility: public export
tailRecAppend : SnocList a -> SnocList a -> SnocList a
  Tail-recursive append. Uses of (++) are automatically transformed to
  this. The only reason this is exported is that the proof of equivalence
  lives in a different module.

  Totality: total
  Visibility: public export
lengthPlus : Nat -> SnocList a -> Nat
  Returns the first argument plus the length of the second.

  Totality: total
  Visibility: public export
lengthTR : SnocList a -> Nat
  `length` implementation that uses tail recursion. Exported so
  lengthTRIsLength can see it.

  Totality: total
  Visibility: public export
mapMaybeAppend : List b -> (a -> Maybe b) -> SnocList a -> SnocList b
  Utility for implementing `mapMaybeTR`

  Totality: total
  Visibility: public export
mapMaybeTR : (a -> Maybe b) -> SnocList a -> SnocList b
  Tail recursive version of `mapMaybe`. This is automatically used
  at runtime due to a `transform` rule.

  Totality: total
  Visibility: public export
filterAppend : List a -> (a -> Bool) -> SnocList a -> SnocList a
  Utility for implementing `filterTR`

  Totality: total
  Visibility: public export
filterTR : (a -> Bool) -> SnocList a -> SnocList a
  Tail recursive version of `filter`. This is automatically used
  at runtime due to a `transform` rule.

  Totality: total
  Visibility: public export
(++) : List a -> List a -> List a
  Concatenate one list with another.

  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
length : List a -> Nat
  Returns the length of the list.

  Totality: total
  Visibility: public export
filter : (a -> Bool) -> List a -> List a
  Applied to a predicate and a list, returns the list of those elements that
  satisfy the predicate.

  Totality: total
  Visibility: public export
mapMaybe : (a -> Maybe b) -> List a -> List b
  Apply a partial function to the elements of a list, keeping the ones at which it is defined.

  Totality: total
  Visibility: public export
reverseOnto : List a -> List a -> List a
  Reverse the second list, prepending its elements to the first.

  Totality: total
  Visibility: public export
reverse : List a -> List a
  Reverses the given list.

  Totality: total
  Visibility: public export
tailRecAppend : List a -> List a -> List a
  Tail-recursive append. Uses of (++) are automatically transformed to
  this. The only reason this is exported is that the proof of equivalence
  lives in a different module.

  Totality: total
  Visibility: public export
lengthPlus : Nat -> List a -> Nat
  Returns the first argument plus the length of the second.

  Totality: total
  Visibility: public export
lengthTR : List a -> Nat
  `length` implementation that uses tail recursion. Exported so
  lengthTRIsLength can see it.

  Totality: total
  Visibility: public export
mapImpl : (a -> b) -> List a -> List b
  Totality: total
  Visibility: public export
mapAppend : SnocList b -> (a -> b) -> List a -> List b
  Utility for implementing `mapTR`

  Totality: total
  Visibility: public export
mapTR : (a -> b) -> List a -> List b
  Tail recursive version of `map`. This is automatically used
  at runtime due to a `transform` rule.

  Totality: total
  Visibility: public export
mapMaybeAppend : SnocList b -> (a -> Maybe b) -> List a -> List b
  Utility for implementing `mapMaybeTR`

  Totality: total
  Visibility: public export
mapMaybeTR : (a -> Maybe b) -> List a -> List b
  Tail recursive version of `mapMaybe`. This is automatically used
  at runtime due to a `transform` rule.

  Totality: total
  Visibility: public export
filterAppend : SnocList a -> (a -> Bool) -> List a -> List a
  Utility for implementing `filterTR`

  Totality: total
  Visibility: public export
filterTR : (a -> Bool) -> List a -> List a
  Tail recursive version of `filter`. This is automatically used
  at runtime due to a `transform` rule.

  Totality: total
  Visibility: public export
listBindOnto : (a -> List b) -> List b -> List a -> List b
  Totality: total
  Visibility: public export
listBind : List a -> (a -> List b) -> List b
  Totality: total
  Visibility: public export
fastConcat : List String -> String
elemBy : Foldable t => (a -> a -> Bool) -> a -> t a -> Bool
  Check if something is a member of a list using a custom comparison.

  Totality: total
  Visibility: public export
elem : Foldable t => Eq a => a -> t a -> Bool
  Check if something is a member of a list using the default Boolean equality.

  Totality: total
  Visibility: public export
getAt : Nat -> List a -> Maybe a
  Lookup a value at a given position

  Totality: total
  Visibility: export
data Stream : Type -> Type
  An infinite stream.

  Totality: total
  Visibility: public export
  Constructor: 
(::) : a -> Inf (Stream a) -> Stream a

  Hint: 
Functor Stream
head : Stream a -> a
  The first element of an infinite stream.

  Totality: total
  Visibility: public export
tail : Stream a -> Stream a
  All but the first element.

  Totality: total
  Visibility: public export
take : Nat -> Stream a -> List a
  Take precisely n elements from the stream.
  @ n how many elements to take
  @ xs the stream

  Totality: total
  Visibility: public export
(++) : String -> String -> String
  Totality: total
  Visibility: public export
  Fixity Declaration: infixr operator, level 7
length : String -> Nat
  Returns the length of the string.
  
  ```idris example
  length ""
  ```
  ```idris example
  length "ABC"
  ```

  Totality: total
  Visibility: public export
reverse : String -> String
  Reverses the elements within a string.
  
  ```idris example
  reverse "ABC"
  ```
  ```idris example
  reverse ""
  ```

  Totality: total
  Visibility: public export
substr : Nat -> Nat -> String -> String
  Returns a substring of a given string
  
  @ index The (zero based) index of the string to extract.  If this is beyond
          the end of the string, the function returns the empty string.
  @ len The desired length of the substring.  Truncated if this exceeds the
        length of the input
  @ subject The string to return a portion of

  Totality: total
  Visibility: public export
strCons : Char -> String -> String
  Adds a character to the front of the specified string.
  
  ```idris example
  strCons 'A' "B"
  ```
  ```idris example
  strCons 'A' ""
  ```

  Totality: total
  Visibility: public export
strUncons : String -> Maybe (Char, String)
  Totality: total
  Visibility: public export
pack : List Char -> String
  Turns a list of characters into a string.

  Totality: total
  Visibility: public export
fastPack : List Char -> String
unpack : String -> List Char
  Turns a string into a list of characters.
  
  ```idris example
  unpack "ABC"
  ```

  Totality: total
  Visibility: public export
fastUnpack : String -> List Char
isUpper : Char -> Bool
  Returns true if the character is in the range [A-Z].

  Totality: total
  Visibility: public export
isLower : Char -> Bool
  Returns true if the character is in the range [a-z].

  Totality: total
  Visibility: public export
isAlpha : Char -> Bool
  Returns true if the character is in the ranges [A-Z][a-z].

  Totality: total
  Visibility: public export
isDigit : Char -> Bool
  Returns true if the character is in the range [0-9].

  Totality: total
  Visibility: public export
isAlphaNum : Char -> Bool
  Returns true if the character is in the ranges [A-Z][a-z][0-9].

  Totality: total
  Visibility: public export
isSpace : Char -> Bool
  Returns true if the character is a whitespace character.

  Totality: total
  Visibility: public export
isNL : Char -> Bool
  Returns true if the character represents a new line.

  Totality: total
  Visibility: public export
toUpper : Char -> Char
  Convert a letter to the corresponding upper-case letter, if any.
  Non-letters are ignored.

  Totality: total
  Visibility: public export
toLower : Char -> Char
  Convert a letter to the corresponding lower-case letter, if any.
  Non-letters are ignored.

  Totality: total
  Visibility: public export
isHexDigit : Char -> Bool
  Returns true if the character is a hexadecimal digit i.e. in the range
  [0-9][a-f][A-F].

  Totality: total
  Visibility: public export
isOctDigit : Char -> Bool
  Returns true if the character is an octal digit.

  Totality: total
  Visibility: public export
isControl : Char -> Bool
  Returns true if the character is a control character.

  Totality: total
  Visibility: public export
chr : Int -> Char
  Convert the number to its backend dependent (usually Unicode) Char
  equivalent.

  Totality: total
  Visibility: public export
ord : Char -> Int
  Return the backend dependent (usually Unicode) numerical equivalent of the Char.

  Totality: total
  Visibility: public export
pi : Double
  Totality: total
  Visibility: public export
euler : Double
  Totality: total
  Visibility: public export
exp : Double -> Double
  Totality: total
  Visibility: public export
log : Double -> Double
  Totality: total
  Visibility: public export
pow : Double -> Double -> Double
  Totality: total
  Visibility: public export
sin : Double -> Double
  Totality: total
  Visibility: public export
cos : Double -> Double
  Totality: total
  Visibility: public export
tan : Double -> Double
  Totality: total
  Visibility: public export
asin : Double -> Double
  Totality: total
  Visibility: public export
acos : Double -> Double
  Totality: total
  Visibility: public export
atan : Double -> Double
  Totality: total
  Visibility: public export
sinh : Double -> Double
  Totality: total
  Visibility: public export
cosh : Double -> Double
  Totality: total
  Visibility: public export
tanh : Double -> Double
  Totality: total
  Visibility: public export
sqrt : Double -> Double
  Totality: total
  Visibility: public export
floor : Double -> Double
  Totality: total
  Visibility: public export
ceiling : Double -> Double
  Totality: total
  Visibility: public export
countFrom : n -> (n -> n) -> Stream n
  Totality: total
  Visibility: public export
takeUntil : (n -> Bool) -> Stream n -> List n
  Visibility: public export
takeBefore : (n -> Bool) -> Stream n -> List n
  Visibility: public export
interface Range : Type -> Type
  Parameters: a
Constructor: 
MkRange

Methods:
  
rangeFromTo : a -> a -> List a
  
rangeFromThenTo : a -> a -> a -> List a
  
rangeFrom : a -> Stream a
  
rangeFromThen : a -> a -> Stream a

Implementations:
  
Range Nat
  
(Integral a, (Ord a, Neg a)) => Range a
  
Range Char
rangeFromTo : Range a => a -> a -> List a
  Totality: total
  Visibility: public export
rangeFromThenTo : Range a => a -> a -> a -> List a
  Totality: total
  Visibility: public export
rangeFrom : Range a => a -> Stream a
  Totality: total
  Visibility: public export
rangeFromThen : Range a => a -> a -> Stream a
  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/prelude/docs/Prelude.Uninhabited.html b/prelude/docs/Prelude.Uninhabited.html
index f3b63f90f6..42c2a879d4 100644
--- a/prelude/docs/Prelude.Uninhabited.html
+++ b/prelude/docs/Prelude.Uninhabited.html
@@ -61,4 +61,4 @@
 
 
 
-
Prelude.Uninhabited(source)
Definitions
interface Uninhabited : Type -> Type
  A canonical proof that some type is empty.

  Parameters: t
Constructor: 
MkUninhabited

Methods:
  
uninhabited : t -> Void
  If I have a t, I've had a contradiction.
  @ t the uninhabited type

Implementations:
  
Uninhabited (Nothing = Just x)
  
Uninhabited (Just x = Nothing)
  
Uninhabited (Yes p = No q)
  
Uninhabited (No p = Yes q)
  
Uninhabited (Left p = Right q)
  
Uninhabited (Right p = Left q)
  
Either (Uninhabited a) (Uninhabited b) => Uninhabited (a, b)
  
Uninhabited a => Uninhabited b => Uninhabited (Either a b)
  
Uninhabited Void
  
Uninhabited (True = False)
  
Uninhabited (False = True)
uninhabited : Uninhabited t => t -> Void
  If I have a t, I've had a contradiction.
  @ t the uninhabited type

  Totality: total
  Visibility: public export
void : (0 _ : Void) -> a
  The eliminator for the `Void` type.

  Totality: total
  Visibility: public export
absurd : Uninhabited t => t -> a
  Use an absurd assumption to discharge a proof obligation.
  @ t some empty type
  @ a the goal type
  @ h the contradictory hypothesis

  Totality: total
  Visibility: public export

\ No newline at end of file
+
Prelude.Uninhabited(source)
Definitions
interface Uninhabited : Type -> Type
  A canonical proof that some type is empty.

  Parameters: t
Constructor: 
MkUninhabited

Methods:
  
uninhabited : t -> Void
  If I have a t, I've had a contradiction.
  @ t the uninhabited type

Implementations:
  
Uninhabited (Nothing = Just x)
  
Uninhabited (Just x = Nothing)
  
Uninhabited (Yes p = No q)
  
Uninhabited (No p = Yes q)
  
Uninhabited (Left p = Right q)
  
Uninhabited (Right p = Left q)
  
Either (Uninhabited a) (Uninhabited b) => Uninhabited (a, b)
  
Uninhabited a => Uninhabited b => Uninhabited (Either a b)
  
Uninhabited Void
  
Uninhabited (True = False)
  
Uninhabited (False = True)
uninhabited : Uninhabited t => t -> Void
  If I have a t, I've had a contradiction.
  @ t the uninhabited type

  Totality: total
  Visibility: public export
void : (0 _ : Void) -> a
  The eliminator for the `Void` type.

  Totality: total
  Visibility: public export
absurd : Uninhabited t => t -> a
  Use an absurd assumption to discharge a proof obligation.
  @ t some empty type
  @ a the goal type
  @ h the contradictory hypothesis

  Totality: total
  Visibility: public export

\ No newline at end of file
diff --git a/prelude/docs/Prelude.html b/prelude/docs/Prelude.html
index 8e73ffd375..3c6b402249 100644
--- a/prelude/docs/Prelude.html
+++ b/prelude/docs/Prelude.html
@@ -61,4 +61,4 @@
 
 
 
-
Prelude(source)
Reexports
import public Builtin
import public PrimIO
import public Prelude.Basics as Prelude
import public Prelude.Cast as Prelude
import public Prelude.EqOrd as Prelude
import public Prelude.Interfaces as Prelude
import public Prelude.Interpolation as Prelude
import public Prelude.IO as Prelude
import public Prelude.Num as Prelude
import public Prelude.Ops as Prelude
import public Prelude.Show as Prelude
import public Prelude.Types as Prelude
import public Prelude.Uninhabited as Prelude

\ No newline at end of file
+
Prelude(source)
Reexports
import public Builtin
import public PrimIO
import public Prelude.Basics as Prelude
import public Prelude.Cast as Prelude
import public Prelude.EqOrd as Prelude
import public Prelude.Interfaces as Prelude
import public Prelude.Interpolation as Prelude
import public Prelude.IO as Prelude
import public Prelude.Num as Prelude
import public Prelude.Ops as Prelude
import public Prelude.Show as Prelude
import public Prelude.Types as Prelude
import public Prelude.Uninhabited as Prelude

\ No newline at end of file
diff --git a/prelude/docs/PrimIO.html b/prelude/docs/PrimIO.html
index ddd419971f..98d2a86cf5 100644
--- a/prelude/docs/PrimIO.html
+++ b/prelude/docs/PrimIO.html
@@ -61,4 +61,4 @@
 
 
 
-
PrimIO(source)
Definitions
data IORes : Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkIORes : a -> (1 _ : %World) -> IORes a
PrimIO : Type -> Type
  Idris's primitive IO, for building abstractions on top of.

  Totality: total
  Visibility: public export
data IO : Type -> Type
  The internal representation of I/O computations.

  Totality: total
  Visibility: export
  Constructor: 
MkIO : (1 _ : PrimIO a) -> IO a
prim__io_pure : a -> PrimIO a
  Totality: total
  Visibility: export
io_pure : a -> IO a
  Totality: total
  Visibility: export
prim__io_bind : (1 _ : PrimIO a) -> (1 _ : (a -> PrimIO b)) -> PrimIO b
  Totality: total
  Visibility: export
io_bind : (1 _ : IO a) -> (1 _ : (a -> IO b)) -> IO b
  Totality: total
  Visibility: export
data Ptr : Type -> Type
  Totality: total
  Visibility: public export
data AnyPtr : Type
  Totality: total
  Visibility: public export
data GCPtr : Type -> Type
  Totality: total
  Visibility: public export
data GCAnyPtr : Type
  Totality: total
  Visibility: public export
data ThreadID : Type
  Totality: total
  Visibility: public export
fromPrim : (1 _ : ((1 _ : %World) -> IORes a)) -> IO a
  Totality: total
  Visibility: export
toPrim : (1 _ : IO a) -> PrimIO a
  Totality: total
  Visibility: export
prim__nullAnyPtr : AnyPtr -> Int
prim__getNullAnyPtr : AnyPtr
prim__castPtr : AnyPtr -> Ptr t
  Totality: total
  Visibility: export
prim__forgetPtr : Ptr t -> AnyPtr
  Totality: total
  Visibility: export
prim__nullPtr : Ptr t -> Int
  Totality: total
  Visibility: export
unsafePerformIO : IO a -> a
  Totality: total
  Visibility: export

\ No newline at end of file
+
PrimIO(source)
Definitions
data IORes : Type -> Type
  Totality: total
  Visibility: public export
  Constructor: 
MkIORes : a -> (1 _ : %World) -> IORes a
PrimIO : Type -> Type
  Idris's primitive IO, for building abstractions on top of.

  Totality: total
  Visibility: public export
data IO : Type -> Type
  The internal representation of I/O computations.

  Totality: total
  Visibility: export
  Constructor: 
MkIO : (1 _ : PrimIO a) -> IO a
prim__io_pure : a -> PrimIO a
  Totality: total
  Visibility: export
io_pure : a -> IO a
  Totality: total
  Visibility: export
prim__io_bind : (1 _ : PrimIO a) -> (1 _ : (a -> PrimIO b)) -> PrimIO b
  Totality: total
  Visibility: export
io_bind : (1 _ : IO a) -> (1 _ : (a -> IO b)) -> IO b
  Totality: total
  Visibility: export
data Ptr : Type -> Type
  Totality: total
  Visibility: public export
data AnyPtr : Type
  Totality: total
  Visibility: public export
data GCPtr : Type -> Type
  Totality: total
  Visibility: public export
data GCAnyPtr : Type
  Totality: total
  Visibility: public export
data ThreadID : Type
  Totality: total
  Visibility: public export
fromPrim : (1 _ : ((1 _ : %World) -> IORes a)) -> IO a
  Totality: total
  Visibility: export
toPrim : (1 _ : IO a) -> PrimIO a
  Totality: total
  Visibility: export
prim__nullAnyPtr : AnyPtr -> Int
prim__getNullAnyPtr : AnyPtr
prim__castPtr : AnyPtr -> Ptr t
  Totality: total
  Visibility: export
prim__forgetPtr : Ptr t -> AnyPtr
  Totality: total
  Visibility: export
prim__nullPtr : Ptr t -> Int
  Totality: total
  Visibility: export
unsafePerformIO : IO a -> a
  Totality: total
  Visibility: export

\ No newline at end of file
diff --git a/prelude/index.html b/prelude/index.html
index f7937be0de..40a6e2fc36 100644
--- a/prelude/index.html
+++ b/prelude/index.html
@@ -61,4 +61,4 @@
 
 
 
-
Package prelude - Namespaces

\ No newline at end of file
+
Package prelude - Namespaces

\ No newline at end of file
diff --git a/test/docs/Test.Golden.html b/test/docs/Test.Golden.html
index ebd52a11da..32fe516355 100644
--- a/test/docs/Test.Golden.html
+++ b/test/docs/Test.Golden.html
@@ -131,4 +131,4 @@
 ```
 
 assuming that the test runner is compiled to an executable named `runtests`.
-
Definitions
record Options : Type
  Options for the test driver.

  Totality: total
  Visibility: public export
  Constructor: 
MkOptions : String -> Maybe String -> Maybe (String -> Bool) -> Bool -> Bool -> Bool -> Nat -> Maybe String -> Options

  Projections:
  
.codegen : Options -> Maybe String
  Which codegen should we use?
  
.color : Options -> Bool
  Should we use colors?
  
.exeUnderTest : Options -> String
  Name of the idris2 executable
  
.failureFile : Options -> Maybe String
  Should we write the list of failing cases to a file?
  
.interactive : Options -> Bool
  Should we run the test suite interactively?
  
.onlyNames : Options -> Maybe (String -> Bool)
  Should we only run some specific cases?
  
.threads : Options -> Nat
  How many threads should we use?
  
.timing : Options -> Bool
  Should we time and display the tests
.exeUnderTest : Options -> String
  Name of the idris2 executable

  Visibility: public export
exeUnderTest : Options -> String
  Name of the idris2 executable

  Visibility: public export
.codegen : Options -> Maybe String
  Which codegen should we use?

  Visibility: public export
codegen : Options -> Maybe String
  Which codegen should we use?

  Visibility: public export
.onlyNames : Options -> Maybe (String -> Bool)
  Should we only run some specific cases?

  Visibility: public export
onlyNames : Options -> Maybe (String -> Bool)
  Should we only run some specific cases?

  Visibility: public export
.interactive : Options -> Bool
  Should we run the test suite interactively?

  Visibility: public export
interactive : Options -> Bool
  Should we run the test suite interactively?

  Visibility: public export
.color : Options -> Bool
  Should we use colors?

  Visibility: public export
color : Options -> Bool
  Should we use colors?

  Visibility: public export
.timing : Options -> Bool
  Should we time and display the tests

  Visibility: public export
timing : Options -> Bool
  Should we time and display the tests

  Visibility: public export
.threads : Options -> Nat
  How many threads should we use?

  Visibility: public export
threads : Options -> Nat
  How many threads should we use?

  Visibility: public export
.failureFile : Options -> Maybe String
  Should we write the list of failing cases to a file?

  Visibility: public export
failureFile : Options -> Maybe String
  Should we write the list of failing cases to a file?

  Visibility: public export
initOptions : String -> Bool -> Options
  Visibility: export
usage : String
  Visibility: export
options : List String -> IO (Maybe Options)
  Process the command line options.

  Visibility: export
runTest : Options -> String -> IO Result
  Run the specified Golden test with the supplied options.
  See the module documentation for more information.
  @testPath the directory that contains the test.

  Visibility: export
pathLookup : List String -> IO (Maybe String)
  Find the first occurrence of an executable on `PATH`.

  Visibility: export
data Requirement : Type
  Some test may involve Idris' backends and have requirements.
  We define here the ones supported by Idris

  Totality: total
  Visibility: public export
  Constructors:
  
C : Requirement
  
Chez : Requirement
  
Node : Requirement
  
Racket : Requirement
  
Gambit : Requirement

  Hints:
  
Eq Requirement
  
Show Requirement
checkRequirement : Requirement -> IO (Maybe String)
  Visibility: export
findCG : IO (Maybe String)
  Visibility: export
data Codegen : Type
  A choice of a codegen

  Totality: total
  Visibility: public export
  Constructors:
  
Nothing : Codegen
  Do NOT pass a cg argument to the executable being tested
  
Default : Codegen
  Use whatever the test runner was passed at the toplevel,
  and if nothing was passed guess a sensible default using findCG
  
Just : Requirement -> Codegen
  Use exactly the given requirement
toList : Codegen -> List Requirement
  Visibility: export
record TestPool : Type
  A test pool is characterised by
   + a name
   + a list of requirement
   + a choice of codegen (overriding the default)
   + and a list of directory paths

  Totality: total
  Visibility: public export
  Constructor: 
MkTestPool : String -> List Requirement -> Codegen -> List String -> TestPool

  Projections:
  
.codegen : TestPool -> Codegen
  
.constraints : TestPool -> List Requirement
  
.poolName : TestPool -> String
  
.testCases : TestPool -> List String
.poolName : TestPool -> String
  Visibility: public export
poolName : TestPool -> String
  Visibility: public export
.constraints : TestPool -> List Requirement
  Visibility: public export
constraints : TestPool -> List Requirement
  Visibility: public export
.codegen : TestPool -> Codegen
  Visibility: public export
codegen : TestPool -> Codegen
  Visibility: public export
.testCases : TestPool -> List String
  Visibility: public export
testCases : TestPool -> List String
  Visibility: public export
testsInDir : String -> {default (const True) _ : (String -> Bool)} -> String -> {default [] _ : List Requirement} -> {default Nothing _ : Codegen} -> IO TestPool
  Find all the test in the given directory.

  Visibility: export
filterTests : Options -> List String -> List String
  Only keep the tests that have been asked for

  Visibility: export
record Summary : Type
  The summary of a test pool run

  Totality: total
  Visibility: public export
  Constructor: 
MkSummary : List String -> List String -> Summary

  Projections:
  
.failure : Summary -> List String
  
.success : Summary -> List String

  Hints:
  
Monoid Summary
  
Semigroup Summary
.success : Summary -> List String
  Visibility: public export
success : Summary -> List String
  Visibility: public export
.failure : Summary -> List String
  Visibility: public export
failure : Summary -> List String
  Visibility: public export
initSummary : Summary
  A new, blank summary

  Visibility: export
updateSummary : Result -> Summary -> Summary
  Update the summary to contain the given result

  Visibility: export
bulkUpdateSummary : List Result -> Summary -> Summary
  Update the summary to contain the given results

  Visibility: export
data ThreadInstruction : Type
  An instruction to a thread which runs tests

  Totality: total
  Visibility: public export
  Constructors:
  
Run : String -> ThreadInstruction
  A test to run
  
Stop : ThreadInstruction
  An indication for the thread to stop
testSender : Channel ThreadInstruction -> Nat -> List String -> IO ()
  Sends the given tests on the given @Channel@, then sends `nThreads` many
  'Stop' @ThreadInstruction@s to stop the threads running the tests.
  
  @testChan The channel to send the tests over.
  @nThreads The number of threads being used to run the tests.
  @tests The list of tests to send to the runners/threads.

  Visibility: export
data ThreadResult : Type
  A result from a test-runner/thread

  Totality: total
  Visibility: public export
  Constructors:
  
Res : Result -> ThreadResult
  The result of running a test
  
Done : ThreadResult
  An indication that the thread was told to stop
testReceiver : Channel ThreadResult -> Summary -> Channel Summary -> Nat -> IO ()
  Receives results on the given @Channel@, accumulating them as a @Summary@.
  When all results have been received (i.e. @nThreads@ many 'Done'
  @ThreadInstruction@s have been encountered), send the resulting Summary over
  the @accChan@ Channel (necessary to be able to @fork@ this function and
  still obtain the Summary at the end).
  
  @resChan The channel to receives the results on.
  @acc The Summary acting as an accumulator.
  @accChan The Channel to send the final Summary over.
  @nThreads The number of threads being used to run the tests.

  Visibility: export
poolRunner : Options -> TestPool -> IO Summary
  A runner for a test pool. If there are tests in the @TestPool@ that we want
  to run, spawns `opts.threads` many runners and sends them the tests,
  collecting all the results in the @Summary@ returned at the end.
  
  @opts The options for the TestPool.
  @pool The TestPool to run.

  Visibility: export
runnerWith : Options -> List TestPool -> IO ()
  Visibility: export
runner : List TestPool -> IO ()
  A runner for a whole test suite

  Visibility: export

\ No newline at end of file
+
Definitions
record Options : Type
  Options for the test driver.

  Totality: total
  Visibility: public export
  Constructor: 
MkOptions : String -> Maybe String -> Maybe (String -> Bool) -> Bool -> Bool -> Bool -> Nat -> Maybe String -> Options

  Projections:
  
.codegen : Options -> Maybe String
  Which codegen should we use?
  
.color : Options -> Bool
  Should we use colors?
  
.exeUnderTest : Options -> String
  Name of the idris2 executable
  
.failureFile : Options -> Maybe String
  Should we write the list of failing cases to a file?
  
.interactive : Options -> Bool
  Should we run the test suite interactively?
  
.onlyNames : Options -> Maybe (String -> Bool)
  Should we only run some specific cases?
  
.threads : Options -> Nat
  How many threads should we use?
  
.timing : Options -> Bool
  Should we time and display the tests
.exeUnderTest : Options -> String
  Name of the idris2 executable

  Visibility: public export
exeUnderTest : Options -> String
  Name of the idris2 executable

  Visibility: public export
.codegen : Options -> Maybe String
  Which codegen should we use?

  Visibility: public export
codegen : Options -> Maybe String
  Which codegen should we use?

  Visibility: public export
.onlyNames : Options -> Maybe (String -> Bool)
  Should we only run some specific cases?

  Visibility: public export
onlyNames : Options -> Maybe (String -> Bool)
  Should we only run some specific cases?

  Visibility: public export
.interactive : Options -> Bool
  Should we run the test suite interactively?

  Visibility: public export
interactive : Options -> Bool
  Should we run the test suite interactively?

  Visibility: public export
.color : Options -> Bool
  Should we use colors?

  Visibility: public export
color : Options -> Bool
  Should we use colors?

  Visibility: public export
.timing : Options -> Bool
  Should we time and display the tests

  Visibility: public export
timing : Options -> Bool
  Should we time and display the tests

  Visibility: public export
.threads : Options -> Nat
  How many threads should we use?

  Visibility: public export
threads : Options -> Nat
  How many threads should we use?

  Visibility: public export
.failureFile : Options -> Maybe String
  Should we write the list of failing cases to a file?

  Visibility: public export
failureFile : Options -> Maybe String
  Should we write the list of failing cases to a file?

  Visibility: public export
initOptions : String -> Bool -> Options
  Visibility: export
usage : String
  Visibility: export
options : List String -> IO (Maybe Options)
  Process the command line options.

  Visibility: export
runTest : Options -> String -> IO Result
  Run the specified Golden test with the supplied options.
  See the module documentation for more information.
  @testPath the directory that contains the test.

  Visibility: export
pathLookup : List String -> IO (Maybe String)
  Find the first occurrence of an executable on `PATH`.

  Visibility: export
data Requirement : Type
  Some test may involve Idris' backends and have requirements.
  We define here the ones supported by Idris

  Totality: total
  Visibility: public export
  Constructors:
  
C : Requirement
  
Chez : Requirement
  
Node : Requirement
  
Racket : Requirement
  
Gambit : Requirement

  Hints:
  
Eq Requirement
  
Show Requirement
checkRequirement : Requirement -> IO (Maybe String)
  Visibility: export
findCG : IO (Maybe String)
  Visibility: export
data Codegen : Type
  A choice of a codegen

  Totality: total
  Visibility: public export
  Constructors:
  
Nothing : Codegen
  Do NOT pass a cg argument to the executable being tested
  
Default : Codegen
  Use whatever the test runner was passed at the toplevel,
  and if nothing was passed guess a sensible default using findCG
  
Just : Requirement -> Codegen
  Use exactly the given requirement
toList : Codegen -> List Requirement
  Visibility: export
record TestPool : Type
  A test pool is characterised by
   + a name
   + a list of requirement
   + a choice of codegen (overriding the default)
   + and a list of directory paths

  Totality: total
  Visibility: public export
  Constructor: 
MkTestPool : String -> List Requirement -> Codegen -> List String -> TestPool

  Projections:
  
.codegen : TestPool -> Codegen
  
.constraints : TestPool -> List Requirement
  
.poolName : TestPool -> String
  
.testCases : TestPool -> List String
.poolName : TestPool -> String
  Visibility: public export
poolName : TestPool -> String
  Visibility: public export
.constraints : TestPool -> List Requirement
  Visibility: public export
constraints : TestPool -> List Requirement
  Visibility: public export
.codegen : TestPool -> Codegen
  Visibility: public export
codegen : TestPool -> Codegen
  Visibility: public export
.testCases : TestPool -> List String
  Visibility: public export
testCases : TestPool -> List String
  Visibility: public export
testsInDir : String -> {default (const True) _ : (String -> Bool)} -> String -> {default [] _ : List Requirement} -> {default Nothing _ : Codegen} -> IO TestPool
  Find all the test in the given directory.

  Visibility: export
filterTests : Options -> List String -> List String
  Only keep the tests that have been asked for

  Visibility: export
record Summary : Type
  The summary of a test pool run

  Totality: total
  Visibility: public export
  Constructor: 
MkSummary : List String -> List String -> Summary

  Projections:
  
.failure : Summary -> List String
  
.success : Summary -> List String

  Hints:
  
Monoid Summary
  
Semigroup Summary
.success : Summary -> List String
  Visibility: public export
success : Summary -> List String
  Visibility: public export
.failure : Summary -> List String
  Visibility: public export
failure : Summary -> List String
  Visibility: public export
initSummary : Summary
  A new, blank summary

  Visibility: export
updateSummary : Result -> Summary -> Summary
  Update the summary to contain the given result

  Visibility: export
bulkUpdateSummary : List Result -> Summary -> Summary
  Update the summary to contain the given results

  Visibility: export
data ThreadInstruction : Type
  An instruction to a thread which runs tests

  Totality: total
  Visibility: public export
  Constructors:
  
Run : String -> ThreadInstruction
  A test to run
  
Stop : ThreadInstruction
  An indication for the thread to stop
testSender : Channel ThreadInstruction -> Nat -> List String -> IO ()
  Sends the given tests on the given @Channel@, then sends `nThreads` many
  'Stop' @ThreadInstruction@s to stop the threads running the tests.
  
  @testChan The channel to send the tests over.
  @nThreads The number of threads being used to run the tests.
  @tests The list of tests to send to the runners/threads.

  Visibility: export
data ThreadResult : Type
  A result from a test-runner/thread

  Totality: total
  Visibility: public export
  Constructors:
  
Res : Result -> ThreadResult
  The result of running a test
  
Done : ThreadResult
  An indication that the thread was told to stop
testReceiver : Channel ThreadResult -> Summary -> Channel Summary -> Nat -> IO ()
  Receives results on the given @Channel@, accumulating them as a @Summary@.
  When all results have been received (i.e. @nThreads@ many 'Done'
  @ThreadInstruction@s have been encountered), send the resulting Summary over
  the @accChan@ Channel (necessary to be able to @fork@ this function and
  still obtain the Summary at the end).
  
  @resChan The channel to receives the results on.
  @acc The Summary acting as an accumulator.
  @accChan The Channel to send the final Summary over.
  @nThreads The number of threads being used to run the tests.

  Visibility: export
poolRunner : Options -> TestPool -> IO Summary
  A runner for a test pool. If there are tests in the @TestPool@ that we want
  to run, spawns `opts.threads` many runners and sends them the tests,
  collecting all the results in the @Summary@ returned at the end.
  
  @opts The options for the TestPool.
  @pool The TestPool to run.

  Visibility: export
runnerWith : Options -> List TestPool -> IO ()
  Visibility: export
runner : List TestPool -> IO ()
  A runner for a whole test suite

  Visibility: export

\ No newline at end of file
diff --git a/test/index.html b/test/index.html
index b1522b0758..bfa085f3df 100644
--- a/test/index.html
+++ b/test/index.html
@@ -61,4 +61,4 @@
 
 
 
-
Package test - Namespaces

\ No newline at end of file
+
Package test - Namespaces

\ No newline at end of file