Liking cljdoc? Tell your friends :D

reacl-c.core


add-stateclj/s

(add-state initial lens item)

Adds new state that the given item can access, via a lens on the the tuple of states [outer inner], where the initial value for inner state is initial. Note that the resulting item has only outer as its state.

Adds new state that the given item can access, via a lens on the
the tuple of states `[outer inner]`, where the initial value for
`inner` state is `initial`. Note that the resulting item has only
`outer` as its state.
sourceraw docstring

constantlyclj/s

source

def-dynamicclj/s≠macro

clj
(def-dynamic name state & body)
cljs
(def-dynamic &form &env name state & body)

A macro to define a new dynamic item. For example, given

(def-dynamic current-state state
  (dom/span "Current state is: " (pr-str state)))

then current-state is an item that shows the current state as it changes over time. This is similar to defn-dynamic but without the arguments.

A macro to define a new dynamic item. For example, given

```
(def-dynamic current-state state
  (dom/span "Current state is: " (pr-str state)))
```

  then `current-state` is an item that shows the current state as it
  changes over time. This is similar to [[defn-dynamic]] but without the
  arguments.
source (clj)source (cljs)raw docstring

def-namedclj/smacro

(def-named name item)

A macro to define a named item. This is the same as Clojures def, but in addition assigns its name to the item which can be used by testing and debugging utilities.

A macro to define a named item. This is the same as Clojures
`def`, but in addition assigns its name to the item which can be
used by testing and debugging utilities.
source (clj)source (cljs)raw docstring

defn-dynamicclj/s≠macro

clj
(defn-dynamic name state args & body)
cljs
(defn-dynamic &form &env name state args & body)

A macro to define a new abstract dynamic item. For example, given

(defn-dynamic greeting state [arg]
  (dom/div (str arg " " state)))

You can create a new dynamic item by calling (greeting "Hello"), which looks exactly like

(dom/div (str "Hello" " " "world")

when the current state of the item is state, and changes whenever the state changes.

A macro to define a new abstract dynamic item. For example, given

```
(defn-dynamic greeting state [arg]
  (dom/div (str arg " " state)))
```

  You can create a new dynamic item by calling `(greeting "Hello")`, which looks exactly like

```
(dom/div (str "Hello" " " "world")
```

  when the current state of the item is `state`, and changes whenever the state changes.
source (clj)source (cljs)raw docstring

defn-effectclj/s≠macro

clj
(defn-effect name args & body)
cljs
(defn-effect &form &env name args & body)

A macro similar to defn, that defines a new effect.

(defn-effect my-effect [arg]
  (change-the-world! args)
  (return)

Calling it returns an effect action, which can be returned by an item as an action. The body of the effect then executed later, when side effects on some external entity are safe.

A macro similar to defn, that defines a new effect.

```
(defn-effect my-effect [arg]
  (change-the-world! args)
  (return)
```

Calling it returns an effect action, which can be returned by an item
  as an action. The body of the effect then executed later, when side
  effects on some external entity are safe.
 
source (clj)source (cljs)raw docstring

defn-namedclj/s≠macro

clj
(defn-named name args & body)
cljs
(defn-named &form &env name args & body)

A macro to define an abstract item. This is the same as Clojures defn, but in addition assigns its name to the returned item which can be used by testing and debugging utilities.

A macro to define an abstract item. This is the same as Clojures
`defn`, but in addition assigns its name to the returned item which can be
used by testing and debugging utilities.
source (clj)source (cljs)raw docstring

defn-subscriptionclj/s≠macro

clj
(defn-subscription name deliver! args & body)
cljs
(defn-subscription &form &env name deliver! args & body)

A macro to define the integration of an external source of actions, that needs an imperative way to 'inject' actions into an application. This could be an interval timer, for example:

(defn-subscription interval-timer deliver! [ms]
  (let [id (.setInterval js/window (fn [] (deliver! (js/Date.))) ms)]
    (fn []
      (.clearInterval js/window id))))

With this definition, you can use (interval-timer 1000) as an item in your application. That item will be invisible, but will emit a JavaScript Date object as an action every second.

Note that deliver! must never be called directly in the body of defn-subscription, but only later, from an asynchronous context. Also note that the body is evaluated as soon as the subscription item is mounted into your application, and that it must result in a function with no arguments, which is called when the item is removed from the application afterwards.

A macro to define the integration of an external source of actions,
  that needs an imperative way to 'inject' actions into an
  application. This could be an interval timer, for example:

```
(defn-subscription interval-timer deliver! [ms]
  (let [id (.setInterval js/window (fn [] (deliver! (js/Date.))) ms)]
    (fn []
      (.clearInterval js/window id))))
```

With this definition, you can use `(interval-timer 1000)` as an
  item in your application. That item will be invisible, but
  will emit a JavaScript `Date` object as an action every second.

Note that `deliver!` must never be called directly in the body of
  `defn-subscription`, but only later, from an *asynchronous context*.
  Also note that the body is evaluated as soon as the subscription
  item is mounted into your application, and that it must result in
  a function with no arguments, which is called when the item is
  removed from the application afterwards.
 
source (clj)source (cljs)raw docstring

derefclj/s

(deref ref)

Returns an implementation specific value, usable as a target in messages sending or to access the native dom elements. See with-ref for a description of references.

Returns an implementation specific value, usable as a target in
messages sending or to access the native dom
elements. See [[with-ref]] for a description of references.
sourceraw docstring

did-mountclj/s

(did-mount ret)
(did-mount item ret)

An item like the given one, or an invisible item, which emits the state change or action as specified by the given return value when mounted.

An item like the given one, or an invisible item, which emits the state
change or action as specified by the given [[return]] value when
mounted.
sourceraw docstring

embed-stateclj/s

(embed-state item lens)

Embeds the state of the given item into a part of the state of the resulting item, via the given lens.

Embeds the state of the given item into a part of the state of the
resulting item, via the given *lens*.
sourceraw docstring

emptyclj/s

An invisible item with no behavior.

An invisible item with no behavior.
sourceraw docstring

error-boundaryclj/s

(error-boundary item f)

Creates an error boundary around the given item. When the rendering of e throws an exception, then (f error) is evaluated, and must result in an return value. Note that exceptions in functions like handle-action, are not catched by this. See try-catch for a higher level construct to handle errors.

Creates an error boundary around the given item. When the rendering
of `e` throws an exception, then `(f error)` is evaluated, and must
result in an [[return]] value. Note that exceptions in functions
like [[handle-action]], are not catched by this. See [[try-catch]]
for a higher level construct to handle errors.
sourceraw docstring

first-lensclj/s

A lens over the first item of a vector.

A lens over the first item of a vector.
sourceraw docstring

focusclj/s

(focus lens item)

Returns an item that focuses the outer state, to the part of it that item shall see, via the given lens. Otherwise behaves and looks the same.

Returns an item that focuses the outer state, to the part of it
that `item` shall see, via the given *lens*. Otherwise behaves and
looks the same.
sourceraw docstring

fragmentclj/s

(fragment & children)

Returns a container item consisting of the given child items.

Returns a container item consisting of the given child items.
sourceraw docstring

handle-actionclj/s

(handle-action item f)

Handles actions emitted by given item, by evaluating (f action) for each of them. That must return the result of calling return with either a new state, and maybe one or more other actions (or the given action unchanged).

Handles actions emitted by given item, by evaluating `(f action)` for each
of them. That must return the result of calling [[return]] with
either a new state, and maybe one or more other actions (or the
given action unchanged). 
sourceraw docstring

handle-messageclj/s

(handle-message f item)

Handles the messages sent to the the resulting item (either via send-message! or return), by calling (f message), which must return a return value. The resulting item otherwise looks and behaves exactly like the given one.

Handles the messages sent to the the resulting item (either
via [[send-message!]] or [[return]]), by calling `(f message)`,
which must return a [[return]] value. The resulting item
otherwise looks and behaves exactly like the given one.
sourceraw docstring

hide-merged-stateclj/s

(hide-merged-state item initial)

Hides a part of the state of an item, which must be a map or record. The hidden part is specified by the given initial value, which can also be a map or record type. The resulting item has the same state as the given item, except that the keys in initial are removed.

Hides a part of the state of an item, which must be a map or
record. The hidden part is specified by the given initial value,
which can also be a map or record type. The resulting item has the
same state as the given item, except that the keys in `initial` are
removed.
sourceraw docstring

hide-stateclj/s

(hide-state item initial lens)

Hides a part of the state of the given item, via a lens that reduces the the tuple of states [outer inner], where the initial value for inner state is initial. The resulting item has only outer as its state.

Hides a part of the state of the given item, via a lens that
reduces the the tuple of states `[outer inner]`, where the initial
value for `inner` state is `initial`. The resulting item has only
`outer` as its state.
sourceraw docstring

id-lensclj/s

The identity lens that does not modify the yanked of shoved values.

The *identity lens* that does not modify the yanked of
shoved values.
sourceraw docstring

isolate-stateclj/s

(isolate-state initial-state item)

Hides the state of the given item completely, resulting in an item with an arbitrary state that is inaccessible for it.

Hides the state of the given item completely, resulting in an
item with an arbitrary state that is inaccessible for it.
sourceraw docstring

keyedclj/s

(keyed item key)

Adds an arbitrary identifier to the given item, which will be used to optimize rendering of it in a list of children of a container item.

Adds an arbitrary identifier to the given item, which will be used
to optimize rendering of it in a list of children of a container
item.
sourceraw docstring

map-actionsclj/s

(map-actions item f)

Returns an item that emits actions (f action), for each action emitted by item, and otherwise looks an behaves exacly the same.

Returns an item that emits actions `(f action)`, for each
`action` emitted by `item`, and otherwise looks an behaves exacly
the same.
sourceraw docstring

merge-lensclj/s

A lens over a tuple of maps or records, that yields a merged map of both. If both maps or records have fields of the same name, only the value of the second part of the tuple is used and updated on a change.

A lens over a tuple of maps or records, that yields a
merged map of both. If both maps or records have fields of the same
name, only the value of the second part of the tuple is used and updated on
a change.
sourceraw docstring

monitor-stateclj/s

(monitor-state item f & args)

When e changes its state, (f old-state new-state & args) is evaluted for side effects. Note that this is only called when the item changes its state 'by itself', not if the state was changed somewhere upwards in the item tree an is only passed down to the resulting item.

When e changes its state, `(f old-state new-state & args)` is
evaluted for side effects. Note that this is only called when the
item changes its state 'by itself', not if the state was changed
somewhere upwards in the item tree an is only passed down to the
resulting item.
sourceraw docstring

name-idclj/s

(name-id s)

Generates a fresh unique value that can be used to generate named items via named. Note that calling this twice with the same name returns different values.

Generates a fresh unique value that can be used to generate named
items via [[named]]. Note that calling this twice with the same
name returns different values.
sourceraw docstring

namedclj/s

(named name-id item)

Returns an item that looks and works exactly like the given item, but with has a user defined name, that appears and can be used in testing and debugging utilities. Use name-id to generate a unique name object. See def-named and defn-named for more convenient ways to create named items.

Returns an item that looks and works exactly like the given item,
but with has a user defined name, that appears and can be used in
testing and debugging utilities. Use [[name-id]] to generate a
unique name object. See [[def-named]] and [[defn-named]] for more
convenient ways to create named items.
sourceraw docstring

partialclj/s

source

returnclj/s

(return :state state :action action :message [target message])

Creates a value to be used for example in the function passed to handle-action. All arguments are optional:

  • :state means that the item changes its state to the given value
  • :action means that the given action is emitted by the item
  • :message means that the given message is sent to the given target reference.

If no :state option is used, the state of the item will not change. :state must occur at most once, :message and :action can be specified multiple times.

Creates a value to be used for example in the function
       passed to [[handle-action]]. All arguments are optional:

- `:state`   means that the item changes its state to the given value
- `:action`  means that the given action is emitted by the item
- `:message` means that the given message is sent to the given target reference.

If no `:state` option is used, the state of the item will not
change. `:state` must occur at most once, `:message` and `:action` can
be specified multiple times.
sourceraw docstring

second-lensclj/s

A lens over the second item of a vector.

A lens over the second item of a vector.
sourceraw docstring

send-message!clj/s

(send-message! app msg)

Sends a message to a running application, i.e. app must be the value returned from reacl-c.browser/run for example. This can be used together with handle-message in situations where the application is not running standalone, but integrated in a different framework.

Sends a message to a running application, i.e. `app` must be the
value returned from [[reacl-c.browser/run]] for example. This can be
used together with [[handle-message]] in situations where the
application is not running standalone, but integrated in a different
framework.
sourceraw docstring

set-refclj/s

(set-ref item ref)

Returns an item identical to the given item, but with the given reference assigned. Replaces the reference previously assigned to it. See with-ref for a description of references.

Returns an item identical to the given item, but with the given
reference assigned. Replaces the reference previously assigned to
it. See [[with-ref]] for a description of references.
sourceraw docstring

subscriptionclj/s

(subscription f & args)
source

try-catchclj/s

(try-catch try-item catch-item)

Returns an item that looks an works the same as the item try-item, until an error is thrown during its rendering. After that catch-item is rendered instead, with a state of the combined outer state and the error - [state-of-e error]. The catch-item will usually be interactive, for example, displaying the error (and the relevant part of the state) to the user, and offer a button to reset the error to nil and maybe fix the state, after which try-item is showed again.

Returns an item that looks an works the same as the item
`try-item`, until an error is thrown during its rendering. After
that `catch-item` is rendered instead, with a state of the combined
outer state and the error - `[state-of-e error]`. The `catch-item`
will usually be interactive, for example, displaying the error (and
the relevant part of the state) to the user, and offer a button to
reset the error to `nil` and maybe fix the state, after which
`try-item` is showed again.
sourceraw docstring

validation-boundaryclj/s

(validation-boundary item validate!)

Creates a state validation boundary around the given item, where (validate! state :up) is evaluated for side effects when a state change is flowing out of then item upwards, and (validate! state :down) is evaluated for side effects when a new state is being pushed down.

Creates a state validation boundary around the given item,
where `(validate! state :up)` is evaluated for side effects when a
state change is flowing out of then item upwards, and `(validate!
state :down)` is evaluated for side effects when a new state is
being pushed down.
sourceraw docstring

will-unmountclj/s

(will-unmount ret)
(will-unmount item ret)

An item like the given one, or an invisible item, which emits the state change or action as specified by the given return value.

An item like the given one, or an invisible item, which emits the
state change or action as specified by the given [[return]] value.
sourceraw docstring

with-refclj/s

(with-ref f & args)

Creates an item for which (f ref & args) is called when it is rendered, which should return an item, and where ref is a fresh reference. A reference should be assigned to one of the items below via set-ref. You can use it as the target of a (return :message [target msg]) for example.

Creates an item for which `(f ref & args)` is called when it is
rendered, which should return an item, and where `ref` is a fresh
*reference*. A reference should be assigned to one of the items
below via [[set-ref]]. You can use it as the target of
a `(return :message [target msg])` for example.
sourceraw docstring

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

× close