Monads and Gonads

also, this indirectly reminded me of what I thought to be one of DC's greatest talks: Monads and Gonads ( [VIDEO] )

The one thing that made monads clearer for me was this thing [VIDEO] Monads and Gonads It's probably condescending for haskellers because it shows that monads are not some enshrined primary concept but just a kind of dumb wrapper you can write in any language and you do when it's useful for you.

I'm unfamiliar with Clojure, but I rather liked Douglas Crockfords comment on code coloring (Lisp) based on scope rather than syntax. [VIDEO]

...that's how chaining method calls end up working in most OO languages (take the Scala example in OP's article). And also in Javascript (I can't remember if there is something like `range` in js right now...): [1,2,3,4,5,6,7,8,9,10] .map(function (x) { return x + 2 }) .reduce(function (a, b) { return a + b }) so the "." in OOP ends up working like "->" or "->>". Heck, you can make the dot in OOP code behave like anything, even like monadic bind (`>>=` or `do` notation in Haskell), if you do OOP-style-monads in JS: [VIDEO] (off-topic: this is also my main problem with OOP... the "." can actually end up meaning anything practically, as program logic is concerned, it's like some kind of "infinite operator overloading" :) )

> Do I need to know Haskell? Yes. This is enough for me to reject this blogpost. No you don't need a specific language to implement any functionality that can be implemented by a turing-complete language. I watched Crockford's monad talk [1]. He used javascript. The only problem with that talk is that he spent about 10 seconds or less explaining what a monad is (and the rest of the talk on implementation issues and his own perspective, etc, etc). I'm still waiting for a good monad discussion without CT or Haskell. (this [2] and this [3] look promising, both in python) [1] [VIDEO] [2] [LINK] [3] [LINK]

>The biggest real problem I’ve found with large “where” clauses is that they tend to have a lot of implicit dependencies on variables from the enclosing scope. For me it's always a toss up. I like to make things local where possible to give some indication that the definitions need not be looked over with a fine-toothed comb -- they aren't used extensively. On the other hand, it does often lead to implicit dependencies. It would be nice to have scope highlighting - color every identifier based on the distance from the scope it's defined in. This idea shamelessly stolen from Doug Crockford in [VIDEO]

Javascript promises are a kind of monad. Douglas Crockford talks about this in his talk "Monads and Gonads" [1] [1] [VIDEO]

combobulate (alpha quality as of 10/22): source code outline/cliff notes. from github README.rst "Emacs package that provides a standardized framework for manipulating and navigating your source code using tree sitter's concrete syntax tree " -> [LINK] [LINK] with [LINK] then write a iterator/loop query for language(s) editing per [LINK] tad less installation heavy (sorta) but also makes use of tree-sitter syntax queries : [LINK] (neovim with treesitter syntax) blockman usage examples: [LINK] Alternative examples / takes (per user interface): ### embedding a block of source code in a document: ** carrotsearch.gethub.io/apidocs/code-blocks ** [LINK] ### 'colorize blocking' (vs space endenting) : ** example code reference coloring: [VIDEO] ### gui block programming : ** [LINK] ** [LINK]