package spotlib

You can search for identifiers within the package.

in-package search v0.2.0

package spotlib

spotlib
- Spotlib
  - At
  - Base
  - Command
    
    Ver1
  - Comopt
    
    Error
  - Copiedfilename
    
    Cygwin
    
    Unix
    
    Win32
  - Dllist
  - Exn
    
    Stdlib
  - File
    
    Test
  - Filepath
  - Freem
    
    M1
    
    M2
  - Hashset
    
    Make
    
    A
  - IntRange
  - Monad
    
    Make
    
    Infix
    
    M
    
    Syntax
    
    Make2
    
    Infix
    
    M
    
    Syntax
  - Monad_intf
    
    Infix1
    
    Infix2
    
    S1
    
    S2
    
    Syntax1
    
    Syntax2
    
    T1
    
    T2
  - Mtypes
    
    Comparable
    
    Infix
    
    Make_comparable
    
    A
    
    Infix
    
    Printable
  - Once
  - Option
    
    Infix
    
    Stdlib
    
    Syntax
  - Overload
    
    Float
    
    Int
  - PTest
  - Poly_result
    
    Infix
    
    Stdlib
    
    Syntax
  - Shell
  - Spot
    
    Array
    
    Bytes
    
    Filename
    
    Format
    
    Gc
    
    Hashtbl
    
    Int64
    
    IntSet
    
    Lazy
    
    Lexing
    
    List
    
    Obj
    
    Printexc
    
    Printf
    
    String
    
    StringSet
    
    Sys
    
    Unix
  - SpotStream
  - Temporal
    
    Date
    
    Infix
    
    Datetime
    
    TZone
    
    Time
    
    Weekday
    
    Year
  - Temporal_lexer
  - Tuple
    
    Stdlib
  - URL
  - UniqueID
  - Vresult
    
    Infix
    
    Stdlib
    
    Syntax
  - Weaktbl
    
    Bucket
    
    Make
    
    K
    
    O
    
    Poly
  - Xarray
  - Xbytes
    
    Set
    
    Stdlib
  - Xfilename
    
    Stdlib
  - Xformat
  - Xgc
  - Xhashtbl
  - Xint64
  - Xlazy
  - Xlexing
  - Xlist
    
    Infix
    
    Stdlib
    
    Syntax
  - 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

type ('a, 'error) t = [

| `Ok of 'a
| `Error of 'error

]

include Monad.T2 with type ('a, 'error) t := ('a, 'error) t

val return : 'a -> ('a, 'z) t

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

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

fmap in Haskell

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

Synonym of fmap

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

fmap2 in Haskell

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

synonym of fmap2 in Haskell

val void : ('a, 'z) t -> (unit, 'z) t

val seq : ('a, 'z) t list -> ('a list, 'z) t

sequence in Haskell. Not tail recursive.

val seq_ : (unit, 'z) t list -> (unit, 'z) t

sequence_ in Haskell. Not tail recursive.

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

Not tail recursive by default

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

Not tail recursive by default

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

Iteration with index starting from 0. Not tail recursive by default.

val for_ : int -> int -> (int -> (unit, 'z) t) -> (unit, 'z) t

for like iteration. Not tail recursive by default

val join : (('a, 'z) t, 'z) t -> ('a, 'z) t

val prod : ('a, 'z) t -> ('b, 'z) t -> ('a * 'b, 'z) t

module Infix : sig ... end

module Syntax : Monad.Syntax2 with type ('a, 'b) t := ('a, 'b) t

val fail : 'a -> [> `Error of 'a ]

val catch : (fail:('error -> 'exn) -> 'a) -> [> ('a, 'error) t ]

catch f runs f ~fail.

If f ~fail returns a value v then catch f returns `Ok v.

If f ~fail calls fail e, then the execution of the f ~fail immediately exists and catch f returns `Error e

Any exception raised in f ~fail is not caught.

val catch_exn : (unit -> 'a) -> [> ('a, exn) t ]

catch_exn f runs f ().

If f () returns a value v then catch f returns `Ok v.

If an exception exn raised in f (), catch f returns `Error exn.

val from_Ok : [< ('a, 'error) t ] -> 'a

Haskell's fromJust

val result : ('a -> 'b) -> ('c -> 'b) -> [< ('a, 'c) t ] -> 'b

Haskell's either

val map_error : ('e -> 'f) -> ('a, 'e) t -> ('a, 'f) t

val at_Error : ('err -> 'a) -> [< ('a, 'err) t ] -> 'a

at_Error = result id

val to_option : [< ('a, 'err) t ] -> 'a option

Conversion to option type

module Stdlib : sig ... end