for their underlying communication, including Akka. Reactive Streams are also to become builtin to Java, as the Flow class, in version 9.
Would it be wise if Swift 5 also builtin Reactive Stream protocols and built its Actor implementation etc. on top of this protocol?
In MHO, yes, it would be great to build a reactive stream abstraction as well. I agree with you that this is an effectively “obvious” part of the eventual model, and that we will almost certainly end up building it. It would also make sense to have foreach over an async sequence be itself implicitly async. I haven’t sketched that out, but it seems like a few straight-forward steps beyond what is in the manifesto doc.
I think this is what you mean by parallel forEach, I have just expanded the
wording below to be clearer (for myself primarily).
The Java equivalent of a `LazySequenceProtocol` has a parallel method that
returns a parallel lazy sequence, so that operations like map, reduce,
filter, and forEach all run in parallel. I have used this a lot to speed up
code and it would be another great addition.
for their underlying communication, including Akka. Reactive Streams are
also to become builtin to Java, as the Flow class, in version 9.
Would it be wise if Swift 5 also builtin Reactive Stream protocols and
built its Actor implementation etc. on top of this protocol?
In MHO, yes, it would be great to build a reactive stream abstraction as
well. I agree with you that this is an effectively “obvious” part of the
eventual model, and that we will almost certainly end up building it. It
would also make sense to have foreach over an async sequence be itself
implicitly async. I haven’t sketched that out, but it seems like a few
straight-forward steps beyond what is in the manifesto doc.
In general, I would prefer an async story like this:
- support coroutines / generators (yield)
- use coroutines to implement Future and Stream/Observable
- optionally provide async/await as syntax sugar for Future/Stream (or just reuse yield)
1. Atomic - with `get`, `set`, and `update` methods
2. Future - with `get`, `cancel`, and `status` methods
3. Reactive Streams - with protocols `Processor`, `Producer`,
`Subscriber`, and `Subscription`, with implementations of `ForEachProducer`
and `ReduceSubscriber`, and with operator `~>` for subscriptions
For those not familiar, Reactive Streams are a standardised form of a type
of actor that have become popular and are available in multiple languages.
Here is Hello World in the Reactive Stream library:
let helloWorldPublisher = ForEachPublisher(sequence: "Hello,
world!".characters)
let helloWorldSubscriber = ReduceSubscriber(into: "") { (result: inout
String, next: Character) in
result.append(next) // Copy the string a character at a time.
}
helloWorldPublisher ~> helloWorldSubscriber // Subscribe
let helloWorldResult = helloWorldSubscriber.get ?? "Failed!" // Wait
for result and check for error
Note how the arguments to `ForEachProducer` and `ReduceSubscriber` mimic
those to similarly named methods in Swifts `Sequence` protocol, how `~>` is
evocative of the process that is occurring, and how future's `get` controls
execution and error reporting.
If anyone experiments with them and provide feedback :), it would be
greatly appreciated.
In general, I would prefer an async story like this:
- support coroutines / generators (yield)
- use coroutines to implement Future and Stream/Observable
- optionally provide async/await as syntax sugar for Future/Stream (or
just reuse yield)