Explicitly import instances

by

The inability to control imports of instances is one of the trade-offs the Haskell typeclass system makes. Here’s an example in a hypothetical Haskell dialect where you can:

Foo.hs:

module Foo where

data Foo = FooA | FooB deriving (Eq, Ord)

Bar.hs:

module Bar (myMap) where

import Data.Map (Map)
import qualified Data.Map as Map

import Foo

myMap :: Map Foo Int
myMap = Map.singleton FooA 42

Baz.hs:

module Baz where

import Data.Map (Map)
import qualified Data.Map as Map

import Foo hiding (instance Ord Foo)
import Bar (myMap)

instance Ord Foo where
  FooA > FooB = True
  FooB > FooA = False

ouch :: Map Foo Int
ouch = Map.insert FooB 42 myMap

Yikes! The set myMap was created with the proper instance Ord Foo, but it’s being combined with a map created with a different, contradictory instance.

Being able to do this would violate Haskell’s open world assumption. Unfortunately, I don’t know of a good, centralised resource for learning about it. This section of RWH might be helpful (I searched for “haskell open world assumption”).

More Related Contents:

  1. Confused by the meaning of the ‘Alternative’ type class and its relationship to other type classes
  2. Haskell types frustrating a simple ‘average’ function
  3. What’s the “|” for in a Haskell class definition?
  4. Typeclass constraints on data declarations
  5. Type Constraints in Data Declaration Haskell
  6. How does deriving work in Haskell?
  7. What is the Comonad typeclass in Haskell?
  8. ‘some’ and ‘many’ functions from the ‘Alternative’ type class [duplicate]
  9. Return specific type within Haskell
  10. Haskell \p -> not takeWhile
  11. Sum of two numbers with function in haskell
  12. How to group similar items in a list using Haskell?
  13. How do I deal with many levels of indentation?
  14. Memoization in Haskell?
  15. Wrong IO actions order using putStr and getLine
  16. Lifting a higher order function in Haskell
  17. Distinction between typeclasses MonadPlus, Alternative, and Monoid?
  18. How do I write, “if typeclass a, then a is also an instance of b by this definition.”
  19. Function definition by special cases in GHCi
  20. Why do we need monads?
  21. Lambda for type expressions in Haskell?
  22. Pattern matching identical values
  23. Composing Monads v. Applicative Functors
  24. Abusing the algebra of algebraic data types – why does this work?
  25. What does the : infix operator do in Haskell?
  26. Monoidal Functor is Applicative but where is the Monoid typeclass in the definition of Applicative?
  27. How to return a pure value from a impure method
  28. How to convert Unicode Escape Sequence to Unicode String in Haskell
  29. Why does OCaml sometimes require eta expansion?
  30. Explanation of “tying the knot”

Leave a Comment