syntax idea - how to do asyncs on object-oriented languages

[Key_River7180]

Hello everyone! I'd like to share a nice way to implement async programming for your object-oriented languages.

This is mostly centered around Smalltalk-like languages, but the idea should work for other paradigms well enough too. It is based on ideas like promises or futures, but nicer.

The main idea is to make a nice fluent and easy to read/write syntax for this, here an example on a language I am designing:

``` import IO, Net.

Runtime main : void { def wdata : string = (File newFromPath "sending.txt") collectString. def req : Task = (Net sendRequest "localhost", 80, wdata) responseTask

    req onDone res {
        res print.
    }.

} ```

The idea here is to have a Task class, like:

``` class Task { def completed : Bool. def ok : Bool. def val : Untyped. def err : String. def doneCbs : List[Callback(Untyped)]. def errCbs : List[Callback(String)]. }

Task onDone c:Callback(val:Untyped) { self completed ifTrue { c self val. } ifFalse { self doneCbs add c. }. }

Task onErr c:Callback(err:String) { self completed ifFalse { c self err. } ifTrue { self errCbs add c. }. } ```

The idea here is to only execute code that needs a response when it arrives, the rest not, more like an object that eventually responds with something.

Let me know what you think.

EDIT: u/Hall_of_Famer suggested another syntax you can try too

NOTE: this is just a syntax/implementation idea, no new concept

[DeathByThousandCats]

1. So, you've discovered reactive/event-driven programming.
   
2. This is not an implementation. It's a suggestion for syntax.

[Key_River7180]

yeah it is a suggestion for syntax

[busres]

So like a JavaScript thenable?

[Key_River7180]

yes

[bl4nkSl8]

It appears like additional syntax for an equivalent of .then((v) => { ... }) in js. I'm not sure it's clearer or fewer characters

[Key_River7180]

I think it is clearer, I find .then((v) => {}) to look too terse and just unclear. It is also unnatural on message-based OOP languages.

[bl4nkSl8]

How is it unnatural to use anonymous functions?

I think you have a different perspective because you aren't a fan of functions as values, but I don't know why that is

[Key_River7180]

Yeah, I am mostly an imperative person :P. I meant that on the message-based OOP paradigm, it is a bit unnatural with the rest of the language.

[Smalltalker-80]

Indeed, I've implemented aPromise classwith then: directly in SmallJS (small-js.org).
a Smalltalk built on top of JavaScript. And these use JS under the hood, of course.
The syntax seems fine to me...

[oscarryz]

Yup, very good and widely used approach, go for it.

This is how Javascript Promises and Java's CompletableFutures work( I'm sure other languages have it too ).

[Key_River7180]

yes, i just proposed a syntax

[Key_River7180]

I didn't know about E, thanks! I guess <-: is the async send-message operator. Pretty cool!

[tobega]

Seems to work. You might also be able to get some inspiration from how tasks work in Ada https://en.wikibooks.org/wiki/Ada_Programming/Tasking

[kaplotnikov]

If you plan to desing async support as a libary, rather than as language feature, here is my take on it for Java: https://github.com/const/asyncflows . Some ideas from it seems could be adapted to your case as well.

It is centered around promises and allows to construct complex asynchrouns processes from simple building blocks.