These links may be helpful:

1. [Evaluating cellular automata is comonadic][1]. In particular, &quot;whenever you see large datastructures pieced together from lots of small but similar computations there&#39;s a good chance that we&#39;re dealing with a comonad&quot;.
2. [Sequences, streams, and segments][2]
3. [Comonads in everyday life][3]


  [1]: http://blog.sigfpe.com/2006/12/evaluating-cellular-automata-is.html
  [2]: http://conal.net/blog/posts/sequences-streams-and-segments
  [3]: http://fmapfixreturn.wordpress.com/2008/07/09/comonads-in-everyday-life/

This doesn&#39;t fully answer my question, but I wanted to put some relevant information in answer format:

&quot;co&quot; (loosely) means &quot;flip the arrows&quot;. Here&#39;s a rough visual of that. 

Consider the monadic operations:

    return :: a ~&gt; m a
    flip (&gt;&gt;=) :: (a ~&gt; m b) -&gt; (m a ~&gt; m b)

Reverse the squiggly arrows and you get the comonadic operations:

    extract :: a &lt;~ w a
    extend :: (a &lt;~ w b) -&gt; (w a &lt;~ w b)

(Written with normal arrows)

    extract :: w a -&gt; a
    extend :: (w a -&gt; b) -&gt; w a -&gt; w b

Notice how in this format, `return` is an arrow that just so happens to fit in the argument slot for `flip (&gt;&gt;=)`, and the same is true of `extract` and `extend`. Monad/comonad laws say that when you put `return` or `extract` into that slot, the result is the identity arrow. The laws are the same, &quot;just with the arrows flipped&quot;. That&#39;s a super handwavey answer but hopefully it provides some insight.

I have a list of tuples that look something like this:

    (&quot;Person 1&quot;,10)
    (&quot;Person 2&quot;,8)
    (&quot;Person 3&quot;,12)
    (&quot;Person 4&quot;,20)

What I want produced, is the list sorted in ascending order, by the second value of the tuple. So L[0] should be `(&quot;Person 2&quot;, 8)` after sorting. 

How can I do this? Using Python 3.2.2 If that helps.

Sort tuples based on second parameter

[Erlang][1] was reported to have been used in production systems for over 20 years with an uptime percentage of 99.9999999%.

I did the math as the following:

    20*365.25*24*60*60*(1 - 0.999999999) == 0.631 s

That means the system only has less than one second of downtime during the period of 20 years. I am not trying to challenge the validity of this, I am just curious about how we can shut down a system (on purpose or by accident) for only 0.631 second. Could anyone who are familiar with large software system explain this to us? Thank you.

----

Does anyone know how to calculate the downtime of a service over a cluster of processing units (or machines)?


  [1]: http://www.erlang.org/

Erlang&#39;s 99.9999999% (nine nines) reliability

What is the Comonad typeclass in Haskell? As in Comonad from [Control.Comonad in the comonad package](http://hackage.haskell.org/packages/archive/comonad/1.1.1.1/doc/html/Control-Comonad.html) (explanations of any other packages that provide a Comonad typeclass are also welcome). I&#39;ve vaguely heard about Comonad, but all I really know about it is that is provides `extract :: w a -&gt; a`, sort of a parallel to Monad&#39;s `return :: a -&gt; m a`.

Bonus points for noting &quot;real life&quot; uses of Comonad in &quot;real&quot; code.

What is the Comonad typeclass in Haskell?

<p>What is the Comonad typeclass in Haskell? As in Comonad from <a href="http://hackage.haskell.org/packages/archive/comonad/1.1.1.1/doc/html/Control-Comonad.html" target="_blank" rel="noopener noreferrer">Control.Comonad in the comonad package</a> (explanations of any other packages that provide a Comonad typeclass are also welcome). I've vaguely heard about Comonad, but all I really know about it is that is provides <code>extract :: w a -> a</code>, sort of a parallel to Monad's <code>return :: a -> m a</code>.</p>
<p>Bonus points for noting "real life" uses of Comonad in "real" code.</p>


I am having problem in entering multi-line commands in ghci.

The following 2-line code works from a file:

    addTwo :: Int -&gt; Int -&gt; Int
    addTwo x y = x + y

But when I enter in ghci, I get an error:

&lt;!-- language: none --&gt;

    &lt;interactive&gt;:1:1: error:
        Variable not in scope: addTwo :: Int -&gt; Int -&gt; Int

I also tried putting the code inside `:{ ... :}`, but they are also not working for this example, because this is just appending the lines into one line, which should not be the case.

I am using WinGHCi, version 2011.2.0.1



Multi-line commands in GHCi

I&#39;ve been told you can interpret Haskell files (which I assume means they will work like Ruby/Python/Perl). I can&#39;t find the command line option on GHC to do this, though. It always wants to compile my file. Took a look at GHCi as well, but it always dumps me into a repl.

I&#39;m basically wanting to just do `ghc -i MyFile.hs` (where -i is a made up flag that I&#39;m pretending correllates to interpreted mode) and have it execute so that I can get quick feedback while I&#39;m trying out ideas and learning.


How to run a Haskell file in interpreted mode

I was playing around with functors, and I noticed something interesting:

Trivially, `id` can be instantiated at the type `(a -&gt; b) -&gt; a -&gt; b`.

With the list functor we have `fmap :: (a -&gt; b) -&gt; [a] -&gt; [b]`, which is the same as `map`.

In the case of the `((-&gt;) r)` functor (from `Control.Monad.Instances`), `fmap` is function composition, so we can instantiate `fmap fmap fmap :: (a -&gt; b) -&gt; [[a]] -&gt; [[b]]`, which is equivalent to `(map . map)`.

Interestingly, `fmap` eight times gives us `(map . map . map)`!

So we have

    0: id = id
    1: fmap = map
    3: fmap fmap fmap = (map . map)
    8: fmap fmap fmap fmap fmap fmap fmap fmap = (map . map . map)

Does this pattern continue? Why/why not? Is there a formula for how many `fmap`s I need to map a function over an _n_-times nested list?  

I tried writing a test script to search for a solution to the _n = 4_ case, but GHC starts eating too much memory at around 40 `fmap`s.

Fun with repeated fmap

In Haskell [LLVM bindings](https://github.com/bos/llvm), I am trying to define a function with a variable number of arguments (actually I mean a constant number that is not known at compile time). I found [this question](https://stackoverflow.com/questions/6448705/adding-a-function-in-llvm-haskell-bindings-when-the-number-of-parameters-is-no) and I am trying to follow the answer.

I do not want to fall back completely to using the FFI for generating LLVM, I want to use the DSL as much as I could and use FFI to only do the things I cannot do via the DSL.

I managed to define a type via functionType, I am still unable to add a function to a module created by calling &lt;code&gt;defineModule&lt;/code&gt;. I also think that the next step is to add the basic blocks to the function via &lt;code&gt;FFI.appendBasicBlock&lt;/code&gt; which I think is easy, but how do I get the arguments via &lt;code&gt;FFI.getParam&lt;/code&gt; inside of a do block in the &lt;code&gt;CodeGenFunction&lt;/code&gt; monad.

Binding FFI and DSL

I have a problem to which a stack of monad transformers (or even one monad transformer) over `IO`. Everything is good, except that using lift before every action is terribly annoying! I suspect there is really nothing to do about that, but I thought I&#39;d ask anyway.

I am aware of lifting entire blocks, but what if the code is really of mixed types? Would it not be nice if GHC threw in some syntactic sugar (for example, `&lt;-$` = `&lt;- lift`)?

Avoiding lift with monad transformers

I&#39;ve been going through the [Typeclassopedia][1] to learn the type classes.  I&#39;m stuck understanding `Alternative` (and `MonadPlus`, for that matter).

The problems I&#39;m having:

 - the &#39;pedia says that &quot;the Alternative type class is for Applicative functors which also have a monoid structure.&quot;  I don&#39;t get this -- doesn&#39;t Alternative mean something totally different from Monoid?  i.e. I understood the point of the Alternative type class as picking between two things, whereas I understood Monoids as being about combining things.  

 - why does Alternative need an `empty` method/member?  I may be wrong, but it seems to not be used at all ... at least in the [code](http://hackage.haskell.org/packages/archive/base/latest/doc/html/src/Control-Applicative.html#*%3E) I could find.  And it seems not to fit with the theme of the class -- if I have two things, and need to pick one, what do I need an &#39;empty&#39; for?

 - why does the Alternative type class need an Applicative constraint, and why does it need a kind of `* -&gt; *`?  Why not just have `&lt;|&gt; :: a -&gt; a -&gt; a`?  All of the instances could still be implemented in the same way ... I think (not sure).  What value does it provide that Monoid doesn&#39;t?

 - what&#39;s the point of the `MonadPlus` type class?  Can&#39;t I unlock all of its goodness by just using something as both a `Monad` and `Alternative`?  Why not just ditch it?  (I&#39;m sure I&#39;m wrong, but I don&#39;t have any counterexamples)

Hopefully all those questions are coherent ... !

----

Bounty update: @Antal&#39;s answer is a great start, but Q3 is still open:  what does Alternative provide that Monoid doesn&#39;t?  I find [this answer](https://stackoverflow.com/questions/10167879/distinction-between-typeclasses-monadplus-alternative-and-monoid) unsatisfactory since it lacks concrete examples, and a specific discussion of how the higher-kindedness of Alternative distinguishes it from Monoid.

If it&#39;s to combine applicative&#39;s effects with Monoid&#39;s behavior, why not just:

    liftA2 mappend

This is even more confusing for me because many Monoid instances are exactly the same as the Alternative instances.

That&#39;s why I&#39;m looking for **specific examples** that show why Alternative is necessary, and how it&#39;s different -- or means something different -- from Monoid.

  [1]: http://www.haskell.org/haskellwiki/Typeclassopedia

Confused by the meaning of the &#39;Alternative&#39; type class and its relationship to other type classes

In his talk [Simple Made Easy][1], Rick Hickey talks about &quot;**Polymorphism a la carte**&quot; (about 30:00 into the video). In the same context, he also mentions Haskell&#39;s [Type Classes][2] and Clojure&#39;s [Multi-Methods][3] (and protocols).

Since I am not very familiar with these concepts, I would like to understand its usefulness when trying to achieve **simplicity**. I am particularly interested in any examples or showcases of this concept in **Scala**. 


  [1]: http://www.infoq.com/presentations/Simple-Made-Easy
  [2]: http://en.wikipedia.org/wiki/Type_class
  [3]: http://en.wikipedia.org/wiki/Multiple_dispatch

What is &quot;polymorphism a la carte&quot; and how can I benefit from it?

What are some ways that I can accomplish what Haskell&#39;s typeclasses do in OCaml? Basically, I want to write a polymorphic function without writing too much code. The typical way to do polymorphism is to supply an additional argument telling the function is what type it is currently working on. For example, let&#39;s say I want to sort a list of ints, I have to pass an additional comparator to the function.

&lt;!-- language-all: lang-ml --&gt;

    type comparison = Lesser | Equal | Greater

    my_sort : (a&#39; -&gt; a&#39; -&gt; comparison) -&gt; &#39;a list -&gt; &#39;a list

Is there anyway to tell OCaml that my type is comparable without writing a comparator function for every type that I want to sort? Which means that my sorting function would look just like this:

    my_sort : &#39;a list -&gt; &#39;a list

What&#39;s the closest thing to Haskell&#39;s typeclasses in OCaml?

**Consider the Object-Oriented Languages:**

Most people coming from an object-oriented programming background, are familiar with the common and intuitive interfaces in various languages that capture the essence of Java&#39;s [**`Collection`**][1] &amp; [**`List`**][2] interfaces. **`Collection`** refers to a  collection of objects which doesn&#39;t necessarily have an natural ordering/indexing. A **`List`** is a collection which has a natural ordering/indexing. These interfaces abstract many library data-structures in Java, as do their equivalent interfaces in other languages, and an intimate understanding of these interfaces are required to work effectively with most library data-structures.

**Transition to Haskell:**

Haskell has a type-class system which acts on types analogously to interfaces on objects. Haskell seems to have a [well designed type-class hierarchy][3] with regard to Functors, Applicative, Monads, etc. when the type regard functionality. They obviously want [correct and well-abstracted type-classes][4]. Yet when you look at many Haskell&#39;s containers ([**`List`**][5],[**`Map`**][6],[**`Sequence`**][7],[**`Set`**][8],[**`Vector`**][9]) they almost all have very similar (or identical) functions, yet aren&#39;t abstracted through type-classes.

**Some Examples:**

 * `null` for testing &quot;emptyness&quot;
 * `length`**/**`size` for element count
 * `elem`**/**`member` for set inclusion
 * `empty` *and/or* `singleton` for default construction
 * `union` for set union
 * `(\\)`**/**`diff` for set difference
 * `(!)`**/**`(!!)` for unsafe indexing (partial function)
 * `(!?)`**/**`lookup` for safe indexing (total function)

If I want to use any of the functions above, but I have imported two or more containers I have to start hiding functions from the imported modules, or explicitly import only the necessary functions from the modules, or qualifying the imported modules. But since all the functions provide the same logical functionality, it just seems like a hassle. If the functions were defined from type-classes, and not separately in each module, the compiler&#39;s type inference mechanics could resolve this. It would also make switching underlying containers simple as long as they shared the type-classes (ie: lets just use a `Sequence` instead of `List` for better random access efficiency).

Why doesn&#39;t Haskell have a **`Collection`** and/or **`Indexable`** type-class(es) to unify &amp; generalize some of these functions?



  [1]: http://docs.oracle.com/javase/7/docs/api/java/util/Collections.html
  [2]: http://docs.oracle.com/javase/7/docs/api/java/util/List.html
  [3]: http://www.haskell.org/wikiupload/d/df/Typeclassopedia-diagram.png
  [4]: http://www.haskell.org/haskellwiki/Functor-Applicative-Monad_Proposal
  [5]: http://hackage.haskell.org/package/base-4.7.0.1/docs/Data-List.html
  [6]: http://hackage.haskell.org/package/containers-0.2.0.1/docs/Data-Map.html
  [7]: http://hackage.haskell.org/package/containers-0.5.5.1/docs/Data-Sequence.html
  [8]: http://www.haskell.org/ghc/docs/latest/html/libraries/containers-0.5.5.1/Data-Set.html
  [9]: https://hackage.haskell.org/package/vector-0.9.1/docs/Data-Vector.html

Why is Haskell missing &quot;obvious&quot; Typeclasses

Asking this question to clarify my understanding of type classes and higher kinded types, I&#39;m not looking for workarounds in Java.

---

In Haskell, I could write something like

&lt;!-- language: haskell --&gt;

    class Negatable t where
        negate :: t -&gt; t

    normalize :: (Negatable t) =&gt; t -&gt; t
    normalize x = negate (negate x)

Then assuming `Bool` has an instance of `Negatable`, 

&lt;!-- language: haskell --&gt;

    v :: Bool
    v = normalize True

And everything works fine.

---

In Java, it does not seem possible to declare a proper `Negatable` interface. We could write:

    interface Negatable {
        Negatable negate();
    }

    Negatable normalize(Negatable a) {
        a.negate().negate();
    }

But then, unlike in Haskell, the following would not compile without a cast (assume `MyBoolean` implements `Negatable`):

    MyBoolean val = normalize(new MyBoolean()); // does not compile; val is a Negatable, not a MyBoolean

**Is there a way to refer to the implementing type in a Java interface, or is this a fundamental limitation of the Java type system?** If it is a limitation, is it related to higher-kinded type support? I think not: it looks like this is another sort of limitation. If so, does it have a name?

Thanks, and please let me know if the question is unclear!

Can I define the Negatable interface in Java?

Using the typical definition of type-level naturals, I&#39;ve defined an n-dimensional grid.

    {-# LANGUAGE KindSignatures #-}
    {-# LANGUAGE DataKinds #-}
    {-# LANGUAGE GADTs #-}
    {-# LANGUAGE TypeFamilies #-}
    
    data Nat = Z | S Nat
    
    data U (n :: Nat) x where
      Point :: x -&gt; U Z x
      Dimension :: [U n x] -&gt; U n x -&gt; [U n x] -&gt; U (S n) x

    dmap :: (U n x -&gt; U m r) -&gt; U (S n) x -&gt; U (S m) r
    dmap f (Dimension ls mid rs) = Dimension (map f ls) (f mid) (map f rs)
    
    instance Functor (U n) where
      fmap f (Point x) = Point (f x)
      fmap f d@Dimension{} = dmap (fmap f) d

Now I want to make it an instance of Comonad, but I can&#39;t quite wrap my brain around it.

    class Functor w =&gt; Comonad w where
      (=&gt;&gt;)    :: w a -&gt; (w a -&gt; b) -&gt; w b
      coreturn :: w a -&gt; a
      cojoin   :: w a -&gt; w (w a)
    
      x =&gt;&gt; f = fmap f (cojoin x)
      cojoin xx = xx =&gt;&gt; id
    
    instance Comonad (U n) where
      coreturn (Point x) = x
      coreturn (Dimension _ mid _) = coreturn mid
    
      -- cojoin :: U Z x -&gt; U Z (U Z x)
      cojoin (Point x) = Point (Point x)
      -- cojoin ::U (S n) x -&gt; U (S n) (U (S n) x)
      cojoin d@Dimension{} = undefined
    
      -- =&gt;&gt; :: U Z x -&gt; (U Z x -&gt; r) -&gt; U Z r
      p@Point{} =&gt;&gt; f = Point (f p)
      -- =&gt;&gt; :: U (S n) x -&gt; (U (S n) x -&gt; r) -&gt; U (S n) r
      d@Dimension{} =&gt;&gt; f = undefined

Using `cojoin` on an n-dimensional grid will produce an n-dimensional grid of n-dimensional grids. I&#39;d like to provide an instance with the same idea as [this one](http://hpaste.org/76465), which is that the *value* of the *cojoined* grid at (x,y,z) should be the *original* grid *focused* on (x,y,z). To adapt that code, it appears that we need to reify `n` in order to perform `n` &quot;fmaps&quot; and `n` &quot;rolls&quot;. You don&#39;t have to do it that way but if that helps, then there you go.

Writing cojoin or cobind for n-dimensional grid type

This is a follow-up to the [answer][1] to my previous question.

Suppose I need to map each item `a:A` of `List[A]` to `b:B` with function `def f(a:A, leftNeighbors:List[A]): B` and generate `List[B]`.

Obviously I cannot just call `map` on the list but I can use the list _zipper_. The zipper is a cursor to move around a list. It provides access to the current element (`focus`) and its neighbors. 

Now I can replace my `f` with  `def f&#39;(z:Zipper[A]):B = f(z.focus, z.left)` and pass this new function `f&#39;` to `cobind` method of `Zipper[A]`. 

The `cobind` works like this: it calls that `f&#39;` with the zipper, then moves the zipper, calls`f&#39;` with the _new_ &quot;moved&quot; zipper, moves the zipper again and so on, and so on ... until the zipper reaches the end of the list.  

Finally, the `cobind` returns a new zipper of type `Zipper[B]`, which can be transformed to the list and so the problem is solved.

Now note the symmetry between `cobind[A](f:Zipper[A] =&gt; B):Zipper[B]` and `bind[A](f:A =&gt; List[B]):List[B]` That&#39;s why `List` is a `Monad` and `Zipper` is a `Comonad`.

Does it make sense ?

  [1]: https://stackoverflow.com/a/23984628/521070


Understanding why Zipper is a Comonad

Given any container type we can form the (element-focused) Zipper and know that this structure is a Comonad. This was recently explored in wonderful detail in [another Stack Overflow question](https://stackoverflow.com/questions/25519767/how-to-make-a-binary-tree-zipper-an-instance-of-comonad) for the following type:

    data Bin a = Branch (Bin a) a (Bin a) | Leaf a deriving Functor

with the following zipper

    data Dir = L | R
    data Step a = Step a Dir (Bin a)   deriving Functor
    data Zip  a = Zip [Step a] (Bin a) deriving Functor
    instance Comonad Zip where ...

It is the case that `Zip` is a `Comonad` though the construction of its instance is a little hairy. That said, `Zip` can be completely mechanically derived from `Tree` and (I believe) any type derived this way is automatically a `Comonad`, so I feel it ought to be the case that we can construct these types and their comonads generically and automatically.

One method for achieving generality for zipper construction is the use the following class and type family

    data Zipper t a = Zipper { diff :: D t a, here :: a }

    deriving instance Diff t =&gt; Functor (Zipper t)
 
    class (Functor t, Functor (D t)) =&gt; Diff t where
      data D t :: * -&gt; *
      inTo  :: t a -&gt; t (Zipper t a)
      outOf :: Zipper t a -&gt; t a

which has (more or less) shown up in Haskell Cafe threads and on Conal Elliott&#39;s blog. This class can be instantiated for the various core algebraic types and thus provides a general framework for talking about the derivatives of ADTs.

So, ultimately, my question is whether or not we can write

    instance Diff t =&gt; Comonad (Zipper t) where ...

which could be used to subsume the specific Comonad instance described above:

    instance Diff Bin where
      data D Bin a = DBin { context :: [Step a], descend :: Maybe (Bin a, Bin a) }
      ...

Unfortunately, I&#39;ve had no luck writing such an instance. Is the `inTo`/`outOf` signature sufficient? Is there something else needed to constrain the types? Is this instance even possible?

Content Type	Original Author	Original Content on Stackoverflow
Question	Dan Burton	View Question on Stackoverflow
Solution 1 - Haskell	Alexey Romanov	View Answer on Stackoverflow
Solution 2 - Haskell	Dan Burton	View Answer on Stackoverflow

What is the Comonad typeclass in Haskell?

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

Solution 2 - Haskell

Erlang's 99.9999999% (nine nines) reliability

Sort tuples based on second parameter

Attributions