Futures/Promises thoughts

[rockymadden]

I apologize in advance that this is not an actual issue, but more of a conversation if you are willing to entertain/have the bandwidth. I am curious about your thoughts on how one might approach adding Future (https://github.com/fluture-js/Fluture), Promise, and/or async/await support to the core language. To the novice lisper/ramdascripter, it seems like a few items might be addressed/thought through first:

• Upgrade Ramda to >= 0.24.0 where they introduced better support for Fantasy Land
• As a nice-to-have (requirement?), the ability to add other iteratee-first, data-last, curried functions libraries written in the spirit of Ramda to the core language (e.g. https://github.com/fluture-js/Fluture, https://github.com/char0n/ramda-adjunct, https://github.com/sanctuary-js/sanctuary)

If going the Future route and you added Fluture functions to the core ramdascript language, like fork (https://github.com/fluture-js/Fluture#fork), you could then do it fairly easily in ramdascript right? Something akin to:

pipe(
  map(futureProducingFunction),
  parallel(1),
  fork(console.error, console.log)
)([
  'https://example.com/api0',
  'https://example.com/api1',
  'https://example.com/api2'
]);

[yosbelms]

@rockymadden The issue in this case should be to find a straightforward way to deal with method chaining.
Example: obj.method1().method2().method3()

[yosbelms]

The most common pattern to achieve methods chain in Ramda is to combine pipe and invoker
Example in RamdaScript:

(pipe
    (invoker 1 'map' futureProducingFunction)
    (invoker 1 'parallel' 1)
    (invoker 2 'fork' console.error console.log))

http://ramdajs.com/docs/#invoker

[yosbelms]

I think there is a lot of things to discuss in this thread if you are still interested.

The main idea behind RamdaScript is to use Ramda as a Lisp. So, to add another libraries to the core would mean move away from its le motif. You may notice that RamdaScript has some functions which are not part of Ramda, example: import, alter... Those are to provide interop with JS.

The translation from RamdaScript to JS is plain and straightforward because Ramda is very powerful. So, the hard work of the compiler is the semantic checker and the compilation of functions aiming JS interop to take advantage of the JavaScript ecosystem of which Sanctuary and Fluture are first class citizens.

That said, we may conclude that it is possible to take advantage of Sanctuary and/or Fluture libraries in RamdaScript, example:

(import 'sanctuary' [Just])

(console.log (Just 42))