[swift-evolution] [Concurrency] Reactive streams as building blocks for actors etc.

[Howard Lovatt]

I have put on Github three concurrency libraries (
https://github.com/hlovatt/Concurrency-Utilities):

  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.

Thanks,

 -- Howard.

  -- Howard.

On 3 September 2017 at 17:36, Georgios Moschovitis <
george.moschovitis at icloud.com> wrote:

> That would be definitely a great addition to the language. IMO, Dart gets
> this right:
>
> https://www.dartlang.org/tutorials/language/futures
> https://www.dartlang.org/tutorials/language/streams
>
> 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)
>
> -g.
>
> On 29 Aug 2017, at 4:56 AM, Howard Lovatt via swift-evolution <
> swift-evolution at swift.org> wrote:
>
> Many of the currently popular server side frameworks are switching to
> Reactive Streams:
>
>     http://en.wikipedia.org/wiki/Reactive_Streams#Adoption
>
> 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?
>
>   -- Howard.
>
> More info on Reactive streams:
>
>     https://github.com/reactive-streams/reactive-streams-jvm/
> blob/v1.0.1/README.md#specification
>
>     http://bryangilbert.com/post/code/scala/akka-reactive-streams/
>
>
> _______________________________________________
> swift-evolution mailing list
> swift-evolution at swift.org
> https://lists.swift.org/mailman/listinfo/swift-evolution
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20170906/ea004a13/attachment.html>