Should wireState define an interface for updating signals through callbacks?

[ArseAssassin]

Pros:

• wires no longer bound to render lifecycle
• creates self-contained units of state
• cleans up render code
• analogous to passing callbacks from a parent

Cons:

• more complicated (?)
• props more difficult to use

Both:

• reliant on callbacks for manipulating DOM-bound values
• no ability to manipulate time in render function

[ArseAssassin]

Can be implemented in user-space:

    persistentWires: (fn) => (props) => {
        let wires = []

        props.isAlive.filter(r.equals(false)).take(1).onValue(() => {
            wires.forEach((it) => it.end())
        })

        let wire = (arg) => {
            if (typeof arg === 'string') {
                return props.slot(arg).emit
            } else if (arg.emit) {
                return arg.emit
            } else if (arg.call) {
                let emitter = kefir.emitter()
                wires.push(emitter)
                arg(emitter)

                return (value) => {
                    emitter.emit(value)
                }
            }
        }

        return { wires: kefir.constant(fn(r.merge(props, { wire }))) }
    },