A reference i found about "reactive programming"
https://github.com/dsyer/reactive-notes/blob/master/intro.adocHope this introduced the concept correctly, thanks for pointing that.
Following are only some thoughts,
Two things surprising here,
1/ a programmer prefers not to solve a problem
2/ one failed attempt mean the end of all attempts**
That being said, my little understanding so far is that current context is used for two purposes,
- cancellation
- data (transmission? not sure) (+/- ts, have not checked i expect so in regards to previous referenceS cited)
While cancellation is a feature i really want to take advantage of,
the other one is much more arguable in the sense that
it can remains expressed purely by the end user without bloating
his productivity and quality (you don t really need it everywhere, just where it is needed),
it seems to be highly software context dependent.
Whereas cancellation, while it looks likes simple, is maybe more subtle.
After all it is about assigning uuid to a chain of call and
appropriately propagate, disjoint/rejoin new uuids with the previous one,
so that we can ask to stop execution of a sub selection of a chain of calls
via an handle.
Am i too simplistic?
Its difficulty reside in its requirement to be passed absolutely everywhere,
That reveals an important fact about the nature of cancellation,
it is there, it is everywhere, at all time (...within the program lifetime),
it is somewhere in the background of every ops since the very beginning the program began,
but not necessarily enabled, and certainly not a straight line.
That is where the syntax might help to establish the plots
that the runtime consumes to connect the dots
and support what the developers want to achieve,
in my understanding so far.
My best comparison to cancellation is
request rays tracing in micro services oriented architecture,
on both end it is a multi-tenant,
it always start with one ray,
the ray always split into multiple rays,
because we do programming, we need ways
to create, control distribute existing/new rays,
and possibly let the userland introduce a new behavior for the rays.
So yeah basically main has a ray,
if you process an http request,
you to create a new ray
to be able to cancel only that request,
but it needs to be connected to the main ray
because if main should be canceled,
that signals should propagate to all rays connected with it,
probably.
** i want to put emphasis because in the description provided
by Sameer, as i tried to summarize, It has been tried to handle
the problem via the type system as if it was
a completely defined set of types.
Which in go is wrong (yeah i m very affirmative here :),
from my understanding, that might be correct in other oop languages.
Technically it is possible to rewrite interfaces, methods signatures, taken individually,
as a whole, and from the consumer pov,
i d say it is an impossible task in go because it it goes against its nature.
And i confirm/understand that by reading to Sameer feedback.
Notes: i m a strong lover of go type system (not talking about values and pointers ;)