Constants

   (      A      B      C      D      E      F      G      I      J      L      M      N      O      P      R      S      T      U      V      Z   

• ($)
  • Prelude.($) (alias for Prelude.Function.($))

    Prelude.Function.($)
       constant
       type `('a -> 'b) -> 'a -> 'b`
       executable

  • Prelude.Function.($)

    Prelude.Function.($)
       constant
       type `('a -> 'b) -> 'a -> 'b`
       executable

• (&&)
  • Prelude.(&&) (alias for Prelude.Bool.(&&))

    Prelude.Bool.(&&)
       constant
       type `Bool -> Bool -> Bool`
       executable

  • Prelude.Bool.(&&)

    Prelude.Bool.(&&)
       constant
       type `Bool -> Bool -> Bool`
       executable

• (*)
  • Prelude.(*) (alias for Prelude.Num.(*))

    Prelude.Num.(*)
       constant of type-class `NumMult`
       type `'a -> 'a -> 'a`
       executable

  • Prelude.Num.(*)

    Prelude.Num.(*)
       constant of type-class `NumMult`
       type `'a -> 'a -> 'a`
       executable

• (+)
  • Prelude.(+) (alias for Prelude.Num.(+))

    Prelude.Num.(+)
       constant of type-class `NumPlus`
       type `'a -> 'a -> 'a`
       executable

  • Prelude.Num.(+)

    Prelude.Num.(+)
       constant of type-class `NumPlus`
       type `'a -> 'a -> 'a`
       executable

• (++)
  • Data.List.(++) (alias for Prelude.List.(++))

    Prelude.List.(++)
       constant
       type `['a] -> ['a] -> ['a]`
       executable

  • Prelude.(++) (alias for Prelude.List.(++))

    Prelude.List.(++)
       constant
       type `['a] -> ['a] -> ['a]`
       executable

  • Prelude.List.(++)

    Prelude.List.(++)
       constant
       type `['a] -> ['a] -> ['a]`
       executable

• (-)
  • Prelude.(-) (alias for Prelude.Num.(-))

    Prelude.Num.(-)
       constant of type-class `NumMinus`
       type `'a -> 'a -> 'a`
       executable

  • Prelude.Num.(-)

    Prelude.Num.(-)
       constant of type-class `NumMinus`
       type `'a -> 'a -> 'a`
       executable

• (-->)
  • Prelude.(-->) (alias for Prelude.Bool.(-->))

    Prelude.Bool.(-->)
       constant
       type `Bool -> Bool -> Bool`
       executable

  • Prelude.Bool.(-->)

    Prelude.Bool.(-->)
       constant
       type `Bool -> Bool -> Bool`
       executable

• (.)
  • Prelude.(.) (alias for Prelude.Function.(.))

    Prelude.Function.(.)
       constant of type-class `Dot`
       type `'a -> 'b -> 'c`
       executable

  • Prelude.Function.(.)

    Prelude.Function.(.)
       constant of type-class `Dot`
       type `'a -> 'b -> 'c`
       executable

• (/)
  • Prelude.(/) (alias for Prelude.Num.(/))

    Prelude.Num.(/)
       constant of type-class `NumDiv`
       type `'a -> 'a -> 'a`
       executable

  • Prelude.Num.(/)

    Prelude.Num.(/)
       constant of type-class `NumDiv`
       type `'a -> 'a -> 'a`
       executable

• (/=)
  • Prelude.(/=) (alias for Prelude.Eq.(/=))

    Prelude.Eq.(/=)
       constant of type-class `Eq`
       type `'a -> 'a -> Bool`
       executable

  • Prelude.Eq.(/=)

    Prelude.Eq.(/=)
       constant of type-class `Eq`
       type `'a -> 'a -> Bool`
       executable

• (/\)
  • Prelude.(/\) (alias for Prelude.Bool.(/\))

    Prelude.Bool.(/\)
       constant
       type `Prop -> Prop -> Prop`
       non executable

  • Prelude.Bool.(/\)

    Prelude.Bool.(/\)
       constant
       type `Prop -> Prop -> Prop`
       non executable

• (:)
  • Data.List.(:) (alias for Prelude.List.(:))

    Prelude.List.(:)
       constructor of datatype `List`
       type `'a -> ['a] -> ['a]`
       executable

  • Prelude.(:) (alias for Prelude.List.(:))

    Prelude.List.(:)
       constructor of datatype `List`
       type `'a -> ['a] -> ['a]`
       executable

  • Prelude.List.(:)

    Prelude.List.(:)
       constructor of datatype `List`
       type `'a -> ['a] -> ['a]`
       executable

• (<$>)
  • Prelude.(<$>) (alias for Prelude.Functor.fmap)

    Prelude.Functor.fmap
       statically resolved constant of type-class `Functor`
       type `('a -> 'b) -> 'F 'a -> 'F 'b`
       executable

  • Prelude.Functor.(<$>) (alias for Prelude.Functor.fmap)

    Prelude.Functor.fmap
       statically resolved constant of type-class `Functor`
       type `('a -> 'b) -> 'F 'a -> 'F 'b`
       executable

• (<)
  • Prelude.(<) (alias for Prelude.Ord.(<))

    Prelude.Ord.(<)
       constant of type-class `Ord`
       type `'a -> 'a -> Bool`
       executable

  • Prelude.Ord.(<)

    Prelude.Ord.(<)
       constant of type-class `Ord`
       type `'a -> 'a -> Bool`
       executable

• (<-/->)
  • Prelude.(<-/->) (alias for Prelude.Bool.(<-/->))

    Prelude.Bool.(<-/->)
       constant
       type `Bool -> Bool -> Bool`
       executable

  • Prelude.Bool.(<-/->)

    Prelude.Bool.(<-/->)
       constant
       type `Bool -> Bool -> Bool`
       executable

• (<->)
  • Prelude.(<->) (alias for Prelude.Bool.(<->))

    Prelude.Bool.(<->)
       constant
       type `Bool -> Bool -> Bool`
       executable

  • Prelude.Bool.(<->)

    Prelude.Bool.(<->)
       constant
       type `Bool -> Bool -> Bool`
       executable

• (<=)
  • Prelude.(<=) (alias for Prelude.Ord.(<=))

    Prelude.Ord.(<=)
       constant of type-class `Ord`
       type `'a -> 'a -> Bool`
       executable

  • Prelude.Ord.(<=)

    Prelude.Ord.(<=)
       constant of type-class `Ord`
       type `'a -> 'a -> Bool`
       executable

• (<=/=>)
  • Prelude.(<=/=>) (alias for Prelude.Bool.(<=/=>))

    Prelude.Bool.(<=/=>)
       constant
       type `Prop -> Prop -> Prop`
       non executable

  • Prelude.Bool.(<=/=>)

    Prelude.Bool.(<=/=>)
       constant
       type `Prop -> Prop -> Prop`
       non executable

• (<=>)
  • Prelude.(<=>) (alias for Prelude.Bool.(<=>))

    Prelude.Bool.(<=>)
       constant
       type `Prop -> Prop -> Prop`
       non executable

  • Prelude.Bool.(<=>)

    Prelude.Bool.(<=>)
       constant
       type `Prop -> Prop -> Prop`
       non executable

• (<>)
  • Prelude.(<>) (alias for Prelude.BasicClasses.(<>))

    Prelude.BasicClasses.(<>)
       constant of type-class `Semigroup`
       type `'a -> 'a -> 'a`
       executable

  • Prelude.BasicClasses.(<>)

    Prelude.BasicClasses.(<>)
       constant of type-class `Semigroup`
       type `'a -> 'a -> 'a`
       executable

• (=/=)
  • Prelude.(=/=) (alias for Prelude.Eq.(=/=))

    Prelude.Eq.(=/=)
       constant of type-class `EqP`
       type `'a -> 'a -> Prop`
       non executable

  • Prelude.Eq.(=/=)

    Prelude.Eq.(=/=)
       constant of type-class `EqP`
       type `'a -> 'a -> Prop`
       non executable

• (=<<)
  • Prelude.(=<<) (alias for Prelude.Monad.(=<<))

    Prelude.Monad.(=<<)
       constant
       type `('a -> 'M 'b) -> 'M 'a -> 'M 'b`
       executable

  • Prelude.Monad.(=<<)

    Prelude.Monad.(=<<)
       constant
       type `('a -> 'M 'b) -> 'M 'a -> 'M 'b`
       executable

• (==)
  • Prelude.(==) (alias for Prelude.Eq.(==))

    Prelude.Eq.(==)
       constant of type-class `Eq`
       type `'a -> 'a -> Bool`
       executable

  • Prelude.Eq.(==)

    Prelude.Eq.(==)
       constant of type-class `Eq`
       type `'a -> 'a -> Bool`
       executable

• (===)
  • Prelude.(===) (alias for Prelude.Eq.(===))

    Prelude.Eq.(===)
       constant of type-class `EqP`
       type `'a -> 'a -> Prop`
       non executable

  • Prelude.Eq.(===)

    Prelude.Eq.(===)
       constant of type-class `EqP`
       type `'a -> 'a -> Prop`
       non executable

• (====)
  • Prelude.(====) (alias for Prelude.Eq.(====))

    Prelude.Eq.(====)
       constant
       type `'a -> 'a -> Prop`
       non executable

  • Prelude.Eq.(====)

    Prelude.Eq.(====)
       constant
       type `'a -> 'a -> Prop`
       non executable

• (==>)
  • Prelude.(==>) (alias for Prelude.Bool.(==>))

    Prelude.Bool.(==>)
       constant
       type `Prop -> Prop -> Prop`
       non executable

  • Prelude.Bool.(==>)

    Prelude.Bool.(==>)
       constant
       type `Prop -> Prop -> Prop`
       non executable

• (>)
  • Prelude.(>) (alias for Prelude.Ord.(>))

    Prelude.Ord.(>)
       constant of type-class `Ord`
       type `'a -> 'a -> Bool`
       executable

  • Prelude.Ord.(>)

    Prelude.Ord.(>)
       constant of type-class `Ord`
       type `'a -> 'a -> Bool`
       executable

• (>=)
  • Prelude.(>=) (alias for Prelude.Ord.(>=))

    Prelude.Ord.(>=)
       constant of type-class `Ord`
       type `'a -> 'a -> Bool`
       executable

  • Prelude.Ord.(>=)

    Prelude.Ord.(>=)
       constant of type-class `Ord`
       type `'a -> 'a -> Bool`
       executable

• (>>)
  • Prelude.(>>) (alias for Prelude.Monad.(>>))

    Prelude.Monad.(>>)
       statically resolved constant of type-class `Monad`
       type `'M 'a -> 'M 'b -> 'M 'b`
       executable

  • Prelude.Monad.(>>)

    Prelude.Monad.(>>)
       statically resolved constant of type-class `Monad`
       type `'M 'a -> 'M 'b -> 'M 'b`
       executable

• (>>=)
  • Prelude.(>>=) (alias for Prelude.Monad.(>>=))

    Prelude.Monad.(>>=)
       statically resolved constant of type-class `Monad`
       type `'M 'a -> ('a -> 'M 'b) -> 'M 'b`
       executable

  • Prelude.Monad.(>>=)

    Prelude.Monad.(>>=)
       statically resolved constant of type-class `Monad`
       type `'M 'a -> ('a -> 'M 'b) -> 'M 'b`
       executable

• (\/)
  • Prelude.(\/) (alias for Prelude.Bool.(\/))

    Prelude.Bool.(\/)
       constant
       type `Prop -> Prop -> Prop`
       non executable

  • Prelude.Bool.(\/)

    Prelude.Bool.(\/)
       constant
       type `Prop -> Prop -> Prop`
       non executable

• (^.)
  • Data.Lens.(^.) (alias for Data.Lens.view)

    Data.Lens.view
       constant of type-class `Data.Lens.IsGetter`
       type `'v -> 'a -> 'b`
       executable

• (||)
  • Prelude.(||) (alias for Prelude.Bool.(||))

    Prelude.Bool.(||)
       constant
       type `Bool -> Bool -> Bool`
       executable

  • Prelude.Bool.(||)

    Prelude.Bool.(||)
       constant
       type `Bool -> Bool -> Bool`
       executable

• all
  • Data.List.all (alias for Prelude.List.all)

    Prelude.List.all
       constant
       type `('a -> Bool) -> ['a] -> Bool`
       executable

  • Prelude.all (alias for Prelude.Foldable.all)

    Prelude.Foldable.all
       constant of type-class `Foldable`
       type `('e -> Bool) -> 't -> Bool`
       executable

  • Prelude.Foldable.all

    Prelude.Foldable.all
       constant of type-class `Foldable`
       type `('e -> Bool) -> 't -> Bool`
       executable

  • Prelude.List.all

    Prelude.List.all
       constant
       type `('a -> Bool) -> ['a] -> Bool`
       executable

• allP
  • Data.List.allP (alias for Prelude.List.allP)

    Prelude.List.allP
       constant
       type `('a -> Prop) -> ['a] -> Prop`
       non executable

  • Prelude.allP (alias for Prelude.List.allP)

    Prelude.List.allP
       constant
       type `('a -> Prop) -> ['a] -> Prop`
       non executable

  • Prelude.List.allP

    Prelude.List.allP
       constant
       type `('a -> Prop) -> ['a] -> Prop`
       non executable

• and
  • Data.List.and (alias for Prelude.List.and)

    Prelude.List.and
       constant
       type `[Bool] -> Bool`
       executable

  • Prelude.and (alias for Prelude.List.and)

    Prelude.List.and
       constant
       type `[Bool] -> Bool`
       executable

  • Prelude.List.and

    Prelude.List.and
       constant
       type `[Bool] -> Bool`
       executable

• andP
  • Data.List.andP (alias for Prelude.List.andP)

    Prelude.List.andP
       constant
       type `[Prop] -> Prop`
       non executable

  • Prelude.andP (alias for Prelude.List.andP)

    Prelude.List.andP
       constant
       type `[Prop] -> Prop`
       non executable

  • Prelude.List.andP

    Prelude.List.andP
       constant
       type `[Prop] -> Prop`
       non executable

• any
  • Data.List.any (alias for Prelude.List.any)

    Prelude.List.any
       constant
       type `('a -> Bool) -> ['a] -> Bool`
       executable

  • Prelude.any (alias for Prelude.Foldable.any)

    Prelude.Foldable.any
       constant of type-class `Foldable`
       type `('e -> Bool) -> 't -> Bool`
       executable

  • Prelude.Foldable.any

    Prelude.Foldable.any
       constant of type-class `Foldable`
       type `('e -> Bool) -> 't -> Bool`
       executable

  • Prelude.List.any

    Prelude.List.any
       constant
       type `('a -> Bool) -> ['a] -> Bool`
       executable

• anyP
  • Data.List.anyP (alias for Prelude.List.anyP)

    Prelude.List.anyP
       constant
       type `('a -> Prop) -> ['a] -> Prop`
       non executable

  • Prelude.anyP (alias for Prelude.List.anyP)

    Prelude.List.anyP
       constant
       type `('a -> Prop) -> ['a] -> Prop`
       non executable

  • Prelude.List.anyP

    Prelude.List.anyP
       constant
       type `('a -> Prop) -> ['a] -> Prop`
       non executable

• bind
  • Data.Maybe.bind (alias for Prelude.Maybe.bind)

    Prelude.Maybe.bind
       constant
       type `Maybe 'a -> ('a -> Maybe 'b) -> Maybe 'b`
       executable

  • Prelude.bind (alias for Prelude.Monad.(>>=))

    Prelude.Monad.(>>=)
       statically resolved constant of type-class `Monad`
       type `'M 'a -> ('a -> 'M 'b) -> 'M 'b`
       executable

  • Prelude.Maybe.bind

    Prelude.Maybe.bind
       constant
       type `Maybe 'a -> ('a -> Maybe 'b) -> Maybe 'b`
       executable

  • Prelude.Monad.bind (alias for Prelude.Monad.(>>=))

    Prelude.Monad.(>>=)
       statically resolved constant of type-class `Monad`
       type `'M 'a -> ('a -> 'M 'b) -> 'M 'b`
       executable

• bool2prop
  • Prelude.bool2prop (alias for Prelude.Bool.bool2prop)

    Prelude.Bool.bool2prop
       constant
       type `Bool -> Prop`
       non executable

  • Prelude.Bool.bool2prop

    Prelude.Bool.bool2prop
       constant
       type `Bool -> Prop`
       non executable

• boolCase
  • Prelude.boolCase (alias for Prelude.Bool.boolCase)

    Prelude.Bool.boolCase
       constant
       type `Bool -> 'a -> 'a -> 'a`
       executable

  • Prelude.Bool.boolCase

    Prelude.Bool.boolCase
       constant
       type `Bool -> 'a -> 'a -> 'a`
       executable

• break
  • Data.List.break

    Data.List.break
       constant
       type `('a -> Bool) -> ['a] -> (['a], ['a])`
       executable

• caseBool
  • Prelude.caseBool (alias for Prelude.Bool.caseBool)

    Prelude.Bool.caseBool
       datatype case-constant
       type `'a -> 'a -> Bool -> 'a`
       executable

  • Prelude.Bool.caseBool

    Prelude.Bool.caseBool
       datatype case-constant
       type `'a -> 'a -> Bool -> 'a`
       executable

• caseDistinctListSet
  • Data.Collection.DistinctListSet.caseDistinctListSet

    Data.Collection.DistinctListSet.caseDistinctListSet
       datatype case-constant
       type `(['a] -> 'b) -> Data.Collection.DistinctListSet.DistinctListSet 'a -> 'b`
       executable

• caseEither
  • Prelude.caseEither (alias for Prelude.Either.caseEither)

    Prelude.Either.caseEither
       datatype case-constant
       type `('a -> 'c) -> ('b -> 'c) -> Either 'a 'b -> 'c`
       executable

  • Prelude.Either.caseEither

    Prelude.Either.caseEither
       datatype case-constant
       type `('a -> 'c) -> ('b -> 'c) -> Either 'a 'b -> 'c`
       executable

• caseFunSetBool
  • Data.Collection.FunSetBool.caseFunSetBool

    Data.Collection.FunSetBool.caseFunSetBool
       datatype case-constant
       type `(('a -> Bool) -> 'b) -> Data.Collection.FunSetBool.FunSetBool 'a -> 'b`
       executable

• caseItself
  • Prelude.caseItself (alias for Prelude.Unit.caseItself)

    Prelude.Unit.caseItself
       datatype case-constant
       type `'b -> (::'a) -> 'b`
       executable

  • Prelude.Unit.caseItself

    Prelude.Unit.caseItself
       datatype case-constant
       type `'b -> (::'a) -> 'b`
       executable

• caseList
  • Data.List.caseList (alias for Prelude.List.caseList)

    Prelude.List.caseList
       datatype case-constant
       type `'b -> ('a -> ['a] -> 'b) -> ['a] -> 'b`
       executable

  • Prelude.caseList (alias for Prelude.List.caseList)

    Prelude.List.caseList
       datatype case-constant
       type `'b -> ('a -> ['a] -> 'b) -> ['a] -> 'b`
       executable

  • Prelude.List.caseList

    Prelude.List.caseList
       datatype case-constant
       type `'b -> ('a -> ['a] -> 'b) -> ['a] -> 'b`
       executable

• caseMaybe
  • Data.Maybe.caseMaybe (alias for Prelude.Maybe.caseMaybe)

    Prelude.Maybe.caseMaybe
       datatype case-constant
       type `'b -> ('a -> 'b) -> Maybe 'a -> 'b`
       executable

  • Prelude.caseMaybe (alias for Prelude.Maybe.caseMaybe)

    Prelude.Maybe.caseMaybe
       datatype case-constant
       type `'b -> ('a -> 'b) -> Maybe 'a -> 'b`
       executable

  • Prelude.Maybe.caseMaybe

    Prelude.Maybe.caseMaybe
       datatype case-constant
       type `'b -> ('a -> 'b) -> Maybe 'a -> 'b`
       executable

• caseNatural
  • Prelude.caseNatural (alias for Prelude.Num.caseNatural)

    Prelude.Num.caseNatural
       datatype case-constant
       type `'a -> (Natural -> 'a) -> Natural -> 'a`
       executable

  • Prelude.Num.caseNatural

    Prelude.Num.caseNatural
       datatype case-constant
       type `'a -> (Natural -> 'a) -> Natural -> 'a`
       executable

• caseOrdering
  • Prelude.caseOrdering (alias for Prelude.Ord.caseOrdering)

    Prelude.Ord.caseOrdering
       datatype case-constant
       type `'a -> 'a -> 'a -> Ordering -> 'a`
       executable

  • Prelude.Ord.caseOrdering

    Prelude.Ord.caseOrdering
       datatype case-constant
       type `'a -> 'a -> 'a -> Ordering -> 'a`
       executable

• caseUnit
  • Prelude.caseUnit (alias for Prelude.Unit.caseUnit)

    Prelude.Unit.caseUnit
       datatype case-constant
       type `'a -> () -> 'a`
       executable

  • Prelude.Unit.caseUnit

    Prelude.Unit.caseUnit
       datatype case-constant
       type `'a -> () -> 'a`
       executable

• catMaybes
  • Data.Maybe.catMaybes

    Data.Maybe.catMaybes
       constant
       type `[(Maybe 'a)] -> ['a]`
       executable

• chr
  • Prelude.chr (alias for Prelude.Char.chr)

    Prelude.Char.chr
       constant
       type `Natural -> Char`
       executable

  • Prelude.Char.chr

    Prelude.Char.chr
       constant
       type `Natural -> Char`
       executable

• compare
  • Prelude.compare (alias for Prelude.Ord.compare)

    Prelude.Ord.compare
       constant of type-class `Ord`
       type `'a -> 'a -> Ordering`
       executable

  • Prelude.Ord.compare

    Prelude.Ord.compare
       constant of type-class `Ord`
       type `'a -> 'a -> Ordering`
       executable

• comparing
  • Prelude.comparing (alias for Prelude.Ord.comparing)

    Prelude.Ord.comparing
       constant
       type `('b -> 'a) -> 'b -> 'b -> Ordering`
       executable

  • Prelude.Ord.comparing

    Prelude.Ord.comparing
       constant
       type `('b -> 'a) -> 'b -> 'b -> Ordering`
       executable

• concat
  • Data.List.concat (alias for Prelude.List.concat)

    Prelude.List.concat
       constant
       type `[['a]] -> ['a]`
       executable

  • Prelude.concat (alias for Prelude.List.concat)

    Prelude.List.concat
       constant
       type `[['a]] -> ['a]`
       executable

  • Prelude.List.concat

    Prelude.List.concat
       constant
       type `[['a]] -> ['a]`
       executable

• concatMap
  • Data.List.concatMap (alias for Prelude.List.concatMap)

    Prelude.List.concatMap
       constant
       type `('a -> ['b]) -> ['a] -> ['b]`
       executable

  • Prelude.concatMap (alias for Prelude.List.concatMap)

    Prelude.List.concatMap
       constant
       type `('a -> ['b]) -> ['a] -> ['b]`
       executable

  • Prelude.List.concatMap

    Prelude.List.concatMap
       constant
       type `('a -> ['b]) -> ['a] -> ['b]`
       executable

• Cons
  • Data.List.Cons (alias for Prelude.List.(:))

    Prelude.List.(:)
       constructor of datatype `List`
       type `'a -> ['a] -> ['a]`
       executable

  • Prelude.Cons (alias for Prelude.List.(:))

    Prelude.List.(:)
       constructor of datatype `List`
       type `'a -> ['a] -> ['a]`
       executable

  • Prelude.List.Cons (alias for Prelude.List.(:))

    Prelude.List.(:)
       constructor of datatype `List`
       type `'a -> ['a] -> ['a]`
       executable

• constant
  • Prelude.constant (alias for Prelude.Function.constant)

    Prelude.Function.constant
       constant
       type `'a -> 'b -> 'a`
       executable

  • Prelude.Function.constant

    Prelude.Function.constant
       constant
       type `'a -> 'b -> 'a`
       executable

• count
  • Data.List.count (alias for Prelude.List.count)

    Prelude.List.count
       constant
       type `'a -> ['a] -> Natural`
       executable

  • Prelude.count (alias for Prelude.List.count)

    Prelude.List.count
       constant
       type `'a -> ['a] -> Natural`
       executable

  • Prelude.List.count

    Prelude.List.count
       constant
       type `'a -> ['a] -> Natural`
       executable

• curry
  • Prelude.curry (alias for Prelude.Tuple.curry)

    Prelude.Tuple.curry
       constant
       type `(('a, 'b) -> 'c) -> 'a -> 'b -> 'c`
       executable

  • Prelude.Tuple.curry

    Prelude.Tuple.curry
       constant
       type `(('a, 'b) -> 'c) -> 'a -> 'b -> 'c`
       executable

• default
  • Prelude.default (alias for Prelude.Default.default)

    Prelude.Default.default
       constant of type-class `Default`
       type `'a`
       executable

  • Prelude.Default.default

    Prelude.Default.default
       constant of type-class `Default`
       type `'a`
       executable

• delete
  • Prelude.delete (alias for Prelude.Collection.delete)

    Prelude.Collection.delete
       constant of type-class `CollectionWithDelete`
       type `'e -> 'c -> 'c`
       executable

  • Prelude.Collection.delete

    Prelude.Collection.delete
       constant of type-class `CollectionWithDelete`
       type `'e -> 'c -> 'c`
       executable

• dequeue
  • Data.Collection.Queue.dequeue

    Data.Collection.Queue.dequeue
       constant
       type `Data.Collection.Queue.Queue 'a -> Maybe ('a, Data.Collection.Queue.Queue 'a)`
       executable

• destEither
  • Prelude.destEither (alias for Prelude.Either.destEither)

    Prelude.Either.destEither
       constant
       type `('a -> 'c) -> ('b -> 'c) -> Either 'a 'b -> 'c`
       executable

  • Prelude.Either.destEither

    Prelude.Either.destEither
       constant
       type `('a -> 'c) -> ('b -> 'c) -> Either 'a 'b -> 'c`
       executable

• difference
  • Prelude.difference (alias for Prelude.Collection.difference)

    Prelude.Collection.difference
       constant of type-class `CollectionWithDelete`
       type `'c -> 'c -> 'c`
       executable

  • Prelude.Collection.difference

    Prelude.Collection.difference
       constant of type-class `CollectionWithDelete`
       type `'c -> 'c -> 'c`
       executable

• disjoint
  • Prelude.disjoint (alias for Prelude.Collection.disjoint)

    Prelude.Collection.disjoint
       constant of type-class `CollectionWithSubsetTest`
       type `'c -> 'c -> Bool`
       executable

  • Prelude.Collection.disjoint

    Prelude.Collection.disjoint
       constant of type-class `CollectionWithSubsetTest`
       type `'c -> 'c -> Bool`
       executable

• DistinctListSet
  • Data.Collection.DistinctListSet.DistinctListSet

    Data.Collection.DistinctListSet.DistinctListSet
       constructor of datatype `Data.Collection.DistinctListSet.DistinctListSet`
       type `['a] -> Data.Collection.DistinctListSet.DistinctListSet 'a`
       executable

• div
  • Prelude.div (alias for Prelude.Num.div)

    Prelude.Num.div
       constant of type-class `NumDivMod`
       type `'a -> 'a -> 'a`
       executable

  • Prelude.Num.div

    Prelude.Num.div
       constant of type-class `NumDivMod`
       type `'a -> 'a -> 'a`
       executable

• divmod
  • Prelude.divmod (alias for Prelude.Num.divmod)

    Prelude.Num.divmod
       constant of type-class `NumDivMod`
       type `'a -> 'a -> ('a, 'a)`
       executable

  • Prelude.Num.divmod

    Prelude.Num.divmod
       constant of type-class `NumDivMod`
       type `'a -> 'a -> ('a, 'a)`
       executable

• drop
  • Data.List.drop

    Data.List.drop
       constant
       type `Natural -> ['a] -> ['a]`
       executable

• dropWhile
  • Data.List.dropWhile

    Data.List.dropWhile
       constant
       type `('a -> Bool) -> ['a] -> ['a]`
       executable

• elem
  • Data.List.elem (alias for Prelude.List.elem)

    Prelude.List.elem
       constant
       type `'a -> ['a] -> Bool`
       executable

  • Prelude.elem (alias for Prelude.Foldable.elem)

    Prelude.Foldable.elem
       constant of type-class `Foldable`
       type `'e -> 't -> Bool`
       executable

  • Prelude.Foldable.elem

    Prelude.Foldable.elem
       constant of type-class `Foldable`
       type `'e -> 't -> Bool`
       executable

  • Prelude.List.elem

    Prelude.List.elem
       constant
       type `'a -> ['a] -> Bool`
       executable

• elem1
  • Data.Lens.elem1

    Data.Lens.elem1
       constant of type-class `Data.Lens.Elem1`
       type `Data.Lens.Lens 's 't 'a 'b`
       executable

• elem2
  • Data.Lens.elem2

    Data.Lens.elem2
       constant of type-class `Data.Lens.Elem2`
       type `Data.Lens.Lens 's 't 'a 'b`
       executable

• elem3
  • Data.Lens.elem3

    Data.Lens.elem3
       constant of type-class `Data.Lens.Elem3`
       type `Data.Lens.Lens 's 't 'a 'b`
       executable

• elem4
  • Data.Lens.elem4

    Data.Lens.elem4
       constant of type-class `Data.Lens.Elem4`
       type `Data.Lens.Lens 's 't 'a 'b`
       executable

• elem5
  • Data.Lens.elem5

    Data.Lens.elem5
       constant of type-class `Data.Lens.Elem5`
       type `Data.Lens.Lens 's 't 'a 'b`
       executable

• elem6
  • Data.Lens.elem6

    Data.Lens.elem6
       constant of type-class `Data.Lens.Elem6`
       type `Data.Lens.Lens 's 't 'a 'b`
       executable

• elem7
  • Data.Lens.elem7

    Data.Lens.elem7
       constant of type-class `Data.Lens.Elem7`
       type `Data.Lens.Lens 's 't 'a 'b`
       executable

• elem8
  • Data.Lens.elem8

    Data.Lens.elem8
       constant of type-class `Data.Lens.Elem8`
       type `Data.Lens.Lens 's 't 'a 'b`
       executable

• elem9
  • Data.Lens.elem9

    Data.Lens.elem9
       constant of type-class `Data.Lens.Elem9`
       type `Data.Lens.Lens 's 't 'a 'b`
       executable

• elemP
  • Data.List.elemP (alias for Prelude.List.elemP)

    Prelude.List.elemP
       constant
       type `'a -> ['a] -> Prop`
       non executable

  • Prelude.List.elemP

    Prelude.List.elemP
       constant
       type `'a -> ['a] -> Prop`
       non executable

• empty
  • Prelude.empty (alias for Prelude.Collection.empty)

    Prelude.Collection.empty
       constant
       type `'c`
       executable

  • Prelude.Collection.empty

    Prelude.Collection.empty
       constant
       type `'c`
       executable

• emptyQueue
  • Data.Collection.Queue.emptyQueue

    Data.Collection.Queue.emptyQueue
       constant
       type `Data.Collection.Queue.Queue 'a`
       executable

• emptyStack
  • Data.Collection.Stack.emptyStack

    Data.Collection.Stack.emptyStack
       constant
       type `Data.Collection.Stack.Stack 'a`
       executable

• enqueue
  • Data.Collection.Queue.enqueue

    Data.Collection.Queue.enqueue
       constant
       type `'a -> Data.Collection.Queue.Queue 'a -> Data.Collection.Queue.Queue 'a`
       executable

• enumFromTo
  • Prelude.enumFromTo (alias for Prelude.BasicClasses.enumFromTo)

    Prelude.BasicClasses.enumFromTo
       constant of type-class `Enum`
       type `'a -> 'a -> ['a]`
       executable

  • Prelude.BasicClasses.enumFromTo

    Prelude.BasicClasses.enumFromTo
       constant of type-class `Enum`
       type `'a -> 'a -> ['a]`
       executable

• EQ
  • Prelude.EQ (alias for Prelude.Ord.EQ)

    Prelude.Ord.EQ
       constructor of datatype `Ordering`
       type `Ordering`
       executable

  • Prelude.Ord.EQ

    Prelude.Ord.EQ
       constructor of datatype `Ordering`
       type `Ordering`
       executable

• existsB_fun
  • Prelude.existsB_fun (alias for Prelude.BasicClasses.existsB_fun)

    Prelude.BasicClasses.existsB_fun
       constant of type-class `Finite`
       type `('a -> Bool) -> Bool`
       executable

  • Prelude.BasicClasses.existsB_fun

    Prelude.BasicClasses.existsB_fun
       constant of type-class `Finite`
       type `('a -> Bool) -> Bool`
       executable

• existsP_fun
  • Prelude.existsP_fun (alias for Prelude.Bool.existsP_fun)

    Prelude.Bool.existsP_fun
       constant
       type `('a -> Prop) -> Prop`
       non executable

  • Prelude.Bool.existsP_fun

    Prelude.Bool.existsP_fun
       constant
       type `('a -> Prop) -> Prop`
       non executable

• fail
  • Prelude.fail (alias for Prelude.Monad.fail)

    Prelude.Monad.fail
       statically resolved constant of type-class `MonadFail`
       type `String -> 'M 'a`
       executable

  • Prelude.Monad.fail

    Prelude.Monad.fail
       statically resolved constant of type-class `MonadFail`
       type `String -> 'M 'a`
       executable

• false
  • Prelude.false (alias for Prelude.Bool.false)

    Prelude.Bool.false
       constant
       type `Prop`
       non executable

  • Prelude.Bool.false

    Prelude.Bool.false
       constant
       type `Prop`
       non executable

• False
  • Prelude.False (alias for Prelude.Bool.False)

    Prelude.Bool.False
       constructor of datatype `Bool`
       type `Bool`
       executable

  • Prelude.Bool.False

    Prelude.Bool.False
       constructor of datatype `Bool`
       type `Bool`
       executable

• filter
  • Data.List.filter (alias for Prelude.List.filter)

    Prelude.List.filter
       constant
       type `('a -> Bool) -> ['a] -> ['a]`
       executable

  • Prelude.filter (alias for Prelude.Collection.filter)

    Prelude.Collection.filter
       constant of type-class `CollectionWithDelete`
       type `('e -> Bool) -> 'c -> 'c`
       executable

  • Prelude.Collection.filter

    Prelude.Collection.filter
       constant of type-class `CollectionWithDelete`
       type `('e -> Bool) -> 'c -> 'c`
       executable

  • Prelude.List.filter

    Prelude.List.filter
       constant
       type `('a -> Bool) -> ['a] -> ['a]`
       executable

• flip
  • Prelude.flip (alias for Prelude.Function.flip)

    Prelude.Function.flip
       constant
       type `('a -> 'b -> 'c) -> 'b -> 'a -> 'c`
       executable

  • Prelude.Function.flip

    Prelude.Function.flip
       constant
       type `('a -> 'b -> 'c) -> 'b -> 'a -> 'c`
       executable

• fmap
  • Prelude.fmap (alias for Prelude.Functor.fmap)

    Prelude.Functor.fmap
       statically resolved constant of type-class `Functor`
       type `('a -> 'b) -> 'F 'a -> 'F 'b`
       executable

  • Prelude.Functor.fmap

    Prelude.Functor.fmap
       statically resolved constant of type-class `Functor`
       type `('a -> 'b) -> 'F 'a -> 'F 'b`
       executable

• foldl
  • Data.List.foldl (alias for Prelude.List.foldl)

    Prelude.List.foldl
       constant
       type `('a -> 'b -> 'a) -> 'a -> ['b] -> 'a`
       executable

  • Prelude.foldl (alias for Prelude.Foldable.foldl)

    Prelude.Foldable.foldl
       statically resolved constant of type-class `Foldable`
       type `('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
       executable

  • Prelude.Foldable.foldl

    Prelude.Foldable.foldl
       statically resolved constant of type-class `Foldable`
       type `('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
       executable

  • Prelude.List.foldl

    Prelude.List.foldl
       constant
       type `('a -> 'b -> 'a) -> 'a -> ['b] -> 'a`
       executable

• foldlWithAbort
  • Data.List.foldlWithAbort (alias for Prelude.List.foldlWithAbort)

    Prelude.List.foldlWithAbort
       constant
       type `('a -> Bool) -> ('a -> 'b -> 'a) -> 'a -> ['b] -> 'a`
       executable

  • Prelude.foldlWithAbort (alias for Prelude.Foldable.foldlWithAbort)

    Prelude.Foldable.foldlWithAbort
       statically resolved constant of type-class `Foldable`
       type `('acc -> Bool) -> ('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
       executable

  • Prelude.Foldable.foldlWithAbort

    Prelude.Foldable.foldlWithAbort
       statically resolved constant of type-class `Foldable`
       type `('acc -> Bool) -> ('acc -> 'e -> 'acc) -> 'acc -> 't -> 'acc`
       executable

  • Prelude.List.foldlWithAbort

    Prelude.List.foldlWithAbort
       constant
       type `('a -> Bool) -> ('a -> 'b -> 'a) -> 'a -> ['b] -> 'a`
       executable

• foldr
  • Data.List.foldr (alias for Prelude.List.foldr)

    Prelude.List.foldr
       constant
       type `('a -> 'b -> 'b) -> 'b -> ['a] -> 'b`
       executable

  • Prelude.foldr (alias for Prelude.Foldable.foldr)

    Prelude.Foldable.foldr
       statically resolved constant of type-class `Foldable`
       type `('e -> 'acc -> 'acc) -> 'acc -> 't -> 'acc`
       executable

  • Prelude.Foldable.foldr

    Prelude.Foldable.foldr
       statically resolved constant of type-class `Foldable`
       type `('e -> 'acc -> 'acc) -> 'acc -> 't -> 'acc`
       executable

  • Prelude.List.foldr

    Prelude.List.foldr
       constant
       type `('a -> 'b -> 'b) -> 'b -> ['a] -> 'b`
       executable

• forallB_fun
  • Prelude.forallB_fun (alias for Prelude.BasicClasses.forallB_fun)

    Prelude.BasicClasses.forallB_fun
       constant of type-class `Finite`
       type `('a -> Bool) -> Bool`
       executable

  • Prelude.BasicClasses.forallB_fun

    Prelude.BasicClasses.forallB_fun
       constant of type-class `Finite`
       type `('a -> Bool) -> Bool`
       executable

• forallP_fun
  • Prelude.forallP_fun (alias for Prelude.Bool.forallP_fun)

    Prelude.Bool.forallP_fun
       constant
       type `('a -> Prop) -> Prop`
       non executable

  • Prelude.Bool.forallP_fun

    Prelude.Bool.forallP_fun
       constant
       type `('a -> Prop) -> Prop`
       non executable

• fromEnum
  • Prelude.fromEnum (alias for Prelude.BasicClasses.fromEnum)

    Prelude.BasicClasses.fromEnum
       constant of type-class `Enum`
       type `'a -> Natural`
       executable

  • Prelude.BasicClasses.fromEnum

    Prelude.BasicClasses.fromEnum
       constant of type-class `Enum`
       type `'a -> Natural`
       executable

• fromList
  • Prelude.fromList (alias for Prelude.Collection.fromList)

    Prelude.Collection.fromList
       constant of type-class `Collection`
       type `['e] -> 'c`
       executable

  • Prelude.Collection.fromList

    Prelude.Collection.fromList
       constant of type-class `Collection`
       type `['e] -> 'c`
       executable

• fromMaybe
  • Data.Maybe.fromMaybe (alias for Prelude.Maybe.fromMaybe)

    Prelude.Maybe.fromMaybe
       constant
       type `'a -> Maybe 'a -> 'a`
       executable

  • Prelude.fromMaybe (alias for Prelude.Maybe.fromMaybe)

    Prelude.Maybe.fromMaybe
       constant
       type `'a -> Maybe 'a -> 'a`
       executable

  • Prelude.Maybe.fromMaybe

    Prelude.Maybe.fromMaybe
       constant
       type `'a -> Maybe 'a -> 'a`
       executable

• fromMaybeMap
  • Data.Maybe.fromMaybeMap (alias for Prelude.Maybe.fromMaybeMap)

    Prelude.Maybe.fromMaybeMap
       constant
       type `'b -> ('a -> 'b) -> Maybe 'a -> 'b`
       executable

  • Prelude.fromMaybeMap (alias for Prelude.Maybe.fromMaybeMap)

    Prelude.Maybe.fromMaybeMap
       constant
       type `'b -> ('a -> 'b) -> Maybe 'a -> 'b`
       executable

  • Prelude.Maybe.fromMaybeMap

    Prelude.Maybe.fromMaybeMap
       constant
       type `'b -> ('a -> 'b) -> Maybe 'a -> 'b`
       executable

• fst
  • Prelude.fst (alias for Prelude.Tuple.fst)

    Prelude.Tuple.fst
       constant
       type `('a, 'b) -> 'a`
       executable

  • Prelude.Tuple.fst

    Prelude.Tuple.fst
       constant
       type `('a, 'b) -> 'a`
       executable

• FunSetBool
  • Data.Collection.FunSetBool.FunSetBool

    Data.Collection.FunSetBool.FunSetBool
       constructor of datatype `Data.Collection.FunSetBool.FunSetBool`
       type `('a -> Bool) -> Data.Collection.FunSetBool.FunSetBool 'a`
       executable

• Getter
  • Data.Lens.Getter

    Data.Lens.Getter
       constructor of record-type `Data.Lens.Getter`
       type `('a -> 'b) -> Data.Lens.Getter 'a 'b`
       executable

• getterGet
  • Data.Lens.getterGet

    Data.Lens.getterGet
       field of record-type `Data.Lens.Getter`
       type `Data.Lens.Getter 'a 'b -> 'a -> 'b`
       executable

• GT
  • Prelude.GT (alias for Prelude.Ord.GT)

    Prelude.Ord.GT
       constructor of datatype `Ordering`
       type `Ordering`
       executable

  • Prelude.Ord.GT

    Prelude.Ord.GT
       constructor of datatype `Ordering`
       type `Ordering`
       executable

• guard
  • Prelude.guard (alias for Prelude.Monad.guard)

    Prelude.Monad.guard
       constant
       type `Bool -> 'M ()`
       executable

  • Prelude.Monad.guard

    Prelude.Monad.guard
       constant
       type `Bool -> 'M ()`
       executable

• id
  • Prelude.id (alias for Prelude.Function.id)

    Prelude.Function.id
       constant
       type `'a -> 'a`
       executable

  • Prelude.Function.id

    Prelude.Function.id
       constant
       type `'a -> 'a`
       executable

• image
  • Prelude.image (alias for Prelude.Collection.image)

    Prelude.Collection.image
       constant
       type `('e1 -> 'e2) -> 'C 'e1 -> 'C 'e2`
       executable

  • Prelude.Collection.image

    Prelude.Collection.image
       constant
       type `('e1 -> 'e2) -> 'C 'e1 -> 'C 'e2`
       executable

• insert
  • Prelude.insert (alias for Prelude.Collection.insert)

    Prelude.Collection.insert
       constant of type-class `Collection`
       type `'e -> 'c -> 'c`
       executable

  • Prelude.Collection.insert

    Prelude.Collection.insert
       constant of type-class `Collection`
       type `'e -> 'c -> 'c`
       executable

• intersection
  • Prelude.intersection (alias for Prelude.Collection.intersection)

    Prelude.Collection.intersection
       constant of type-class `CollectionWithDelete`
       type `'c -> 'c -> 'c`
       executable

  • Prelude.Collection.intersection

    Prelude.Collection.intersection
       constant of type-class `CollectionWithDelete`
       type `'c -> 'c -> 'c`
       executable

• isEmpty
  • Prelude.isEmpty (alias for Prelude.Collection.isEmpty)

    Prelude.Collection.isEmpty
       constant of type-class `CollectionWithEmptynessTest`
       type `'c -> Bool`
       executable

  • Prelude.Collection.isEmpty

    Prelude.Collection.isEmpty
       constant of type-class `CollectionWithEmptynessTest`
       type `'c -> Bool`
       executable

• isEmptyP
  • Prelude.isEmptyP (alias for Prelude.Collection.isEmptyP)

    Prelude.Collection.isEmptyP
       constant of type-class `Collection`
       type `'c -> Prop`
       non executable

  • Prelude.Collection.isEmptyP

    Prelude.Collection.isEmptyP
       constant of type-class `Collection`
       type `'c -> Prop`
       non executable

• isJust
  • Data.Maybe.isJust (alias for Prelude.Maybe.isJust)

    Prelude.Maybe.isJust
       constant
       type `Maybe 'a -> Bool`
       executable

  • Prelude.isJust (alias for Prelude.Maybe.isJust)

    Prelude.Maybe.isJust
       constant
       type `Maybe 'a -> Bool`
       executable

  • Prelude.Maybe.isJust

    Prelude.Maybe.isJust
       constant
       type `Maybe 'a -> Bool`
       executable

• isNothing
  • Data.Maybe.isNothing (alias for Prelude.Maybe.isNothing)

    Prelude.Maybe.isNothing
       constant
       type `Maybe 'a -> Bool`
       executable

  • Prelude.isNothing (alias for Prelude.Maybe.isNothing)

    Prelude.Maybe.isNothing
       constant
       type `Maybe 'a -> Bool`
       executable

  • Prelude.Maybe.isNothing

    Prelude.Maybe.isNothing
       constant
       type `Maybe 'a -> Bool`
       executable

• isProperSubsetOf
  • Prelude.isProperSubsetOf (alias for Prelude.Collection.isProperSubsetOf)

    Prelude.Collection.isProperSubsetOf
       constant of type-class `CollectionWithSubsetTest`
       type `'c -> 'c -> Bool`
       executable

  • Prelude.Collection.isProperSubsetOf

    Prelude.Collection.isProperSubsetOf
       constant of type-class `CollectionWithSubsetTest`
       type `'c -> 'c -> Bool`
       executable

• isSetEquiv
  • Prelude.isSetEquiv (alias for Prelude.Collection.isSetEquiv)

    Prelude.Collection.isSetEquiv
       constant of type-class `CollectionWithSubsetTest`
       type `'c -> 'c -> Bool`
       executable

  • Prelude.Collection.isSetEquiv

    Prelude.Collection.isSetEquiv
       constant of type-class `CollectionWithSubsetTest`
       type `'c -> 'c -> Bool`
       executable

• isSubsetOf
  • Prelude.isSubsetOf (alias for Prelude.Collection.isSubsetOf)

    Prelude.Collection.isSubsetOf
       constant of type-class `CollectionWithSubsetTest`
       type `'c -> 'c -> Bool`
       executable

  • Prelude.Collection.isSubsetOf

    Prelude.Collection.isSubsetOf
       constant of type-class `CollectionWithSubsetTest`
       type `'c -> 'c -> Bool`
       executable

• Itself
  • Prelude.Itself (alias for Prelude.Unit.Itself)

    Prelude.Unit.Itself
       constructor of datatype `Itself`
       type `(::'a)`
       executable

  • Prelude.Unit.Itself

    Prelude.Unit.Itself
       constructor of datatype `Itself`
       type `(::'a)`
       executable

• Just
  • Data.Maybe.Just (alias for Prelude.Maybe.Just)

    Prelude.Maybe.Just
       constructor of datatype `Maybe`
       type `'a -> Maybe 'a`
       executable

  • Prelude.Just (alias for Prelude.Maybe.Just)

    Prelude.Maybe.Just
       constructor of datatype `Maybe`
       type `'a -> Maybe 'a`
       executable

  • Prelude.Maybe.Just

    Prelude.Maybe.Just
       constructor of datatype `Maybe`
       type `'a -> Maybe 'a`
       executable

• last
  • Data.List.last (alias for Prelude.List.last)

    Prelude.List.last
       constant
       type `['a] -> Maybe 'a`
       executable

  • Prelude.last (alias for Prelude.List.last)

    Prelude.List.last
       constant
       type `['a] -> Maybe 'a`
       executable

  • Prelude.List.last

    Prelude.List.last
       constant
       type `['a] -> Maybe 'a`
       executable

• Left
  • Prelude.Left (alias for Prelude.Either.Left)

    Prelude.Either.Left
       constructor of datatype `Either`
       type `'a -> Either 'a 'b`
       executable

  • Prelude.Either.Left

    Prelude.Either.Left
       constructor of datatype `Either`
       type `'a -> Either 'a 'b`
       executable

• length
  • Data.List.length (alias for Prelude.List.length)

    Prelude.List.length
       constant
       type `['a] -> Natural`
       executable

  • Prelude.length (alias for Prelude.List.length)

    Prelude.List.length
       constant
       type `['a] -> Natural`
       executable

  • Prelude.List.length

    Prelude.List.length
       constant
       type `['a] -> Natural`
       executable

• Lens
  • Data.Lens.Lens

    Data.Lens.Lens
       constructor of record-type `Data.Lens.Lens`
       type `('s -> 'a) -> ('s -> 'b -> 't) -> Data.Lens.Lens 's 't 'a 'b`
       executable

• lensGet
  • Data.Lens.lensGet

    Data.Lens.lensGet
       field of record-type `Data.Lens.Lens`
       type `Data.Lens.Lens 's 't 'a 'b -> 's -> 'a`
       executable

• lensSet
  • Data.Lens.lensSet

    Data.Lens.lensSet
       field of record-type `Data.Lens.Lens`
       type `Data.Lens.Lens 's 't 'a 'b -> 's -> 'b -> 't`
       executable

• lexCompare
  • Prelude.lexCompare (alias for Prelude.Ord.lexCompare)

    Prelude.Ord.lexCompare
       constant
       type `'a -> 'a -> Ordering -> Ordering`
       executable

  • Prelude.Ord.lexCompare

    Prelude.Ord.lexCompare
       constant
       type `'a -> 'a -> Ordering -> Ordering`
       executable

• listToMaybe
  • Data.Maybe.listToMaybe

    Data.Maybe.listToMaybe
       constant
       type `['a] -> Maybe 'a`
       executable

• lookup
  • Data.List.lookup

    Data.List.lookup
       constant
       type `'k -> [('k, 'v)] -> Maybe 'v`
       executable

• LT
  • Prelude.LT (alias for Prelude.Ord.LT)

    Prelude.Ord.LT
       constructor of datatype `Ordering`
       type `Ordering`
       executable

  • Prelude.Ord.LT

    Prelude.Ord.LT
       constructor of datatype `Ordering`
       type `Ordering`
       executable

• map
  • Data.List.map (alias for Prelude.List.map)

    Prelude.List.map
       constant
       type `('a -> 'b) -> ['a] -> ['b]`
       executable

  • Data.Maybe.map (alias for Prelude.Maybe.map)

    Prelude.Maybe.map
       constant
       type `('a -> 'b) -> Maybe 'a -> Maybe 'b`
       executable

  • Prelude.map (alias for Prelude.List.map)

    Prelude.List.map
       constant
       type `('a -> 'b) -> ['a] -> ['b]`
       executable

  • Prelude.List.map

    Prelude.List.map
       constant
       type `('a -> 'b) -> ['a] -> ['b]`
       executable

  • Prelude.Maybe.map

    Prelude.Maybe.map
       constant
       type `('a -> 'b) -> Maybe 'a -> Maybe 'b`
       executable

• mapM
  • Prelude.mapM (alias for Prelude.Monad.mapM)

    Prelude.Monad.mapM
       constant
       type `('a -> 'M 'b) -> ['a] -> 'M ['b]`
       executable

  • Prelude.Monad.mapM

    Prelude.Monad.mapM
       constant
       type `('a -> 'M 'b) -> ['a] -> 'M ['b]`
       executable

• mapMaybe
  • Data.Maybe.mapMaybe

    Data.Maybe.mapMaybe
       constant
       type `('a -> Maybe 'b) -> ['a] -> ['b]`
       executable

• mapM_
  • Prelude.mapM_ (alias for Prelude.Monad.mapM_)

    Prelude.Monad.mapM_
       constant
       type `('a -> 'M 'b) -> ['a] -> 'M ()`
       executable

  • Prelude.Monad.mapM_

    Prelude.Monad.mapM_
       constant
       type `('a -> 'M 'b) -> ['a] -> 'M ()`
       executable

• mappend
  • Prelude.mappend (alias for Prelude.BasicClasses.mappend)

    Prelude.BasicClasses.mappend
       constant
       type `'a -> 'a -> 'a`
       executable

  • Prelude.BasicClasses.mappend

    Prelude.BasicClasses.mappend
       constant
       type `'a -> 'a -> 'a`
       executable

• max
  • Prelude.max (alias for Prelude.Ord.max)

    Prelude.Ord.max
       constant of type-class `Ord`
       type `'a -> 'a -> 'a`
       executable

  • Prelude.Ord.max

    Prelude.Ord.max
       constant of type-class `Ord`
       type `'a -> 'a -> 'a`
       executable

• maxBound
  • Prelude.maxBound (alias for Prelude.BasicClasses.maxBound)

    Prelude.BasicClasses.maxBound
       constant of type-class `Bounded`
       type `'a`
       executable

  • Prelude.BasicClasses.maxBound

    Prelude.BasicClasses.maxBound
       constant of type-class `Bounded`
       type `'a`
       executable

• maybeToList
  • Data.Maybe.maybeToList

    Data.Maybe.maybeToList
       constant
       type `Maybe 'a -> ['a]`
       executable

• member
  • Prelude.member (alias for Prelude.Collection.member)

    Prelude.Collection.member
       constant of type-class `CollectionWithMembershipTest`
       type `'e -> 'c -> Bool`
       executable

  • Prelude.Collection.member

    Prelude.Collection.member
       constant of type-class `CollectionWithMembershipTest`
       type `'e -> 'c -> Bool`
       executable

• memberP
  • Prelude.memberP (alias for Prelude.Collection.memberP)

    Prelude.Collection.memberP
       constant of type-class `Collection`
       type `'e -> 'c -> Prop`
       non executable

  • Prelude.Collection.memberP

    Prelude.Collection.memberP
       constant of type-class `Collection`
       type `'e -> 'c -> Prop`
       non executable

• mempty
  • Prelude.mempty (alias for Prelude.BasicClasses.mempty)

    Prelude.BasicClasses.mempty
       constant of type-class `Monoid`
       type `'a`
       executable

  • Prelude.BasicClasses.mempty

    Prelude.BasicClasses.mempty
       constant of type-class `Monoid`
       type `'a`
       executable

• min
  • Prelude.min (alias for Prelude.Ord.min)

    Prelude.Ord.min
       constant of type-class `Ord`
       type `'a -> 'a -> 'a`
       executable

  • Prelude.Ord.min

    Prelude.Ord.min
       constant of type-class `Ord`
       type `'a -> 'a -> 'a`
       executable

• minBound
  • Prelude.minBound (alias for Prelude.BasicClasses.minBound)

    Prelude.BasicClasses.minBound
       constant of type-class `Bounded`
       type `'a`
       executable

  • Prelude.BasicClasses.minBound

    Prelude.BasicClasses.minBound
       constant of type-class `Bounded`
       type `'a`
       executable

• mkChar
  • Prelude.mkChar (alias for Prelude.Char.mkChar)

    Prelude.Char.mkChar
       constant
       type `BuiltInChar -> Char`
       executable

  • Prelude.Char.mkChar

    Prelude.Char.mkChar
       constant
       type `BuiltInChar -> Char`
       executable

• mkLiteralChar
  • Prelude.mkLiteralChar (alias for Prelude.Literal.mkLiteralChar)

    Prelude.Literal.mkLiteralChar
       statically resolved constant of type-class `LiteralChar`
       type `BuiltInChar -> 'a`
       executable

  • Prelude.Literal.mkLiteralChar

    Prelude.Literal.mkLiteralChar
       statically resolved constant of type-class `LiteralChar`
       type `BuiltInChar -> 'a`
       executable

• mkLiteralDecimal
  • Prelude.mkLiteralDecimal (alias for Prelude.Literal.mkLiteralDecimal)

    Prelude.Literal.mkLiteralDecimal
       statically resolved constant of type-class `LiteralDecimal`
       type `BuiltInDecimal -> 'a`
       executable

  • Prelude.Literal.mkLiteralDecimal

    Prelude.Literal.mkLiteralDecimal
       statically resolved constant of type-class `LiteralDecimal`
       type `BuiltInDecimal -> 'a`
       executable

• mkLiteralNum
  • Prelude.mkLiteralNum (alias for Prelude.Literal.mkLiteralNum)

    Prelude.Literal.mkLiteralNum
       statically resolved constant of type-class `LiteralNum`
       type `(Prelude.Literal.BuiltInNumRep, BuiltInNum) -> 'a`
       executable

  • Prelude.Literal.mkLiteralNum

    Prelude.Literal.mkLiteralNum
       statically resolved constant of type-class `LiteralNum`
       type `(Prelude.Literal.BuiltInNumRep, BuiltInNum) -> 'a`
       executable

• mkLiteralString
  • Prelude.mkLiteralString (alias for Prelude.Literal.mkLiteralString)

    Prelude.Literal.mkLiteralString
       statically resolved constant of type-class `LiteralString`
       type `BuiltInString -> 'a`
       executable

  • Prelude.Literal.mkLiteralString

    Prelude.Literal.mkLiteralString
       statically resolved constant of type-class `LiteralString`
       type `BuiltInString -> 'a`
       executable

• mkString
  • Prelude.mkString (alias for Prelude.String.mkString)

    Prelude.String.mkString
       constant
       type `BuiltInString -> String`
       executable

  • Prelude.String.mkString

    Prelude.String.mkString
       constant
       type `BuiltInString -> String`
       executable

• mod
  • Prelude.mod (alias for Prelude.Num.mod)

    Prelude.Num.mod
       constant of type-class `NumDivMod`
       type `'a -> 'a -> 'a`
       executable

  • Prelude.Num.mod

    Prelude.Num.mod
       constant of type-class `NumDivMod`
       type `'a -> 'a -> 'a`
       executable

• Nil
  • Data.List.Nil (alias for Prelude.List.Nil)

    Prelude.List.Nil
       constructor of datatype `List`
       type `['a]`
       executable

  • Prelude.Nil (alias for Prelude.List.Nil)

    Prelude.List.Nil
       constructor of datatype `List`
       type `['a]`
       executable

  • Prelude.List.Nil

    Prelude.List.Nil
       constructor of datatype `List`
       type `['a]`
       executable

• not
  • Prelude.not (alias for Prelude.Bool.not)

    Prelude.Bool.not
       constant
       type `Bool -> Bool`
       executable

  • Prelude.Bool.not

    Prelude.Bool.not
       constant
       type `Bool -> Bool`
       executable

• notElem
  • Data.List.notElem (alias for Prelude.List.notElem)

    Prelude.List.notElem
       constant
       type `'a -> ['a] -> Bool`
       executable

  • Prelude.notElem (alias for Prelude.List.notElem)

    Prelude.List.notElem
       constant
       type `'a -> ['a] -> Bool`
       executable

  • Prelude.List.notElem

    Prelude.List.notElem
       constant
       type `'a -> ['a] -> Bool`
       executable

• notElemP
  • Data.List.notElemP (alias for Prelude.List.notElemP)

    Prelude.List.notElemP
       constant
       type `'a -> ['a] -> Prop`
       non executable

  • Prelude.List.notElemP

    Prelude.List.notElemP
       constant
       type `'a -> ['a] -> Prop`
       non executable

• Nothing
  • Data.Maybe.Nothing (alias for Prelude.Maybe.Nothing)

    Prelude.Maybe.Nothing
       constructor of datatype `Maybe`
       type `Maybe 'a`
       executable

  • Prelude.Nothing (alias for Prelude.Maybe.Nothing)

    Prelude.Maybe.Nothing
       constructor of datatype `Maybe`
       type `Maybe 'a`
       executable

  • Prelude.Maybe.Nothing

    Prelude.Maybe.Nothing
       constructor of datatype `Maybe`
       type `Maybe 'a`
       executable

• notP
  • Prelude.notP (alias for Prelude.Bool.notP)

    Prelude.Bool.notP
       constant
       type `Prop -> Prop`
       non executable

  • Prelude.Bool.notP

    Prelude.Bool.notP
       constant
       type `Prop -> Prop`
       non executable

• nub
  • Data.List.nub (alias for Prelude.List.nub)

    Prelude.List.nub
       constant
       type `['a] -> ['a]`
       executable

  • Prelude.nub (alias for Prelude.List.nub)

    Prelude.List.nub
       constant
       type `['a] -> ['a]`
       executable

  • Prelude.List.nub

    Prelude.List.nub
       constant
       type `['a] -> ['a]`
       executable

• nubBy
  • Data.List.nubBy (alias for Prelude.List.nubBy)

    Prelude.List.nubBy
       constant
       type `('a -> 'a -> Bool) -> ['a] -> ['a]`
       executable

  • Prelude.nubBy (alias for Prelude.List.nubBy)

    Prelude.List.nubBy
       constant
       type `('a -> 'a -> Bool) -> ['a] -> ['a]`
       executable

  • Prelude.List.nubBy

    Prelude.List.nubBy
       constant
       type `('a -> 'a -> Bool) -> ['a] -> ['a]`
       executable

• null
  • Data.List.null (alias for Prelude.List.null)

    Prelude.List.null
       constant
       type `['a] -> Bool`
       executable

  • Prelude.null (alias for Prelude.Foldable.null)

    Prelude.Foldable.null
       constant of type-class `Foldable`
       type `'t -> Bool`
       executable

  • Prelude.Foldable.null

    Prelude.Foldable.null
       constant of type-class `Foldable`
       type `'t -> Bool`
       executable

  • Prelude.List.null

    Prelude.List.null
       constant
       type `['a] -> Bool`
       executable

• occur
  • Prelude.occur (alias for Prelude.Collection.occur)

    Prelude.Collection.occur
       constant of type-class `CollectionWithMembershipTest`
       type `'e -> 'c -> Natural`
       executable

  • Prelude.Collection.occur

    Prelude.Collection.occur
       constant of type-class `CollectionWithMembershipTest`
       type `'e -> 'c -> Natural`
       executable

• or
  • Data.List.or (alias for Prelude.List.or)

    Prelude.List.or
       constant
       type `[Bool] -> Bool`
       executable

  • Prelude.or (alias for Prelude.List.or)

    Prelude.List.or
       constant
       type `[Bool] -> Bool`
       executable

  • Prelude.List.or

    Prelude.List.or
       constant
       type `[Bool] -> Bool`
       executable

• ord
  • Prelude.ord (alias for Prelude.Char.ord)

    Prelude.Char.ord
       constant
       type `Char -> Natural`
       executable

  • Prelude.Char.ord

    Prelude.Char.ord
       constant
       type `Char -> Natural`
       executable

• orP
  • Data.List.orP (alias for Prelude.List.orP)

    Prelude.List.orP
       constant
       type `[Prop] -> Prop`
       non executable

  • Prelude.orP (alias for Prelude.List.orP)

    Prelude.List.orP
       constant
       type `[Prop] -> Prop`
       non executable

  • Prelude.List.orP

    Prelude.List.orP
       constant
       type `[Prop] -> Prop`
       non executable

• pack
  • Prelude.pack (alias for Prelude.Text.pack)

    Prelude.Text.pack
       constant
       type `String -> Text`
       executable

  • Prelude.Text.pack

    Prelude.Text.pack
       constant
       type `String -> Text`
       executable

• partition
  • Data.List.partition (alias for Prelude.List.partition)

    Prelude.List.partition
       constant
       type `('a -> Bool) -> ['a] -> (['a], ['a])`
       executable

  • Prelude.partition (alias for Prelude.Collection.partition)

    Prelude.Collection.partition
       constant of type-class `CollectionWithDelete`
       type `('e -> Bool) -> 'c -> ('c, 'c)`
       executable

  • Prelude.Collection.partition

    Prelude.Collection.partition
       constant of type-class `CollectionWithDelete`
       type `('e -> Bool) -> 'c -> ('c, 'c)`
       executable

  • Prelude.List.partition

    Prelude.List.partition
       constant
       type `('a -> Bool) -> ['a] -> (['a], ['a])`
       executable

• pop
  • Data.Collection.Stack.pop

    Data.Collection.Stack.pop
       constant
       type `Data.Collection.Stack.Stack 'a -> Maybe ('a, Data.Collection.Stack.Stack 'a)`
       executable

• pred
  • Prelude.pred (alias for Prelude.BasicClasses.pred)

    Prelude.BasicClasses.pred
       constant of type-class `Enum`
       type `'a -> 'a`
       executable

  • Prelude.BasicClasses.pred

    Prelude.BasicClasses.pred
       constant of type-class `Enum`
       type `'a -> 'a`
       executable

• pure
  • Prelude.pure (alias for Prelude.Monad.return)

    Prelude.Monad.return
       statically resolved constant of type-class `Monad`
       type `'a -> 'M 'a`
       executable

  • Prelude.Monad.pure (alias for Prelude.Monad.return)

    Prelude.Monad.return
       statically resolved constant of type-class `Monad`
       type `'a -> 'M 'a`
       executable

• push
  • Data.Collection.Stack.push

    Data.Collection.Stack.push
       constant
       type `'a -> Data.Collection.Stack.Stack 'a -> Data.Collection.Stack.Stack 'a`
       executable

• removeFirst
  • Data.List.removeFirst (alias for Prelude.List.removeFirst)

    Prelude.List.removeFirst
       constant
       type `('a -> Bool) -> ['a] -> ['a]`
       executable

  • Prelude.removeFirst (alias for Prelude.List.removeFirst)

    Prelude.List.removeFirst
       constant
       type `('a -> Bool) -> ['a] -> ['a]`
       executable

  • Prelude.List.removeFirst

    Prelude.List.removeFirst
       constant
       type `('a -> Bool) -> ['a] -> ['a]`
       executable

• replicate
  • Data.List.replicate

    Data.List.replicate
       constant
       type `Natural -> 'a -> ['a]`
       executable

• return
  • Prelude.return (alias for Prelude.Monad.return)

    Prelude.Monad.return
       statically resolved constant of type-class `Monad`
       type `'a -> 'M 'a`
       executable

  • Prelude.Monad.return

    Prelude.Monad.return
       statically resolved constant of type-class `Monad`
       type `'a -> 'M 'a`
       executable

• revAppend
  • Data.List.revAppend (alias for Prelude.List.revAppend)

    Prelude.List.revAppend
       constant
       type `['a] -> ['a] -> ['a]`
       executable

  • Prelude.revAppend (alias for Prelude.List.revAppend)

    Prelude.List.revAppend
       constant
       type `['a] -> ['a] -> ['a]`
       executable

  • Prelude.List.revAppend

    Prelude.List.revAppend
       constant
       type `['a] -> ['a] -> ['a]`
       executable

• reverse
  • Data.List.reverse (alias for Prelude.List.reverse)

    Prelude.List.reverse
       constant
       type `['a] -> ['a]`
       executable

  • Prelude.reverse (alias for Prelude.List.reverse)

    Prelude.List.reverse
       constant
       type `['a] -> ['a]`
       executable

  • Prelude.List.reverse

    Prelude.List.reverse
       constant
       type `['a] -> ['a]`
       executable

• Right
  • Prelude.Right (alias for Prelude.Either.Right)

    Prelude.Either.Right
       constructor of datatype `Either`
       type `'b -> Either 'a 'b`
       executable

  • Prelude.Either.Right

    Prelude.Either.Right
       constructor of datatype `Either`
       type `'b -> Either 'a 'b`
       executable

• scanl
  • Data.List.scanl (alias for Prelude.List.scanl)

    Prelude.List.scanl
       constant
       type `('a -> 'b -> 'a) -> 'a -> ['b] -> ['a]`
       executable

  • Prelude.scanl (alias for Prelude.List.scanl)

    Prelude.List.scanl
       constant
       type `('a -> 'b -> 'a) -> 'a -> ['b] -> ['a]`
       executable

  • Prelude.List.scanl

    Prelude.List.scanl
       constant
       type `('a -> 'b -> 'a) -> 'a -> ['b] -> ['a]`
       executable

• scanr
  • Data.List.scanr (alias for Prelude.List.scanr)

    Prelude.List.scanr
       constant
       type `('a -> 'b -> 'b) -> 'b -> ['a] -> ['b]`
       executable

  • Prelude.scanr (alias for Prelude.List.scanr)

    Prelude.List.scanr
       constant
       type `('a -> 'b -> 'b) -> 'b -> ['a] -> ['b]`
       executable

  • Prelude.List.scanr

    Prelude.List.scanr
       constant
       type `('a -> 'b -> 'b) -> 'b -> ['a] -> ['b]`
       executable

• sequence
  • Prelude.sequence (alias for Prelude.Monad.sequence)

    Prelude.Monad.sequence
       constant
       type `[('M 'a)] -> 'M ['a]`
       executable

  • Prelude.Monad.sequence

    Prelude.Monad.sequence
       constant
       type `[('M 'a)] -> 'M ['a]`
       executable

• sequence_
  • Prelude.sequence_ (alias for Prelude.Monad.sequence_)

    Prelude.Monad.sequence_
       constant
       type `[('M 'a)] -> 'M ()`
       executable

  • Prelude.Monad.sequence_

    Prelude.Monad.sequence_
       constant
       type `[('M 'a)] -> 'M ()`
       executable

• set
  • Data.Lens.set

    Data.Lens.set
       constant of type-class `Data.Lens.IsSetter`
       type `'v -> 's -> 'b -> 't`
       executable

• setEmpty
  • Prelude.setEmpty (alias for Prelude.Collection.setEmpty)

    Prelude.Collection.setEmpty
       constant
       type `'c`
       executable

  • Prelude.Collection.setEmpty

    Prelude.Collection.setEmpty
       constant
       type `'c`
       executable

• setFromList
  • Prelude.setFromList (alias for Prelude.Collection.setFromList)

    Prelude.Collection.setFromList
       constant
       type `['e] -> 'c`
       executable

  • Prelude.Collection.setFromList

    Prelude.Collection.setFromList
       constant
       type `['e] -> 'c`
       executable

• setInsert
  • Prelude.setInsert (alias for Prelude.Collection.setInsert)

    Prelude.Collection.setInsert
       constant
       type `'e -> 'c -> 'c`
       executable

  • Prelude.Collection.setInsert

    Prelude.Collection.setInsert
       constant
       type `'e -> 'c -> 'c`
       executable

• Setter
  • Data.Lens.Setter

    Data.Lens.Setter
       constructor of record-type `Data.Lens.Setter`
       type `('s -> 'b -> 't) -> Data.Lens.Setter 's 't 'b`
       executable

• setterSet
  • Data.Lens.setterSet

    Data.Lens.setterSet
       field of record-type `Data.Lens.Setter`
       type `Data.Lens.Setter 's 't 'b -> 's -> 'b -> 't`
       executable

• simpleLensToGetter
  • Data.Lens.simpleLensToGetter

    Data.Lens.simpleLensToGetter
       constant
       type `Data.Lens.SimpleLens 'a 'b -> Data.Lens.Getter 'a 'b`
       executable

• singleton
  • Prelude.singleton (alias for Prelude.Collection.singleton)

    Prelude.Collection.singleton
       constant of type-class `Collection`
       type `'e -> 'c`
       executable

  • Prelude.Collection.singleton

    Prelude.Collection.singleton
       constant of type-class `Collection`
       type `'e -> 'c`
       executable

• size
  • Prelude.size (alias for Prelude.Foldable.size)

    Prelude.Foldable.size
       constant of type-class `Foldable`
       type `'t -> Natural`
       executable

  • Prelude.Foldable.size

    Prelude.Foldable.size
       constant of type-class `Foldable`
       type `'t -> Natural`
       executable

• snd
  • Prelude.snd (alias for Prelude.Tuple.snd)

    Prelude.Tuple.snd
       constant
       type `('a, 'b) -> 'b`
       executable

  • Prelude.Tuple.snd

    Prelude.Tuple.snd
       constant
       type `('a, 'b) -> 'b`
       executable

• snoc
  • Data.List.snoc (alias for Prelude.List.snoc)

    Prelude.List.snoc
       constant
       type `['a] -> 'a -> ['a]`
       executable

  • Prelude.snoc (alias for Prelude.List.snoc)

    Prelude.List.snoc
       constant
       type `['a] -> 'a -> ['a]`
       executable

  • Prelude.List.snoc

    Prelude.List.snoc
       constant
       type `['a] -> 'a -> ['a]`
       executable

• span
  • Data.List.span

    Data.List.span
       constant
       type `('a -> Bool) -> ['a] -> (['a], ['a])`
       executable

• splitAt
  • Data.List.splitAt

    Data.List.splitAt
       constant
       type `Natural -> ['a] -> (['a], ['a])`
       executable

• Suc
  • Prelude.Suc (alias for Prelude.Num.Suc)

    Prelude.Num.Suc
       constructor of datatype `Natural`
       type `Natural -> Natural`
       executable

  • Prelude.Num.Suc

    Prelude.Num.Suc
       constructor of datatype `Natural`
       type `Natural -> Natural`
       executable

• succ
  • Prelude.succ (alias for Prelude.BasicClasses.succ)

    Prelude.BasicClasses.succ
       constant of type-class `Enum`
       type `'a -> 'a`
       executable

  • Prelude.BasicClasses.succ

    Prelude.BasicClasses.succ
       constant of type-class `Enum`
       type `'a -> 'a`
       executable

• take
  • Data.List.take

    Data.List.take
       constant
       type `Natural -> ['a] -> ['a]`
       executable

• takeFirst
  • Data.List.takeFirst (alias for Prelude.List.takeFirst)

    Prelude.List.takeFirst
       constant
       type `('a -> Bool) -> ['a] -> Maybe (['a], 'a)`
       executable

  • Prelude.takeFirst (alias for Prelude.List.takeFirst)

    Prelude.List.takeFirst
       constant
       type `('a -> Bool) -> ['a] -> Maybe (['a], 'a)`
       executable

  • Prelude.List.takeFirst

    Prelude.List.takeFirst
       constant
       type `('a -> Bool) -> ['a] -> Maybe (['a], 'a)`
       executable

• takeWhile
  • Data.List.takeWhile

    Data.List.takeWhile
       constant
       type `('a -> Bool) -> ['a] -> ['a]`
       executable

• to
  • Data.Lens.to

    Data.Lens.to
       constant
       type `('a -> 'b) -> Data.Lens.Getter 'a 'b`
       executable

• toEnum
  • Prelude.toEnum (alias for Prelude.BasicClasses.toEnum)

    Prelude.BasicClasses.toEnum
       constant of type-class `Enum`
       type `Natural -> Maybe 'a`
       executable

  • Prelude.BasicClasses.toEnum

    Prelude.BasicClasses.toEnum
       constant of type-class `Enum`
       type `Natural -> Maybe 'a`
       executable

• toGetter
  • Data.Lens.toGetter

    Data.Lens.toGetter
       constant of type-class `Data.Lens.IsGetter`
       type `'v -> Data.Lens.Getter 'a 'b`
       executable

• toList
  • Prelude.toList (alias for Prelude.Foldable.toList)

    Prelude.Foldable.toList
       constant of type-class `Foldable`
       type `'t -> ['e]`
       executable

  • Prelude.Foldable.toList

    Prelude.Foldable.toList
       constant of type-class `Foldable`
       type `'t -> ['e]`
       executable

• toSetter
  • Data.Lens.toSetter

    Data.Lens.toSetter
       constant of type-class `Data.Lens.IsSetter`
       type `'v -> Data.Lens.Setter 's 't 'b`
       executable

• true
  • Prelude.true (alias for Prelude.Bool.true)

    Prelude.Bool.true
       constant
       type `Prop`
       non executable

  • Prelude.Bool.true

    Prelude.Bool.true
       constant
       type `Prop`
       non executable

• True
  • Prelude.True (alias for Prelude.Bool.True)

    Prelude.Bool.True
       constructor of datatype `Bool`
       type `Bool`
       executable

  • Prelude.Bool.True

    Prelude.Bool.True
       constructor of datatype `Bool`
       type `Bool`
       executable

• uexistsB_fun
  • Prelude.uexistsB_fun (alias for Prelude.BasicClasses.uexistsB_fun)

    Prelude.BasicClasses.uexistsB_fun
       constant of type-class `Finite`
       type `('a -> Bool) -> Bool`
       executable

  • Prelude.BasicClasses.uexistsB_fun

    Prelude.BasicClasses.uexistsB_fun
       constant of type-class `Finite`
       type `('a -> Bool) -> Bool`
       executable

• uexistsP_fun
  • Prelude.uexistsP_fun (alias for Prelude.Bool.uexistsP_fun)

    Prelude.Bool.uexistsP_fun
       constant
       type `('a -> Prop) -> Prop`
       non executable

  • Prelude.Bool.uexistsP_fun

    Prelude.Bool.uexistsP_fun
       constant
       type `('a -> Prop) -> Prop`
       non executable

• uncurry
  • Prelude.uncurry (alias for Prelude.Tuple.uncurry)

    Prelude.Tuple.uncurry
       constant
       type `('a -> 'b -> 'c) -> ('a, 'b) -> 'c`
       executable

  • Prelude.Tuple.uncurry

    Prelude.Tuple.uncurry
       constant
       type `('a -> 'b -> 'c) -> ('a, 'b) -> 'c`
       executable

• undefined
  • Prelude.undefined (alias for Prelude.Default.undefined)

    Prelude.Default.undefined
       constant of type-class `Default`
       type `'a`
       executable

  • Prelude.Default.undefined

    Prelude.Default.undefined
       constant of type-class `Default`
       type `'a`
       executable

• union
  • Prelude.union (alias for Prelude.Collection.union)

    Prelude.Collection.union
       constant
       type `'c -> 'c -> 'c`
       executable

  • Prelude.Collection.union

    Prelude.Collection.union
       constant
       type `'c -> 'c -> 'c`
       executable

• Unit
  • Prelude.Unit (alias for Prelude.Unit.Unit)

    Prelude.Unit.Unit
       constructor of datatype `()`
       type `()`
       executable

  • Prelude.Unit.Unit

    Prelude.Unit.Unit
       constructor of datatype `()`
       type `()`
       executable

• universeFoldWithAbort
  • Prelude.universeFoldWithAbort (alias for Prelude.BasicClasses.universeFoldWithAbort)

    Prelude.BasicClasses.universeFoldWithAbort
       statically resolved constant of type-class `Finite`
       type `('acc -> Bool) -> ('acc -> 'a -> 'acc) -> 'acc -> 'acc`
       executable

  • Prelude.BasicClasses.universeFoldWithAbort

    Prelude.BasicClasses.universeFoldWithAbort
       statically resolved constant of type-class `Finite`
       type `('acc -> Bool) -> ('acc -> 'a -> 'acc) -> 'acc -> 'acc`
       executable

• universeList
  • Prelude.universeList (alias for Prelude.BasicClasses.universeList)

    Prelude.BasicClasses.universeList
       constant of type-class `Finite`
       type `['a]`
       executable

  • Prelude.BasicClasses.universeList

    Prelude.BasicClasses.universeList
       constant of type-class `Finite`
       type `['a]`
       executable

• unpack
  • Prelude.unpack (alias for Prelude.Text.unpack)

    Prelude.Text.unpack
       constant
       type `Text -> String`
       executable

  • Prelude.Text.unpack

    Prelude.Text.unpack
       constant
       type `Text -> String`
       executable

• unreachable
  • Prelude.unreachable (alias for Prelude.Default.unreachable)

    Prelude.Default.unreachable
       constant
       type `'a`
       executable

  • Prelude.Default.unreachable

    Prelude.Default.unreachable
       constant
       type `'a`
       executable

• unzip
  • Data.List.unzip

    Data.List.unzip
       constant
       type `[('a, 'b)] -> (['a], ['b])`
       executable

• view
  • Data.Lens.view

    Data.Lens.view
       constant of type-class `Data.Lens.IsGetter`
       type `'v -> 'a -> 'b`
       executable

• Zero
  • Prelude.Zero (alias for Prelude.Num.Zero)

    Prelude.Num.Zero
       constructor of datatype `Natural`
       type `Natural`
       executable

  • Prelude.Num.Zero

    Prelude.Num.Zero
       constructor of datatype `Natural`
       type `Natural`
       executable

• zip
  • Data.List.zip

    Data.List.zip
       constant
       type `['a] -> ['b] -> [('a, 'b)]`
       executable