*New version, 0.4.0 released:*
http://fluokitten.uncomplicate.org/ has lots of documentation and
tutorials. Source at: https://github.com/uncomplicate/fluokitten
New features:
- Added PseudoFunctor, PseudoApplicative, and PseudoMonad, to support
destructive operations in Neanderthal.
That's a good answer! I've enjoyed reading the documentation of both
fluokitten and morph and understood it. The functionality certainly
seems useful.
Phil
Dragan Djuric draga...@gmail.com writes:
If Clojure has all of the Haskell's type features, I guess there would be
only one Clojure
Hi Ben and everyone who participated in the discussion. Most of the issues
we have been discussed (most notably mdo and agnostic return) have been
implemented in the newly released version 0.3.0. No macrology was necessary
for agnostic return :)
Please try the new version and post your
Thanks for the tip, Michael. I added a notification on every page, for the
TL;DR crowd, so I hope that will catch the attention of enough people and
improve the future readability of the docs.
On Wednesday, July 3, 2013 2:34:33 PM UTC+2, Michael Klishin wrote:
2013/7/3 Dragan Djuric
On Wednesday, July 3, 2013 2:06:34 AM UTC+2, Ben wrote:
On Tue, Jul 2, 2013 at 4:33 PM, Dragan Djuric drag...@gmail.comjavascript:
wrote:
And in this case you have to explicitly specify which monad you want to
use, every time you call bind. I understand that in some case it might be a
The specific bind implementations always get the instance of the Monad
protocol the bind was called with (since it is a part of an implementation
of the Monad protocol), so you use that instance as a first argument to
pure.
Of course, if you call bind with a function that does not make sense
This looks fantastic.
I probably won't be able to resist to type check it with core.typed at some
point.
And enough documentation to satisfy Michael Klishin? I'm impressed :)
Thanks,
Ambrose
On Wed, Jul 3, 2013 at 2:07 AM, Dragan Djuric draga...@gmail.com wrote:
I am pleased to announce a
I probably won't be able to resist to type check it with core.typed at
some point.
If you contribute that, or help me baking in (some) non-invasive type
checking into Fluokitten, that would be FANTASTIC! I have that in vague
long-term plans, but I haven't had time to look at core.typed
On Wed, Jul 3, 2013 at 7:50 PM, Dragan Djuric draga...@gmail.com wrote:
I probably won't be able to resist to type check it with core.typed at
some point.
If you contribute that, or help me baking in (some) non-invasive type
checking into Fluokitten, that would be FANTASTIC! I have that in
2013/7/3 Dragan Djuric draga...@gmail.com
one of the main project goals is to make monads (et al) approachable for
beginners, and for that, docs and tutorials are the main thing. So, this
library really does not make much sense without lots of documentation. I
hope to even improve it on that
Michael,
The site source is in the gh-pages branch in the main source repository on
github: https://github.com/uncomplicate/fluokitten/tree/gh-pages
On Wednesday, July 3, 2013 2:19:07 PM UTC+2, Michael Klishin wrote:
2013/7/3 Dragan Djuric drag...@gmail.com javascript:
one of the main
2013/7/3 Dragan Djuric draga...@gmail.com
The site source is in the gh-pages branch in the main source repository on
github: https://github.com/uncomplicate/fluokitten/tree/gh-pages
It's worth mentioning somewhere. ClojureWerkz projects link to doc source
at the top of every guide,
adding a
On Wed, Jul 3, 2013 at 12:32 AM, Dragan Djuric draga...@gmail.com wrote:
On Wednesday, July 3, 2013 2:06:34 AM UTC+2, Ben wrote:
On Tue, Jul 2, 2013 at 4:33 PM, Dragan Djuric drag...@gmail.com wrote:
And in this case you have to explicitly specify which monad you want to
use, every time
On Wed, Jul 3, 2013 at 7:07 AM, Ben Wolfson wolf...@gmail.com wrote:
However, I think this, regarding the second law, is telling: The second
does not too, since it says what happens when you bind with (pure m) not
(pure n)
*all* the laws only say what happen when you stay within the same
Monads as a Haskell construct is what the previously mentioned laws
describe. Monads in category theory are defined in a category X as a triple
(T, n, m) where T is a functor and m and n certan natural transformations
such that certan diagrams commute. In that sense, I am not sure that even
I've never really used monads or monoids, but one thing that does
confuse me is how come there are so may libraries for supporting them.
I've been reading the documentation of morph
(https://github.com/blancas/morph) recently, which is the first one I've
understood. A quick look at fluokitten
If Clojure has all of the Haskell's type features, I guess there would be
only one Clojure monad library, more or less a direct port of Haskell's. As
Clojure is different, there are different ways to approach monads from
neither of which can be the same as Haskell's, each having its pros and
Hi,
Am Mittwoch, 3. Juli 2013 16:49:43 UTC+2 schrieb Dragan Djuric:
Monads as a Haskell construct is what the previously mentioned laws
describe. Monads in category theory are defined in a category X as a triple
(T, n, m) where T is a functor and m and n certan natural transformations
Yes, I agree completely, when we stay inside Haskell. However, Clojure is
dynamic. Here are two objects that are equal despite having different types:
Consider this case:
(= [1] (list 1))
;= true
(isa? (type [1]) (list 1))
;= false
In fact, equality in Java (and Clojure) depends on the
On Wed, Jul 3, 2013 at 10:31 AM, Dragan Djuric draga...@gmail.com wrote:
Yes, I agree completely, when we stay inside Haskell. However, Clojure is
dynamic. Here are two objects that are equal despite having different types:
If you're going to talk about category theory concepts, then that's
If you're going to talk about category theory concepts, then that's the
constraint you have to operate under. monad is constituted by the laws,
the laws involve operations with a certain type, and that's just it. It's
not a matter of being in Haskell or not, it's a matter of accurately
On Wed, Jul 3, 2013 at 7:49 AM, Dragan Djuric draga...@gmail.com wrote:
Monads as a Haskell construct is what the previously mentioned laws
describe. Monads in category theory are defined in a category X as a triple
(T, n, m) where T is a functor and m and n certan natural transformations
I am pleased to announce a first public release of new (and different)
monads and friends library for Clojure.
Extensive *documentation* is at http://fluokitten.uncomplicate.org
Fluokitten is a Clojure library that implements category theory concepts,
such as functors, applicative functors,
2013/7/2 Dragan Djuric draga...@gmail.com
I am pleased to announce a first public release of new (and different)
monads and friends library for Clojure.
Extensive *documentation* is at http://fluokitten.uncomplicate.org
Good job, Dragan!
--
MK
http://github.com/michaelklishin
I haven't played around with this but it looks as if the second argument to
bind needs to know what kind of monad it's operating in, is that right?
Would it be possible to write agnostic functions like this in this lib?
monads.core (defn tst-reader [f]
(mdo env - ask
No, the second argument to bind only needs to be a function that takes a
plain value and return a monadic value; you do not need to specify anything
explicitly and it does not need to know what kind of monad it is operating
on. Whatever that function returns will be a monad that the eventual
I did look at the docs and I don't really get how to return a monadic value
in the right monad, the way return does automatically. All the examples I
saw have something like vector or atom or what-have-you.
On Tue, Jul 2, 2013 at 2:41 PM, Dragan Djuric draga...@gmail.com wrote:
No, the second
e.g., I'm not sure how to define the function f here:
$ ghci
GHCi, version 7.4.1: http://www.haskell.org/ghc/ :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Prelude let f :: (Monad m) = (a -
pure function, defined in applicative, is equivalent to return (In Haskell,
in Fluokitten there is only pure).
I think I understand what is your question now. Since Clojure does not
support polymorphysm based on the returning argument you cannot translate
that Haskell code exactly. For such a
I wanted to say THE pure function. Now I realize that pure function is
ambiguous :)
On Wednesday, July 3, 2013 1:03:26 AM UTC+2, Dragan Djuric wrote:
pure function, defined in applicative, is equivalent to return (In
Haskell, in Fluokitten there is only pure).
I think I understand what is
IMO you *always* want the monad to stay the same---the laws describing
monadic computations don't account for swapping the things out midstream,
at any rate. And it pays to be able to define monadic computations without
having to explicitly pass around a token to serve as the current monad.
FWIW,
And in this case you have to explicitly specify which monad you want to
use, every time you call bind. I understand that in some case it might be a
preferred way, but in my opinion for most cases that I care about I prefer
it the other way.
Regarding monadic laws, which one exactly demands
On Tue, Jul 2, 2013 at 4:33 PM, Dragan Djuric draga...@gmail.com wrote:
And in this case you have to explicitly specify which monad you want to
use, every time you call bind. I understand that in some case it might be a
preferred way, but in my opinion for most cases that I care about I prefer
On Tue, Jul 2, 2013 at 5:06 PM, Ben Wolfson wolf...@gmail.com wrote:
On Tue, Jul 2, 2013 at 4:33 PM, Dragan Djuric draga...@gmail.com wrote:
Regarding monadic laws, which one exactly demands that you cannot change
the monad (not counting the fact that haskell's implementation does it that
34 matches
Mail list logo
