CrossClj

0.5.2 docs

SourceDocs


project

docs index

NAMESPACES
clojure.core.typed
collect
test
CTYP-234
ann-qualify
ctyp-294
fail
gradual
succeed

RECENT
    VARS
    ->cont-monad
    ->list-transformer
    ->maybe-monad
    ->maybe-transformer
    ->set-transformer
    ->state-monad
    ->state-transformer
    ->vector-transformer
    ->writer-monad
    ->writer-transformer
    assoc-in-val
    call-cc
    censor
    chain
    comprehend
    cont
    do
    fmap
    get-in-val
    get-state
    get-val
    join
    lazy-concat
    lift
    list-t
    listen
    map
    maybe
    maybe-t
    maybe-zero-val
    Monad
    MonadWriter
    MonadZero
    plus
    seq
    set-state
    set-t
    set-val
    state
    state-t
    update-in-val
    update-state
    update-val
    vector-t
    write
    writer
    writer-t

    « Index of all namespaces of this project

    (->cont-monad v mv f)
    Positional factory function for class clojure.core.typed.test.protocol_monads.cont-monad.
    
    (->list-transformer m v)
    Positional factory function for class clojure.core.typed.test.protocol_monads.list-transformer.
    
    (->maybe-monad v)
    Positional factory function for class clojure.core.typed.test.protocol_monads.maybe-monad.
    
    (->maybe-transformer m v)
    Positional factory function for class clojure.core.typed.test.protocol_monads.maybe-transformer.
    
    (->set-transformer m v)
    Positional factory function for class clojure.core.typed.test.protocol_monads.set-transformer.
    
    (->state-monad v mv f)
    Positional factory function for class clojure.core.typed.test.protocol_monads.state-monad.
    
    (->state-transformer m v mv f alts)
    Positional factory function for class clojure.core.typed.test.protocol_monads.state-transformer.
    
    (->vector-transformer m v)
    Positional factory function for class clojure.core.typed.test.protocol_monads.vector-transformer.
    
    (->writer-monad v accumulator)
    Positional factory function for class clojure.core.typed.test.protocol_monads.writer-monad.
    
    (->writer-transformer m mv writer-m)
    Positional factory function for class clojure.core.typed.test.protocol_monads.writer-transformer.
    
    (assoc-in-val path val)
    (call-cc f)
    A computation in the cont monad that calls function f with a single
    argument representing the current continuation. The function f should
    return a continuation (which becomes the return value of call-cc),
    or call the passed-in current continuation to terminate.
    (censor f mv)
    (chain steps)
    Chains together monadic computation steps that are each functions
    of one parameter. Each step is called with the result of the previous
    step as its argument. (m-chain (step1 step2)) is equivalent to
    (fn [x] (domonad [r1 (step1 x) r2 (step2 r1)] r2)).
    Private
    (comprehend f mvs)
    (cont v)
    Monad describing computations in continuation-passing style. The monadic
    values are functions that are called with a single argument representing
    the continuation of the computation, to which they pass their result.
    macro
    (do result bindings expr)
    Monad comprehension. Takes the name of a monad (like vector, hash-set),
    a vector of steps given as binding-form/monadic-expression pairs, and
    a result value specified by expr. The monadic-expression terms can use
    the binding variables of the previous steps.
    If the monad contains a definition of m-zero, the step list can also
    contain conditions of the form :when p, where the predicate p can
    contain the binding variables from all previous steps.
    A clause of the form :let [binding-form expr ...], where the bindings
    are given as a vector as for the use in let, establishes additional
    bindings that can be used in the following steps.
    (fmap f mv)
    Bind the monadic value mv to the function f. Returning (f x) for argument x
    
    (get-in-val path & [default])
    (get-state)
    Return a state-monad value that returns the current state and does not
    modify it.
    (get-val key)
    Return a state-monad value that assumes the state to be a map and
    returns the value corresponding to the given key. The state is not modified.
    (join mv)
    Converts a monadic value containing a monadic value into a 'simple'
    monadic value.
    Private
    (lazy-concat l)(lazy-concat l ls)
    (lift f)
    Converts of function f to a function of monadic arguments
    returning a monadic value.
    (list-t m)
    monad transformer that transforms a monad m into a monad in which
    the base values are lists.
    (map f xs)
    'Executes' the sequence of monadic values resulting from mapping
    f onto the values xs. f must return a monadic value.
    (maybe v)
    Monad describing computations with possible failures. Failure is
    represented by nil, any other value is considered valid. As soon as
    a step returns nil, the whole computation will yield nil as well.
    (maybe-t m)
    Monad transformer that transforms a monad m into a monad in which
    the base values can be invalid (represented by :nothing).
    protocol
    Accumulation of values into containers
    
    (writer-m-add container value)
    add value to container, return new container
    
    (writer-m-combine container1 container2)
    combine two containers, return new container
    
    (writer-m-empty _)
    return an empty container
    
    (plus [mv & mvs])
    (seq mvs)(seq m-result mvs)
    'Executes' the monadic values in 'mvs' and returns a sequence of the
    basic values contained in them.
    (set-state s)
    Return a state-monad value that replaces the current state by s and
    returns the previous state.
    (set-t m)
    monad transformer that transforms a monad m into a monad in which
    the base values are sets.
    (set-val key val)
    Return a state-monad value that assumes the state to be a map and
    replaces the value associated with key by val. The old value is returned.
    (state v)
    Monad describing stateful computations. The monadic values have the
    structure (fn [old-state] [result new-state]).
    (state-t m)
    Monad transformer that transforms a monad m into a monad of stateful
    computations that have the base monad type as their result.
    (update-in-val path f & args)
    (update-state f)
    Return a state-monad value that replaces the current state by the
    result of f applied to the current state and that returns the old state.
    (update-val key f & args)
    Return a state-monad value that assumes the state to be a map and
    replaces the value associated with the given key by the return value
    of f applied to the old value and args. The old value is returned.
    (vector-t m)
    monad transformer that transforms a monad m into a monad in which
    the base values are vectors.
    (write m-result val-to-write)
    (writer accumulator)
    Monad describing computations that accumulate data on the side, e.g. for
    logging. The monadic values have the structure [value log]. Any of the
    accumulators from clojure.contrib.accumulators can be used for storing the
    log data. Its empty value is passed as a parameter.
    (writer-t m accumulator)