This page is not created by, affiliated with, or supported by Slack Technologies, Inc.

## 2019-04-21

## Channels

- # announcements (8)
- # beginners (22)
- # calva (42)
- # cider (2)
- # clj-kondo (1)
- # cljdoc (3)
- # clojure (63)
- # clojure-chicago (1)
- # clojure-uk (29)
- # clojurescript (16)
- # clojureverse-ops (2)
- # core-matrix (6)
- # cursive (1)
- # datomic (23)
- # emacs (1)
- # heroku (2)
- # luminus (1)
- # off-topic (47)
- # pathom (1)
- # planck (3)
- # re-frame (4)
- # reitit (1)
- # rewrite-clj (5)
- # shadow-cljs (47)

https://www.youtube.com/watch?v=lKXe3HUG2l4 One of my fav. talks…

`putValue:: Eq k=> k -> v ->Store i k v->Store i k v`

I'm trying to understand this type signature, and the `Eq k =>`

is tripping me up a bit, can someone explain it to me?

That says that `k`

in the type signature is something you can compare

So the actual type is `k -> v -> Store i k v -> Store i k v`

in which `k`

has an `Eq`

instance

In clojure terms (I don't know haskell, trying to transcribe a paper to Clojure), would you say that `k`

implements the `Eq`

protocol?

I was going to link the docs, but they don’t seem to be that helpful

Googling about "haskell context" isn't too useful, ended up on a dead haskell wiki page

Is there a haskell-alike (So, I guess something with monads and hindley-milner types?) that I might find somewhat practical? Haskell may be that, but I'm just curious to know if there's something else that's worth checking out? Frege maybe?

I hadn't thought of OCaml, derivatives of their work is going into native desktop apps right?

Just looking at Eta -- prompted by your question. It looks like it manages to dovetail the Haskell ecosystem (Cabal etc) into the JVM ecosystem in quite a nice way. Maybe next time I go back to "learn Haskell properly", I'll try Eta... 🙂

Wasn’t there a new tool in town: stack?

The background for this question is that I'm trying to understand https://dl.acm.org/citation.cfm?id=3236774 and the dependencies/Applicative stuff makes no sense to me to how it works.

The paper is available in presentation here: https://www.youtube.com/watch?v=BQVT6wiwCxM

haven’t watched, but may be helpful?

(Also, SPJ is a functional programmer hero)

Although, after watching it, its quite heavily dependent on knowledge of Haskell.

I've seen it, although a while ago, the authors published loads of complimentary material too

Cool! Papers can be hard to get through, so I am glad that there is also a recorded presentation. I have seen that there is a difference in expressiveness depending on whether your data structure is ‘just’ Functor or ‘also’ Applicative or ‘also’ Monad, but I must admit that its just a slight intuition but no … full understanding.

After trying very hard to grok applicative, I've understood that it's more static than a monad, so it can be analysed

The authors combine applicative with getConst to statically find dependencies, but I couldn't figure out what getConst actually does independently, the name would imply that it's like (constantly), but it clearly isn't based on results.

It's quite tempting to design a model which matches the semantics as I understand them and cover it up with macros.

(I am trying to help as much as I can) the applicative instance of `Const`

appears to be closer to appending to some accumulator.

That's what I thought, but I couldn't figure out how that resulted in evaluation being interrupted, or where that was documented.

I suspect I need to spend some serious time understanding the category theory completely.

This fun-written book helped me a lot: http://learnyouahaskell.com/functors-applicative-functors-and-monoids

It’s like Clojure for the Brave and True but for Haskell

I skimmed the first few chapters, but didn't see that one. I saw one with boxes that was good. I'll give that a read now thanks!

Maybe I should go over that whole book in more detail. Seems good enough too. New study project :)

I was just rambling to a coworker how we all can learn a lot from other programming languages ^^!

*even* languages as abstract as Haskell ;)

I found this: https://blog.jle.im/entry/const-applicative-and-monoids.html (assuming you were asking me?)

But I have been looking at this stuff on and off for years, I still don’t grasp it entirely.

I think I even vaguely understand how getConst works, even though the name is absolutely terrible

yeah…

naming is not Haskells strong suite, whoever figured that “wrapping in a monadic context” should be called `return`

… So many imperative programmers were confused that day