CODEWITHSUNDEEP
haskelloperator-overloading
Ross MacArthur
Ross MacArthur

Reputation: 5449

In Haskell how can I override the (==) and (/=) operators for a type class?

Say I have something like this

class Circle c where
    x :: c -> Float
    y :: c -> Float
    radius :: c -> Float

data Location = Location { locationX :: Float
                         , locationY :: Float
                         } deriving (Show, Eq)

data Blob = Location { blobX :: Float
                     , blobY :: Float
                     , blobRadius :: Float,
                     , blobRating :: Int
                     } deriving (Show, Eq)

instance Circle Location where
    x = locationX
    y = locationY
    radius = pure 0

instance Circle Blob where
    x = blobX
    y = blobY
    radius = blobRadius

Say for example I want Circle types to be equal if their x and y points are equal. How can I compare instances of the type class with the (==) and (/=) operators. I know I can do something like this, but is it possible to overload the operators?

equal :: Circle a => Circle b => a -> b -> Bool
equal a b = (x a == x b && y a == y b)

I want to be able to compare with

(Location 5.0 5.0) == (Blob 5.0 5.0 ... ) should give me True

Upvotes: 0

Views: 770

Answers (2)

chepner
chepner

Reputation: 531235

Two circles that share a common center aren't necessarily equal, but they are concentric; that's what you should write a function to check.

concentric :: (Circle a, Circle b) => a -> b -> Bool
concentric c1 c2 = x c1 == x c2 && y c1 == y c2

Upvotes: 2

leftaroundabout
leftaroundabout

Reputation: 120711

Zeroth, some standard imports:

import Data.Function (on)
import Control.Arrow ((&&&))

First, this is not a good idea. a==b should only be true if a and b are (for all purposes relevant to the user) interchangeable – that's clearly not the case for two circles which merely happen to share the same center point!

Second, it's probably not a good idea to make Circle a typeclass in the first place. A typeclass only makes sense when you want to abstract over something that can't directly be expressed with just a parameter. But if you just want to attach different “payloads” to points in space, a more sensible approach might be to define something like

data Located a = Located {x,y :: ℝ, payload :: a}

If, as seems to be the case, you actually want to allow different instances of Circle to coexist and be comparable at runtime, then a typeclass is entirely the wrong choice. That would be an OO class. Haskell doesn't have any built-in notion of those, but you could just use

data Blob = Blob
   { x,y :: ℝ
   , radius :: ℝ
   , rating :: Maybe Int }

and no other types.

https://lukepalmer.wordpress.com/2010/01/24/haskell-antipattern-existential-typeclass/

Third, the instance that you asked for can, theoretically speaking, be defined as

instance (Circle a) => Eq a where
  (==) = (==)`on`(x &&& y)

But this would be a truely horrible idea. It would be a catch-all instance: whenever you compare anything, the compiler would check “is it of the form a?” (literally anything is of that form) “oh great, then said instance tells me how to compare this.” Only later would it look at the Circle requirement.

The correct solution is to not define any such Eq instance at all. Your types already have Eq instances individually, that should generally be the right thing to use – no need to express it through the Circle class at all, just give any function which needs to do such comparisons the constraint (Circle a, Eq a) => ....

Of course, these instances would then not just compare the location but the entire data, which, as I said, is a good thing. If you actually want to compare only part of the structure, well, make that explicit! Use not == itself, but extract the relevant parts and compare those. A useful helper for this could be

location :: Circle a => a -> Location
location c = Location (x c) (y c)

...then you can, for any Circle type, simply write (==)`on`location instead of (==), to disregard any other information except the location. Or write out (==)`on`(x &&& y) directly, which can easily be tweaked to other situations.

Upvotes: 9

Related Questions