This page is not created by, affiliated with, or supported by Slack Technologies, Inc.
- # 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)
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?
So the actual type is
k -> v -> Store i k v -> Store i k v in which
k has an
In clojure terms (I don't know haskell, trying to transcribe a paper to Clojure), would you say that
k implements the
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... 🙂
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
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
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 ^^!
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
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