Good examples of Not a Functor/Functor/Applicative/Monad?

by

A type constructor which is not a Functor:

newtype T a = T (a -> Int)

You can make a contravariant functor out of it, but not a (covariant) functor. Try writing fmap and you’ll fail. Note that the contravariant functor version is reversed:

fmap      :: Functor f       => (a -> b) -> f a -> f b
contramap :: Contravariant f => (a -> b) -> f b -> f a

A type constructor which is a functor, but not Applicative:

I don’t have a good example. There is Const, but ideally I’d like a concrete non-Monoid and I can’t think of any. All types are basically numeric, enumerations, products, sums, or functions when you get down to it. You can see below pigworker and I disagreeing about whether Data.Void is a Monoid;

instance Monoid Data.Void where
    mempty = undefined
    mappend _ _ = undefined
    mconcat _ = undefined

Since _|_ is a legal value in Haskell, and in fact the only legal value of Data.Void, this meets the Monoid rules. I am unsure what unsafeCoerce has to do with it, because your program is no longer guaranteed not to violate Haskell semantics as soon as you use any unsafe function.

See the Haskell Wiki for an article on bottom (link) or unsafe functions (link).

I wonder if it is possible to create such a type constructor using a richer type system, such as Agda or Haskell with various extensions.

A type constructor which is an Applicative, but not a Monad:

newtype T a = T {multidimensional array of a}

You can make an Applicative out of it, with something like:

mkarray [(+10), (+100), id] <*> mkarray [1, 2]
  == mkarray [[11, 101, 1], [12, 102, 2]]

But if you make it a monad, you could get a dimension mismatch. I suspect that examples like this are rare in practice.

A type constructor which is a Monad:

[]

About Arrows:

Asking where an Arrow lies on this hierarchy is like asking what kind of shape “red” is. Note the kind mismatch:

Functor :: * -> *
Applicative :: * -> *
Monad :: * -> *

but,

Arrow :: * -> * -> *

More Related Contents:

  1. Applicatives compose, monads don’t
  2. Difference between Monad and Applicative in Haskell
  3. How to interpret bind/>>= of the function instance?
  4. Why should Applicative be a superclass of Monad?
  5. How to handle side effect with Applicative?
  6. How to return a pure value from a impure method
  7. What is a monad?
  8. Monads with Join() instead of Bind()
  9. A monad is just a monoid in the category of endofunctors, what’s the problem?
  10. Is monad bind (>>=) operator closer to function composition (chaining) or function application?
  11. How do functors work in haskell?
  12. How to extract value from monadic action
  13. Large-scale design in Haskell? [closed]
  14. Distinction between typeclasses MonadPlus, Alternative, and Monoid?
  15. What is the purpose of the reader monad?
  16. Is Haskell truly pure (is any language that deals with input and output outside the system)?
  17. Euler 43 – is there a monad to help write this list comprehension?
  18. Haskell: I/O and Returning From a Function
  19. Why does haskell’s bind function take a function from non-monadic to monadic
  20. What is a monad?
  21. Is there a way to place some impure code inside pure functions?
  22. What are free monads?
  23. Why are side-effects modeled as monads in Haskell?
  24. Is there a monad that doesn’t have a corresponding monad transformer (except IO)?
  25. Monoidal Functor is Applicative but where is the Monoid typeclass in the definition of Applicative?
  26. How does the ST monad work?
  27. An example of a Foldable which is not a Functor (or not Traversable)?
  28. In what sense is the IO Monad pure?
  29. How Monads are considered pure?
  30. Is Haskell’s mapM not lazy?

Leave a Comment