reagent.ratom — reagent 1.1.0

*ratom-context* cljs

atom cljs

(atom x)

(atom x & {:keys [meta validator]})

Like clojure.core/atom, except that it keeps track of derefs.

check-derefs cljs

(check-derefs f)

cursor cljs

(cursor src path)

debug cljs

flush! cljs

(flush!)

IDisposable cljs protocol

add-on-dispose! cljs

(add-on-dispose! this f)

dispose! cljs

(dispose! this)

IReactiveAtom cljs protocol

IRunnable cljs protocol

run cljs

(run this)

make-reaction cljs

(make-reaction f & {:keys [auto-run on-set on-dispose]})

make-track cljs

(make-track f args)

make-track! cljs

(make-track! f args)

make-wrapper cljs

(make-wrapper value callback-fn args)

RAtom cljs

RCursor cljs

reaction cljs macro

(reaction & body)

Reaction cljs

reactive? cljs

(reactive?)

run! cljs macro

(run! & body)

Runs body immediately, and runs again whenever atoms deferenced in the body change. Body should side effect.

run-in-reaction cljs

(run-in-reaction f obj key run opts)

Evaluates f and returns the result. If f calls deref on any ratoms, creates a new Reaction that watches those atoms and calls run whenever any of those watched ratoms change. Also, the new reaction is added to list of 'watches' of each of the ratoms. The run parameter is a function that should expect one argument. It is passed obj when run. The opts are any options accepted by a Reaction and will be set on the newly created Reaction. Sets the newly created Reaction to the key on obj.

running cljs

(running)

track cljs

(track f & args)

Track cljs

track! cljs

(track! f & args)

with-let cljs macro

(with-let bindings & body)

with-let-destroy cljs

(with-let-destroy v)

with-let-values cljs

(with-let-values key)

Wrapper cljs