Comments on: The Cofree Comonad and the Expression Problem

By: Madison Foley

Madison Foley — Wed, 11 Jan 2012 20:38:43 +0000

Thank you pretty a lot for posting all the excellent info! Hunting forward to seeintg additional!

By: dumpster rental lorain oh

dumpster rental lorain oh — Thu, 05 Jan 2012 07:03:33 +0000

Nice article. I master some thing extra challenging on unique weblogs everyday. It’ll usually be stimulating to read through subject matter from other writers and practice a bit anything from their store. I’d opt for to use some while using the subject matter on my blog site whether you never mind. Natually I’ll give you a hyperlink in your net blog site. Many thanks for sharing.

By: fetisch spiele

fetisch spiele — Wed, 22 Jun 2011 17:04:40 +0000

Its like you learn my mind! You seem to know so much about this, like you wrote the guide in it or something. I think that you just could do with some p.c. to power the message house a little bit, however instead of that, this is fantastic blog. An excellent read. I will certainly be back.

By: The Comonad.Reader » Zapping Adjunctions

The Comonad.Reader » Zapping Adjunctions — Thu, 05 Jun 2008 19:29:20 +0000

[...] In an earlier post about the cofree comonad and the expression problem, I used a typeclass defining a form of duality that enables you to let two functors annihilate each other, letting one select the path whenever the other offered up multiple options. To have a shared set of conventions with the material in Zipping and Unzipping Functors, I have since remodeled that class slightly: [...]

By: The Comonad.Reader » Zipping and Unzipping Functors

The Comonad.Reader » Zipping and Unzipping Functors — Mon, 05 May 2008 03:01:27 +0000

[...] Here we set aside the restriction that we only be able to Zip a comonad, and simply require that if the functor in question is a comonad, then it is a “symmetric semi-monoidal comonad”, which is to say that zipping and then extracting yields the same result as extracting from each separately. You may note a lot of similarity in the above to the definition for Control.Functor.Zap the Dual functor from the other day. [...]

By: Dave Menendez

Dave Menendez — Sat, 03 May 2008 07:01:15 +0000

Here’s the URI: http://okmij.org/ftp/Haskell/generics.html#PolyVariant

By: Dave Menendez

Dave Menendez — Sat, 03 May 2008 07:00:39 +0000

It’s only two years old, but Oleg describes how to handle polymorphic variants using a record of functions in . He doesn’t have the neat Dual class, though.

By: Edward Kmett

Edward Kmett — Thu, 01 May 2008 15:36:33 +0000

Here is a quick take on the Incr/Recall example.

[Edit: typechecked, added to source code, and a couple typos corrected]

data Incr t = Incr Int t
data Recall t = Recall (Int -> t)

instance Functor Incr where
fmap f (Incr i t) = Incr i (f t)

instance Functor Recall where
fmap f (Recall g) = Recall (f . g)

(/+/) :: (Functor f, Functor g) => (f a -> a) -> (g a -> a) -> ((f :+: g) a -> a)
(f /+/ g) (Inl a) = f a
(f /+/ g) (Inr b) = g b

newtype Mem = Mem Int
type RunAlg f a = f (Mem -> (a,Mem)) -> Mem -> (a,Mem)

incrRun :: RunAlg Incr a
incrRun (Incr k r) (Mem i) = r (Mem (i + k))

recallRun :: RunAlg Recall a
recallRun (Recall r) (Mem i) = r i (Mem i)

run :: Functor f => RunAlg f a -> Free f a -> Mem -> (a, Mem)
run = cataFree (,)

runMyExpr :: Free (Incr :+: Recall) a -> Mem -> (a, Mem)
runMyExpr = run (incrRun /+/ recallRun)

By: Grant B

Grant B — Thu, 01 May 2008 09:45:13 +0000

I’m interested in your variant approach to the expression problem, but I have a hard time comparing yours to Swierstra’s. I tried working on the translation exercise you suggested but that led me nowhere. Could you please present at least one worked example taken from the original paper?