CSP vs FRP

[danprince]

Implement either CSP or FRP as a first class citizen. FRP is going to be simpler at a language level, but stack/stream could provide a bit clashy. Alternatively CSP could be implemented with some new syntax, but then the interpreter would need to be implemented using continuations from day one, which will result in slower generated code.

[danprince]

CSP

import (chan take put) from "async"

chan -- put a new channel onto the stack
take -- block until a value becomes available then put onto the stack

2 put -- example of putting values into the channel

Pros

• Can keep the regular stack model clean, blocking the currently executing context until values are available in the channel.

Cons

• Code must be compiled to continuations or state machines.
• Not possible to export a value/reference, meaning a channel couldn't be shared between files without some hacky string namespaces/weird stack balancing

FRP

import (-> subscribe) from "reactive"
import (map fold) from "frp"
import (by-id) from "dom"

"inc" by-id "click" -> -- creates an event stream of clicks
(1) map -- returns a new event stream with mapped values
(+) fold -- fold accumulated values with +
(print) subscribe -- print out running total

Pros

• Works nicely with concatenative design: "inc" by-id "click" -> (1) map (+) fold (print) subscribe.
• Can be compiled into JS neatly.

Cons

• How is stack scope meant to work? Event streams running asynchronously shouldn't have access to the main stack.

[danprince]

Idea: implement FRP with "reactive" stacks.

import (rstack) from "reactive"

("change" print) -- stack subscription function
rstack -- converts the current stack to a reactive one

"inc" by-id "click" -> -- put the click event onto the reactive stack and print "change"

-- re-implementation of last example
( drop 1 + dup print ) rstack
"inc" by-id "click" ->

Bit messy. End up with a sort of global function that has to deal with all stack reactions.

import (rstack) from "reactive"
import (dispatch) from "flux"

(
  :type get
  (:inc 1 :dec -1) match
  + dup print
) rstack

"inc" by-id "click" (:type "inc") dispatch
"dec" by-id "click" (:type "dec) dispatch

Similar mess, but potentially could compose the "reacting" function out of smaller dedicated event handlers.