14:05 <isd> I'll probably want to try this out on a smaller one-off project before I think about using it in Sandstorm proper, but this was fun to build and I'm happy with how it came out: https://github.com/zenhack/incremental.js

15:48 <abliss> does the library really transform (x + y) * z into (x * y) + z? :P

15:50 <simpson> Fun. I implemented Adapton for similar purposes: https://github.com/monte-language/typhon/blob/master/mast/fun/adapton.mt

16:04 <isd> abliss: derp, good catch.

16:04 <isd> The README is the sloppiest part of the repo right now; I need to go back over and document properly.

16:06 <isd> There's some really key stuff that's needs to be stated that isn't.

16:06 <isd> Like .then(). and the way observers work

16:14 <isd> simpson: happen to know if/how the design of adapton differs from what incremental does?

16:18 <simpson> isd: Offhand no, but they're all based on very similar ideas.

16:23 <simpson> isd: Looking at your examples, I think that the biggest difference between your particular presentation and mine is that yours is monadic.

16:24 <simpson> I've got cells, sort of like in a spreadsheet, inspired by "Lamport slots", which are just slots which change value according to a Lamport clock.

16:25 <simpson> So rather than returning to the monad in order to do computations, users pull from the slots directly as if they held plain values. Behind the scenes, the slots send messages to each other to incrementally update.

16:25 <isd> yeah, incremental is less explicit about the graph abstraction; the idea is you can mentally erase the .map() and .bind() calls and get back the non-incremental computation trivially

16:26 <simpson> Yeah. It's a "handle" monad, like ResourceT or ST in Haskell. And these can be really useful; microKanren is usually embedded via this sort of monad.

16:27 <isd> well, .then() in javascript rather than .bind()

16:27 <simpson> The downside is that the logic variables need to be opaque, and the user can't get at what's actually passed around. Twisted Deferreds have this problem too.

16:30 <isd> simpson: composability. Usually when people talk about callback hell, what they're getting at is fairly-ad-hoc use of callback arguments. Where as with monads you can without too much trouble mentally erase the .then() calls and get back to "normal" code

16:30 <isd> relatedly, I wish javascript's async/await was generalized to arbitrary monads

16:32 <simpson> http://minikanren.org/ is the landing page, http://webyrd.net/scheme-2013/papers/HemannMuKanren2013.pdf is the paper to read. It's a really fun weekend project.

16:34 <isd> Aha, yeah monads seem like a natural fit for embedding something like that.

16:35 <simpson> isd: As the slogan goes, "promises form a monad", right? https://github.com/bravoserver/bravo/blob/master/bravo/world.py#L93-L95 shows a halfway-to-E sort of style with Deferreds.

16:36 <simpson> In modern Monte, we'd write m`def chunk := self.requestChunk(bigx, bigz); when (chunk) -> { f(self, chunk, ...) }`

16:36 <isd> Sadly Python makes monadic style code super awkward, due to the no-statements-in-a-lambda restriction.

16:37 <simpson> Yeah. E goes the other way and doesn't have statements.

16:38 <isd> +1