CrossClj

1.9.0 docs

SourceDocs



RECENT
    VARS
    alet
    all
    any
    attempt
    await
    bind
    branch
    cancel!
    cancelled?
    catch
    chain
    delay
    do*
    done?
    err
    error
    extract
    finally
    map
    mapcat
    pending?
    promise
    promise?
    promisify
    rejected
    rejected?
    resolved
    resolved?
    schedule
    set-executor!
    then

    « Index of all namespaces of this project

    macro
    (alet bindings & body)
    A let alternative that always returns promise and allows
    use await marker function in order to emulate the async/await
    syntax and make the let expression look like synchronous where
    async operations are performed.
    (all promises)
    Given an array of promises, return a promise
    that is fulfilled  when all the items in the
    array are fulfilled.
    
    Example:
    
    (-> (all [(promise :first-promise)
              (promise :second-promise)]
        (then (fn [[first-result second-result]]))
         (println (str first-result ", " second-result)
    
    Will print out
    :first-promise, :second-promise.
    
    If at least one of the promises is rejected, the resulting promise will be
    rejected.
    (any promises)
    Given an array of promises, return a promise
    that is fulfilled when first one item in the
    array is fulfilled.
    (attempt callback)
    A helper for start promise chain without worry about
    synchronous or asynchronous exceptions. Returns a promise
    resolved with the return value of the callback.
    (await & args)
    (bind p f)
    A chain helper for promises.
    
    (branch p success failure)
    (cancel! p)
    Cancel the promise.
    
    (cancelled? v)
    Return true if v is a cancelled promise.
    
    (catch p f)(catch p pred-or-type f)
    Catch all promise chain helper.
    
    (chain p & funcs)
    Like then but accepts multiple parameters.
    
    (delay t)(delay t v)
    Given a timeout in miliseconds and optional
    value, returns a promise that will fulfilled
    with provided value (or nil) after the
    time is reached.
    macro
    (do* & body)
    A sugar syntax on top of attempt.
    
    Returns true if promise p is already done.
    
    A short alias for error function.
    
    (error f p)(error f type p)
    Same as catch but with parameters inverted.
    
    (extract p)
    Returns the current promise value.
    
    (finally p callback)
    Attach handler to promise that will be
    executed independently if promise is
    resolved or rejected.
    (map f p)
    Apply a function to the promise value and
    return a new promise with the result.
    (mapcat f p)
    Same as map but removes one level of
    promise neesting. Useful when the map function
    returns a promise instead of value.
    
    In JS environment this function is analogous
    to map because the promise abstraction overloads
    the map operator.
    (pending? p)
    Returns true if promise p is stil pending.
    
    (promise v)
    The promise constructor.
    
    (promise? v)
    Return true if v is a promise instance.
    
    (promisify callable)
    Given a function that accepts a callback as the last argument return other
    function that returns a promise. Callback is expected to take single
    parameter (result of a computation).
    (rejected v)
    Return a rejected promise with provided reason.
    
    (rejected? p)
    Returns true if promise p is already rejected.
    
    (resolved v)
    Return a resolved promise with provided value.
    
    (resolved? p)
    Returns true if promise p is already fulfilled.
    
    (schedule ms func)
    Schedule a callable to be executed after the ms delay
    is reached.
    
    In JVM it uses a scheduled executor service and in JS
    it uses the setTimeout function.
    (set-executor! executor)
    Replace the default executor instance with
    your own instance.
    (then p f)
    Similar to map but with parameters inverted
    for convenience and for familiarity with
    javascript's promises .then operator.
    
    Unlike Clojure's map, will resolve any promises
    returned  by f.