reagent.ratom

*ratom-context*

dynamic

atom

(atom x)(atom x & {:keys [meta validator]})
Like clojure.core/atom, except that it keeps track of derefs.

check-derefs

(check-derefs f)

cursor

(cursor src path)

debug

flush!

(flush!)

IDisposable

protocol

members

dispose!

(dispose! this)

add-on-dispose!

(add-on-dispose! this f)

IReactiveAtom

protocol

IRunnable

protocol

members

run

(run this)

make-reaction

(make-reaction f & {:keys [auto-run on-set on-dispose]})
Creates a Reaction from a function.

- :auto-run - starts running the reaction immediately, and runs again when
atoms deferenced in the function change.
- :on-set - runs when reaction value is updated, before notifying watchers.
- :on-dispose - runs when the reaction is disposed.

make-track

(make-track f args)

make-track!

(make-track! f args)

make-wrapper

(make-wrapper value callback-fn args)

RAtom

RCursor

reaction

macro

(reaction & body)
Prefer using reagent.core/reaction.

Reaction

reaction

macro

(reaction & body)
Prefer using reagent.core/reaction.

reactive?

(reactive?)

run!

macro

(run! & body)
Creates a Reaction from the body, and runs the body immediately
and again whenever atoms deferenced in the body
change. Body should side effect.

Use dispose! to stop running the Reaction.

run!

macro

(run! & body)
Creates a Reaction from the body, and runs the body immediately
and again whenever atoms deferenced in the body
change. Body should side effect.

Use dispose! to stop running the Reaction.

run-in-reaction

(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

(running)

track

(track f & args)

Track

track!

(track! f & args)

with-let

macro

(with-let bindings & body)

with-let

macro

(with-let bindings & body)

with-let-destroy

(with-let-destroy v)

with-let-values

(with-let-values key)

Wrapper