Two mutually exclusive things I want:
* Everything is a live stream of filtering/reducing functions over Lisplike tokens (because reactive and symbolic and literate)
* Everything is also an object (because safe)
You'd think that a function could *be* an object. You just keep 'sending' it (applying it to) a sequence of values, those are the messages.
But how does it receive the 'end stream' message? What value is that?
A similar problem to
.apply-filter [ .* 2 ] [ 1 2 3 ]
Yep. That's where I want to get to, using as few core abstractions as possible. On the possibly foolhardy assumption that 1) you can get to global simplicity by using a smaller set of core abstractions, and 2) that simplicity makes things better. Either of which assumptions may be wrong.
ie we currently have OOP systems which don't even surface their stream of method calls *as* a user-code-facing object, which seems about as helpful as trying to build an Internet with all the packets being completely hidden from software inspection.
Which is probably one reason why 'microservices' have become such a thing. Because maybe by abstracting out 'message sending' to a protocol, you can build in the parts of message sending that didn't make it into C++.
Server run by the main developers of the project It is not focused on any particular niche interest - everyone is welcome as long as you follow our code of conduct!