adamc@794: datatype t = datatype Basis.list
adamc@794: 
adamc@846: val show : a ::: Type -> show a -> show (t a)
adamc@846: val eq : a ::: Type -> eq a -> eq (t a)
adamc@794: 
adamc@845: val foldl : a ::: Type -> b ::: Type -> (a -> b -> b) -> b -> t a -> b
adamc@850: val foldlAbort : a ::: Type -> b ::: Type -> (a -> b -> option b) -> b -> t a -> option b
adamc@850: val foldlMapAbort : a ::: Type -> b ::: Type -> c ::: Type
adamc@850:                     -> (a -> b -> option (c * b)) -> b -> t a -> option (t c * b)
adamc@845: 
adamc@1057: val foldr : a ::: Type -> b ::: Type -> (a -> b -> b) -> b -> t a -> b
adamc@1057: 
adamc@916: val length : a ::: Type -> t a -> int
adamc@916: 
adamc@794: val rev : a ::: Type -> t a -> t a
adamc@794: 
adamc@821: val revAppend : a ::: Type -> t a -> t a -> t a
adamc@821: 
adamc@821: val append : a ::: Type -> t a -> t a -> t a
adamc@821: 
adamc@794: val mp : a ::: Type -> b ::: Type -> (a -> b) -> t a -> t b
adamc@794: 
adamc@821: val mapPartial : a ::: Type -> b ::: Type -> (a -> option b) -> t a -> t b
adamc@821: 
adamc@1279: val mapi : a ::: Type -> b ::: Type -> (int -> a -> b) -> t a -> t b
adamc@1279: 
adamc@796: val mapX : a ::: Type -> ctx ::: {Unit} -> (a -> xml ctx [] []) -> t a -> xml ctx [] []
adamc@800: 
adam@1539: val mapXi : a ::: Type -> ctx ::: {Unit} -> (int -> a -> xml ctx [] []) -> t a -> xml ctx [] []
adam@1539: 
adamc@800: val mapM : m ::: (Type -> Type) -> monad m -> a ::: Type -> b ::: Type
adamc@830:            -> (a -> m b) -> t a -> m (t b)
adamc@830: 
adamc@1107: val mapPartialM : m ::: (Type -> Type) -> monad m -> a ::: Type -> b ::: Type -> (a -> m (option b)) -> t a -> m (t b)
adamc@1107:                                                                         
adamc@830: val mapXM : m ::: (Type -> Type) -> monad m -> a ::: Type -> ctx ::: {Unit}
adamc@830:             -> (a -> m (xml ctx [] [])) -> t a -> m (xml ctx [] [])
adamc@821: 
adam@1768: val mapXiM : m ::: (Type -> Type) -> monad m -> a ::: Type -> ctx ::: {Unit} -> (int -> a -> m (xml ctx [] [])) -> t a -> m (xml ctx [] [])
adam@1768: 
adamc@821: val filter : a ::: Type -> (a -> bool) -> t a -> t a
adamc@822: 
adamc@822: val exists : a ::: Type -> (a -> bool) -> t a -> bool
adamc@822: 
adamc@840: val foldlM : m ::: (Type -> Type) -> monad m -> a ::: Type -> b ::: Type
adamc@840:              -> (a -> b -> m b) -> b -> t a -> m b
adamc@840: 
adam@1547: val foldlMi : m ::: (Type -> Type) -> monad m -> a ::: Type -> b ::: Type
adam@1547:              -> (int -> a -> b -> m b) -> b -> t a -> m b
adam@1547: 
adam@1634: val filterM : m ::: (Type -> Type) -> monad m -> a ::: Type
adam@1634:               -> (a -> m bool) -> t a -> m (t a)
adam@1634: 
adamc@822: val foldlMap : a ::: Type -> b ::: Type -> c ::: Type
adamc@822:                -> (a -> b -> c * b) -> b -> t a -> t c * b
adamc@839: 
adam@2095: val mem : a ::: Type -> eq a -> a -> t a -> bool
adam@2095: 
adam@1519: val find : a ::: Type -> (a -> bool) -> t a -> option a
adam@1519: 
adamc@839: val search : a ::: Type -> b ::: Type -> (a -> option b) -> t a -> option b
adamc@843: 
adamc@843: val all : a ::: Type -> (a -> bool) -> t a -> bool
adamc@844: 
adamc@844: val app : m ::: (Type -> Type) -> monad m -> a ::: Type
adamc@844:           -> (a -> m unit) -> t a -> m unit
adamc@845: 
adam@1840: val tabulateM : m ::: (Type -> Type) -> monad m -> a ::: Type
adam@1840:                 -> (int -> m a) -> int -> m (t a)
adam@1840: 
adamc@908: val mapQuery : tables ::: {{Type}} -> exps ::: {Type} -> t ::: Type
adamc@908:                -> [tables ~ exps] =>
adam@1394:     sql_query [] [] tables exps
adamc@908:     -> ($(exps ++ map (fn fields :: {Type} => $fields) tables) -> t)
adamc@908:     -> transaction (list t)
adamc@845: 
adamc@1107: val mapQueryM : tables ::: {{Type}} -> exps ::: {Type} -> t ::: Type
adamc@1107:                -> [tables ~ exps] =>
adam@1394:     sql_query [] [] tables exps
adamc@1107:     -> ($(exps ++ map (fn fields :: {Type} => $fields) tables) -> transaction t)
adamc@1107:     -> transaction (list t)
adamc@1107: 
adamc@1107: val mapQueryPartialM : tables ::: {{Type}} -> exps ::: {Type} -> t ::: Type
adamc@1107:                -> [tables ~ exps] =>
adam@1394:     sql_query [] [] tables exps
adamc@1107:     -> ($(exps ++ map (fn fields :: {Type} => $fields) tables) -> transaction (option t))
adamc@1107:     -> transaction (list t)
adamc@1107: 
adam@1321: val sort : a ::: Type -> (a -> a -> bool) (* > predicate *) -> t a -> t a
adam@1321: 
adam@1322: val nth : a ::: Type -> list a -> int -> option a
adam@1345: val replaceNth : a ::: Type -> list a -> int -> a -> list a
adam@1322: 
adamc@845: (** Association lists *)
adamc@845: 
adamc@845: val assoc : a ::: Type -> b ::: Type -> eq a -> a -> t (a * b) -> option b
adamc@845: 
adamc@845: val assocAdd : a ::: Type -> b ::: Type -> eq a -> a -> b -> t (a * b) -> t (a * b)
greenrd@1481: 
greenrd@1481: (** Converting records to lists *)
greenrd@1481: 
greenrd@1481: val recToList : a ::: Type -> r ::: {Unit} -> folder r -> $(mapU a r) -> t a
adam@1634: 
adam@1634: (* Divide a list into two sections at a particular 0-based position, returning the second, first, or both parts, respectively. *)
adam@1634: val drop : t ::: Type -> int -> list t -> list t
adam@1634: val take : t ::: Type -> int -> list t -> list t
adam@1634: val splitAt : t ::: Type -> int -> list t -> list t * list t