package spotlib

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Type
Constructors
Deconstructors
Conversions between the eager list
Misc functions
Inpure hacks

package spotlib

spotlib
- Spotlib
  - At
  - Base
  - Command
    
    Ver1
  - Comopt
    
    Error
  - Copiedfilename
    
    Cygwin
    
    Unix
    
    Win32
  - Dllist
  - Exn
    
    Stdlib
  - File
    
    Test
  - Filepath
  - Freem
    
    EX
    
    Infix
    
    M1
    
    EX
    
    Infix
    
    S
    
    M2
    
    EX
    
    Infix
    
    S
    
    S
  - Hashset
    
    Make
    
    A
  - IntRange
  - Monad
    
    Make
    
    EX
    
    Infix
    
    M
    
    S
    
    Make1
    
    EX
    
    Infix
    
    M
    
    S
    
    Make2
    
    EX
    
    Infix
    
    M
    
    S
  - Monad_intf
    
    EX1
    
    EX2
    
    Infix1
    
    Infix2
    
    S1
    
    S2
    
    T1
    
    EX
    
    Infix
    
    S
    
    T2
    
    EX
    
    Infix
    
    S
  - Mtypes
    
    Comparable
    
    Infix
    
    Make_comparable
    
    A
    
    Infix
    
    Printable
  - Once
  - Option
    
    Infix
    
    Stdlib
  - Overload
    
    Float
    
    Int
  - PTest
  - Poly_result
    
    Infix
    
    Stdlib
  - Shell
  - Spot
    
    Array
    
    Bytes
    
    Filename
    
    Format
    
    Gc
    
    Hashtbl
    
    Int64
    
    IntSet
    
    Lazy
    
    Lexing
    
    List
    
    Obj
    
    Printexc
    
    Printf
    
    String
    
    StringSet
    
    Sys
    
    Unix
  - SpotStream
    
    EX
    
    Infix
    
    S
  - Temporal
    
    Date
    
    Infix
    
    Datetime
    
    TZone
    
    Time
    
    Weekday
    
    Year
  - Temporal_lexer
  - Tuple
    
    Stdlib
  - URL
  - UniqueID
  - Vresult
    
    Infix
    
    Stdlib
  - Weaktbl
    
    Bucket
    
    Make
    
    K
    
    O
    
    Poly
  - Xarray
  - Xbytes
    
    Set
    
    Stdlib
  - Xfilename
    
    Stdlib
  - Xformat
  - Xgc
  - Xhashtbl
  - Xint64
  - Xlazy
    
    EX
    
    Infix
    
    S
  - Xlexing
  - Xlist
    
    Infix
    
    Stdlib
  - Xobj
  - Xprintexc
  - Xprintf
  - Xset
    
    Make
    
    O
    
    S
  - Xstring
    
    Set
    
    Stdlib
  - Xsys
  - Xunix
    
    CommandDeprecated
    
    Find
    
    path
    
    Process_times
    
    Stdlib

Legend:
Library
Module
Module type
Parameter
Class
Class type

Lazy list or Stream

Type

type 'a desc =

| Cons of 'a * 'a desc lazy_t
| Null

type 'a t = 'a desc lazy_t

Constructors

val null : 'a t

a constant null

val cons : 'a -> 'a t -> 'a t

val (^^) : 'a -> 'a t -> 'a t

same as cons

val singleton : 'a -> 'a t

val create : ('st -> ('a * 'st) option) -> 'st -> 'a t

Pure functional creator

Deconstructors

val hd : 'a t -> 'a

val tl : 'a t -> 'a t

val peek : 'a t -> ('a * 'a t) option

You can use match with lazy pattern instead of peek

val is_null : 'a t -> bool

null check

val nth : 'a t -> int -> 'a

val length : 'a t -> int

Conversions between the eager list

val to_list : 'a t -> 'a list

Conversion from a lazy stream to a strict list. Do not use against inifinite streams.

val of_list : 'a list -> 'a t

Conversion from a strict list to a lazy stream. The conversion itself is done strictly: the result has no reference to the original list

Misc functions

val take : int -> 'a t -> 'a t

take n t takes the first n elements of t. Lazy.

val init : 'a t -> 'a t

init t returns the same list t but without its final element.

val rev : 'a t -> 'a t

val filter : ('a -> bool) -> 'a t -> 'a t

val filter_map : ('a -> 'b option) -> 'a t -> 'b t

val concat : 'a t t -> 'a t

val mem : 'a -> 'a t -> bool

Membership. Never terminates over inifinite streams.

val iter : ('a -> unit) -> 'a t -> unit

Iteration. Never terminates over inifinite streams.

val map : ('a -> 'b) -> 'a t -> 'b t

Map

val fold_left : 
  ('a Lazy.t -> 'b -> 'a Lazy.t) ->
  'a Lazy.t ->
  'b t ->
  'a Lazy.t

Folding left

val fold_left1 : 
  ('a Lazy.t -> 'a Lazy.t -> 'a Lazy.t) ->
  'a Lazy.t t ->
  'a Lazy.t

fold_left1 f (x^^xs) = fold_left f x xs fold_left1 f null raises an exception.

val fold_left' : ('a -> 'b -> 'b) -> 'b -> 'a t -> 'b

Folding left, strict version. Never terminates over inifinite streams. Tail recursive.

val fold_right : 
  ('a -> 'b lazy_t -> 'b lazy_t) ->
  'a t ->
  'b lazy_t ->
  'b lazy_t

fold_right f t init. Folding right. Not tail recursive. If laziness is required, it is the responsibility of f.

val fold_right1 : 
  ('a -> 'a lazy_t -> 'a lazy_t) ->
  'a t ->
  'a lazy_t ->
  'a lazy_t

fold_right1 f (append xs (singleton x)) = fold_right f xs x fold_right1 f null raises an exception. If laziness is required, it is the responsibility of f.

val append : 'a t -> 'a t -> 'a t

Append. Lazy.

val intercalate : 'a t -> 'a t t -> 'a t

Haskell's intercalate

val intersparse : 'a -> 'a t -> 'a t

Haskell's intersparse

val split_at : int -> 'a t -> 'a list * 'a t

Haskell's splitAt. Prefix is forced.

val split_at' : int -> 'a t -> 'a t * 'a t

Haskell's splitAt. Prefix is lazy.

Inpure hacks

val rev_between : 'a t -> 'a t -> 'a list

val between : 'a t -> 'a t -> 'a list

Get elements between two points of the *same* stream.

The first argument of rev_between and between must point the former element of the stream than the second argument. Otherwise, the behaviour of rev_between and between are not specified: a wrong result or memory exhaustion by an infinite loop.

Monadic interface

include Monad.T with type 'a t := 'a t

include Monad_intf.S1 with type 'a t := 'a t

val return : 'a -> 'a t

val bind : 'a t -> ('a -> 'b t) -> 'b t

include Monad_intf.EX1 with type 'a t := 'a t

val fmap : ('a -> 'b) -> 'a t -> 'b t

fmap in Haskell

val liftM : ('a -> 'b) -> 'a t -> 'b t

synonym of fmap

val fmap2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t

fmap2 in Haskell

val liftM2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t

synonym of fmap2

val void : 'a t -> unit t

val seq : 'a t list -> 'a list t

sequence in Haskell. Not tail recursive.

val seq_ : unit t list -> unit t

sequence_ in Haskell. Not tail recursive.

val mapM : ('a -> 'b t) -> 'a list -> 'b list t

Not tail recursive

val mapM_ : ('a -> unit t) -> 'a list -> unit t

Not tail recursive

val iteri : (int -> 'a -> unit t) -> 'a list -> unit t

Iteration with index starting from 0. Not tail recursive.

val for_ : int -> int -> (int -> unit t) -> unit t

for like iteration. Not tail recursive

val join : 'a t t -> 'a t

include Monad_intf.Infix1 with type 'a t := 'a t

val (>>=) : 'a t -> ('a -> 'b t) -> 'b t

synonym of bind

val (>>|) : 'a t -> ('a -> 'b) -> 'b t

synonum of fmap, with the flipped arguments

Applicative style binops

val (^<$>) : ('a -> 'b) -> 'a t -> 'b t

same as map, <$> in Haskell

val (/<*>) : ('a -> 'b) t -> 'a t -> 'b t

<*> in Haskell

module S : Monad_intf.S1 with type 'a t := 'a t

module EX : Monad_intf.EX1 with type 'a t := 'a t

module Infix : Monad_intf.Infix1 with type 'a t := 'a t