Liking cljdoc? Tell your friends :D

space.matterandvoid.subscriptions.impl.reagent-ratom


add-on-dispose!clj/s≠

(add-on-dispose! a-ratom f)
clj

On JVM Clojure, use an atom to register f to be invoked when dispose! is invoked with a-ratom.

On JVM Clojure, use an atom to register `f` to be invoked when `dispose!` is
invoked with `a-ratom`.
source (clj)source (cljs)raw docstring

atomclj/s≠

clj
(atom x)
cljs
source (clj)source (cljs)

cached-reactioncljs

(cached-reaction f ratom k obj destroy)
source

cursorclj/s≠

clj
(cursor src path)
cljs
(cursor ratom path)
source (clj)source (cljs)

cursor?clj/s

(cursor? r)
source (clj)source (cljs)

debug-enabled?clj/s≠

cljs

@define {boolean}

@define {boolean}
source (clj)source (cljs)raw docstring

deref?clj/s

(deref? x)
source (clj)source (cljs)

dispose!clj/s≠

(dispose! a-ratom)
clj

On JVM Clojure, invoke all callbacks registered with add-on-dispose! for a-ratom.

On JVM Clojure, invoke all callbacks registered with `add-on-dispose!` for
`a-ratom`.
source (clj)source (cljs)raw docstring

in-reactive-contextclj/s≠

clj
(in-reactive-context _ f)
cljs
(in-reactive-context o f)
source (clj)source (cljs)

make-reactionclj/s≠

(make-reaction f)
clj

On JVM Clojure, return a deref-able thing which invokes the given function on every deref. That is, make-reaction here provides precisely none of the benefits of reagent.ratom/make-reaction (which only invokes its function if the reactions that the function derefs have changed value). But so long as f only depends on other reactions (which also behave themselves), the only difference is one of efficiency. That is, your tests should see no difference other than that they do redundant work.

On JVM Clojure, return a `deref`-able thing which invokes the given function
on every `deref`. That is, `make-reaction` here provides precisely none of the
benefits of `reagent.ratom/make-reaction` (which only invokes its function if
the reactions that the function derefs have changed value). But so long as `f`
only depends on other reactions (which also behave themselves), the only
difference is one of efficiency. That is, your tests should see no difference
other than that they do redundant work.
source (clj)source (cljs)raw docstring

on-loadclj

(on-load listener)
source

ratom?clj/s

(ratom? x)
source (clj)source (cljs)

reaction?clj/s

(reaction? r)
source (clj)source (cljs)

reactive-context?clj/s

(reactive-context?)
source (clj)source (cljs)

reagent-idclj/s≠

(reagent-id reactive-val)
clj

Doesn't make sense in a Clojure context currently.

Doesn't make sense in a Clojure context currently.
cljs

Produces an id for reactive Reagent values e.g. reactions, ratoms, cursors.

Produces an id for reactive Reagent values
e.g. reactions, ratoms, cursors.
source (clj)source (cljs)raw docstring

run-in-reactionclj/s

(run-in-reaction f obj key run opts)
source (clj)source (cljs)

cljdoc is a website building & hosting documentation for Clojure/Script libraries

× close