baret Util ·

A collection of experimental utilities for working with baret.

Contents

• Reference

Reference

This library provides a large number of named exports. Typically one just imports the library as:

import * as U from "baret.util"

Misc

≡ U.seq(value, ...fns) ~> value

U.seq allows one to pipe a value through a sequence of functions. In other words, U.seq(x, fn_1, ..., fn_N) is roughly equivalent to fn_N( ... fn_1(x) ... ). It serves a similar purpose as the ->> macro of Clojure or the |> operator of F# and Elm, for example, or the >| operator defined in a Usenet post by some rando.

For example:

U.seq(1, x => x + 1, x => -x)
// -2

A common technique in JavaScript is to use method chaining: x.fn_1().fn_2(). A problem with method chaining is that it requires having objects with methods. Sometimes you may need to manipulate values that are not objects, like null and undefined, and other times you may want to use functions that are not directly provided as methods and it may not be desirable to monkey patch such methods.

U.seq is designed to work with partially applied curried functions that take the object as their last argument and can be seen as providing a flexible alternative to method chaining.

≡ U.seqPartial(maybeValue, ...fns) ~> maybeValue

U.seqPartial allows one to pipe a value through a sequence of function in such a way that if the value becomes undefined the process is stopped and undefined is returned without calling the remaining functions.

≡ U.scope(() => value) ~> value

U.scope simply calls the given thunk. IOW, U.scope(fn) is equivalent to (fn)(). You can use it to create a new scope at expression level.

For example:

U.scope((x = 1, y = 2) => x + y)
// 3

≡ U.toPartial((...values) => value) ~> (...maybeValues) => maybeValue

U.toPartial takes the given function and returns a curried version of the function that immediately returns undefined if any of the arguments passed is undefined and otherwise calls the given function with arguments.

For example:

U.toPartial((x, y) => x + y)(1, undefined)
// undefined

U.toPartial((x, y) => x + y)(1, 2)
// 3

≡ U.show(value) ~> value

U.show logs the given value to console and returns the value.

≡ U.refTo(settable)(value or null) ~> undefined

U.refTo is designed for getting a reference to the DOM element of a component:

const Component = ({dom = U.variable()}) =>
  <div ref={U.refTo(dom)}>
    ...
  </div>

React calls the ref callback with the DOM element on mount and with null on unmount. However, U.refTo does not write null to the variable. The upside of skipping null and using an initially empty variable rather than an atom is that once the variable emits a value, you can be sure that it refers to a DOM element.

≡ U.cns(...maybeClassName)

≡ U.getProps({prop: settable, ...})

≡ U.setProps({prop: observable, ...})

≡ U.bindProps({ref: eventName, prop: settable, ...})

≡ U.bind({prop: settable, ...})

≡ K

≡ U.template(template of observables)

≡ U.string

≡ U.lift

≡ U.ift(condition, consequent)

≡ U.ifte(condition, consequent, alternative)

≡ U.iftes(condition, consequent, ...[, alternative])

≡ U.actions(...maybeFns)

≡ U.mapCached(x => ..., array)

≡ U.mapIndexed((x, i) => ..., array)

≡ U.indices(array)

≡ U.mapElems((elem, i) => ..., array)

≡ U.mapElemsWithIds(elem => id, (elem, id) => ..., array)

Atom

≡ U.atom(value)

≡ U.variable()

≡ U.molecule(template)

≡ U.holding(() => ...)

≡ U.view(lens, value)

≡ U.set(settable, value)

Bus

≡ U.bus()

U.bus() creates a new observable Bus stream. A Bus stream has the following methods:

• bus.push(value) to explicitly emit value value,
• bus.error(value) to explicitly emit error error, and
• bus.end() to explicitly end the stream after which all the methods do nothing.

baret

TODO: Kefir refereces still here

≡ U.fromKefir()

Context

≡ U.Context

≡ U.withContext

≡ U.WithContext

Kefir

Kefir operations in curried form.

≡ U.changes(observable) ~> observable

≡ U.debounce(milliseconds, observable) ~> observable

≡ U.delay(milliseconds, observable) ~> observable

≡ U.endWith(value, observable) ~> observable

≡ U.mapValue(currentValue => newValue, observable) ~> observable

≡ U.flatMapErrors(error => observable, observable) ~> observable

≡ U.flatMapLatest(value => observable, observable) ~> observable

≡ U.flatMapParallel(value => observable, observable) ~> observable

≡ U.flatMapSerial(value => observable, observable) ~> observable

≡ U.foldPast

≡ U.fromEvents(object, name) ~> observable

≡ U.interval

≡ U.later

≡ U.lazy(() => observable) ~> property

≡ U.never ~> observable

≡ U.on

≡ U.parallel([...observables]) ~> observable

≡ U.sampledBy

≡ U.serially([...observables]) ~> observable

≡ U.sink(observable) ~> observable

≡ U.skipDuplicates(observable) ~> observable

≡ U.skipFirst(count, observable) ~> observable

≡ U.skipUnless(elem => boolean, observable) ~> observable

≡ U.skipWhen(elem => boolean, observable) ~> observable

≡ U.startWith(constant, observable) ~> observable

≡ U.takeFirst(count, observable) ~> observable

≡ U.takeUntilBy

≡ U.throttle(milliseconds, observable) ~> observable

≡ U.toProperty(observable) ~> observable

Ramda

Ramda functions lifted to take Bacon observables.

Math