--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/paste/paste.29654	Wed Oct 10 19:42:43 2012 +0000
@@ -0,0 +1,38 @@
+2012-07-06.txt:22:39:36: <zzo38> I think this can make a MonadPlus whenever w is a comonad:   newtype CodensityAsk w x = CodensityAsk { runCodensityAsk :: forall z. w z -> (x -> z) -> z };   (and that it seems to always make a monad)
+2012-07-08.txt:04:36:14: <zzo38> Do you figure out about CodensityAsk, CodensityAskT, DensityAsk, DensityAskT?
+2012-07-08.txt:04:37:08: <zzo38> (The way I have it, (CodensityAsk w) make MonadPlus if w is Comonad; hopefully it is correct although I am not completely sure)
+2012-07-08.txt:05:04:03: <zzo38> I did not post the CodensityAskT on here so now I will:  newtype CodensityAskT w m x = CodensityAskT { runCodensityAskT :: forall z. w (m z) -> (x -> m z) -> m z };
+2012-07-08.txt:05:07:42: <zzo38> You have said before that (Yoneda Endo) makes a Maybe monad, although you cannot get the instances for free. (CodensityAsk Identity) would be the same kind of things, isn't it? You will get Monad and MonadPlus instance for free.
+2012-07-08.txt:06:18:42: <zzo38> (There is also CodensityAsk which is the same except without the "m"; the reason it is separate is because w could be anything not necessarily even a endofunctor or contrafunctor)
+2012-07-08.txt:11:20:30: <zzo38> Now I made up this:  catchCodensityAskT :: (Functor w, Monad m) => w (CodensityAskT w m x) -> CodensityAskT w m x -> CodensityAskT w m x;
+2012-07-08.txt:11:35:31: <zzo38> I made up the catch for CodensityAsk; can it be made finally as well?
+2012-07-08.txt:11:55:26: <zzo38> (CodensityAsk Predicate) seems to be the exhaustively searchable set monad as in "infinite-search" package. The type can be proven the same by Yoneda and the monad seem to work same way too
+2012-07-08.txt:17:29:58: <zzo38> (CodensityAsk $ \(X q) k -> k 'a' ++ k 'b' ++ maybe [] return q) :: CodensityAsk (X [] Maybe) Char
+2012-07-09.txt:04:47:23: <zzo38> I figured out how you can make a free monad using a F-algebra:  toFree (CodensityAsk f) = f (Algebra Free) Pure; mkFree x = CodensityAsk (\(Algebra q) k -> q (fmap k x));
+2012-07-09.txt:06:04:15: <zzo38> I figured out how you can make a free monad using a F-algebra:  toFree (CodensityAsk f) = f (Algebra Free) Pure; mkFree x = CodensityAsk (\(Algebra q) k -> q (fmap k x));
+2012-07-13.txt:23:31:34: <zzo38> You get   CodensityAsk ((->) x)   to be like    Either x    including a MonadPlus instance if x is a monoid
+2012-07-15.txt:01:15:17: <zzo38> Do you like CodensityAsk (and CodensityAskT)? I have figured out many things about it.
+2012-07-15.txt:01:20:21: <zzo38> (CodensityAsk (Store s)) is also MonadPlus.
+2012-07-15.txt:09:55:17: <zzo38> type Sto s = CodensityAsk (Store s); getSto = CodensityAsk (\(StoreT _ s) r -> r s); setSto x = CodensityAsk (\(StoreT (Identity f) _) _ -> f x); modSto x = CodensityAsk (\(StoreT (Identity f) s) _ -> f (x s)); runSto s (CodensityAsk f) = f (store Left s) Right;
+2012-07-16.txt:04:52:48: <zzo38> In my program it is called (CodensityAsk (Store x))
+2012-07-16.txt:20:52:19: <zzo38> Is it correct?   Codensity Endo = []   CodensityAsk Endo = Writer (Sum Natural)   Density Endo = Traced (Product Natural)
+2012-07-16.txt:21:34:46: <zzo38> edwardk: Is it this?     CodensityAsk Endo = Writer (Sum Natural)   Density Endo = Traced (Product Natural)
+2012-07-16.txt:21:45:32: <zzo38> By F-algebras I would suppose (CodensityAsk Endo) would be same like (Free Identity)
+2012-08-14.txt:06:44:36: <zzo38> Perhaps you can even make up a kind of multi-continuation by CodensityAsk with some GADT.
+2012-08-24.txt:02:48:53: <zzo38> That   newtype Search f a = Search { optimum :: f a -> a }   I have also called Algebra (as a F-algebra is). I also think that if f is Predicate you get the "infinite search" monad that someone else described, and I think also (CodensityAsk Predicate) is also the same, too!
+2012-08-24.txt:02:54:33: <zzo38> newtype CodensityAsk f x = CodensityAsk { runCodensityAsk :: forall z. f z -> (x -> z) -> z };
+2012-08-24.txt:02:54:57: <zzo38> It is always a Monad. If f is Comonad then (CodensityAsk) is also a MonadPlus.
+2012-08-24.txt:02:55:09: <zzo38> It is always a Monad. If f is Comonad then (CodensityAsk f) is also a MonadPlus.
+2012-08-24.txt:02:55:54: <zzo38> There is also CodensityAskT which every "z" in that definition would be "m z" instead
+2012-08-24.txt:05:18:51: <zzo38> I said I proved that (CodensityAsk Predicate) is actually the same as the infinite search monad; actually, I have only proven that the type is equivalent, not that the monad is equivalent. However, it seems to be equivalent monad from testing it.
+2012-10-08.txt:17:09:40: <zzo38> I think you can make a writer monad with Codensity and it can also be done with CodensityAsk.
+2012-10-08.txt:17:18:50: <zzo38> For example:   newtype X y z = X { runX :: y -> z -> z }; type Writer x = CodensityAsk (X x); write x = CodensityAsk (\(X a) f -> a x $ f ()); runWriter (CodensityAsk f) = f (X $  (b, c) -> (a : b, c)) ((,) []);
+2012-10-10.txt:05:08:51: <shachaf> zzo38: Where did your CodensityAsk type come from?
+2012-10-10.txt:05:17:06: <shachaf> zzo38: Can you express CodensityAsk as a CodensityAsk type?
+2012-10-10.txt:05:19:05: <zzo38> shachaf: I suppose you can use (CodensityAsk (IdentityT f)) but I don't know if that is what you meant
+2012-10-10.txt:05:22:44: <shachaf> zzo38: What's CodensityAsk (Cont r)?
+2012-10-10.txt:05:24:29: <zzo38> However, notice that you don't need to use a functor there, it can be anything, such as (CodensityAsk Predicate) to make up the infinite search monad.
+2012-10-10.txt:05:25:01: <shachaf> zzo38: CodensityAsk is "pretty damn awesome", confirms another channel.
+2012-10-10.txt:06:10:56: <shachaf> @ask zzo38 Is this the CodensityAsk Monad (>>=)? m >>= f = CA $ \q k -> runCA m q (\x -> runCA (f x) q k)
+2012-10-10.txt:19:42:26: <oerjan> `pastelogs zzo38 codensityask
+2012-10-10.txt:19:42:34: <oerjan> `pastelogs zzo38.*codensityask