The following message is in a Haskell module. It will be easier to read
in a fixed point font.
{-# OPTIONS -fglasgow-exts #-}
-- Hi,
--
-- I ran into an issue while working with functional dependencies.
-- Consider the following code. I'm rewriting many of the prelude
-- operators using functional dependencies. The type of he return value
-- is determined by the operators parameters.
-- Use "P." in front of functions to access the preludes version of these
-- functions.
import qualified Prelude as P
-- I override prelude operators with my own operators.
import Prelude hiding ( (*), recip )
import Ratio
-- recip returns the reciprocal of its parameter. I've given the
-- Reciprocate class the ability to return a type that is different from
-- its argument.
class Reciprocate a b | a -> b where
recip :: a -> b
-- Here are some example instances of Reciprocate. In most cases,
-- recip will return the same type as it's argument. However, taking
-- the reciprocal of an Integer returns a (Ratio Integer).
instance Reciprocate Double Double where
recip = P.recip -- I call prelude's recip here.
instance Reciprocate (Ratio Integer) (Ratio Integer) where
recip = P.recip -- I call prelude's recip here.
instance Reciprocate Integer (Ratio Integer) where
recip x = (1::Integer) % x
-- (*) multiplies its parameters. The resulting type is determined by
-- the type of the arguments
class Multiply a b c | a b -> c where
(*) :: a -> b -> c
-- Here are some example instances of Multiply.
instance Multiply Double Double Double where
(*) = (P.*)
-- Multiplying Integer by Double returns a Double
instance Multiply Integer Double Double where
(*) x y = (P.*) (fromIntegral x) y
instance Multiply Double Integer Double where
(*) x y = (P.*) x (fromIntegral y)
instance Multiply Integer (Ratio Integer) (Ratio Integer) where
(*) x y = (P.*) (x%1) y
-- Now, this is where I ran into some trouble I define a Divide class
-- as follows. Here I define a default (/) operator that uses the
-- Reciprocate and Multiply class to perform division. However, this code
-- produces error messages. So, I commented it out. Even if I don't want
-- to implement (/) with recip and (*), requiring this relationship --
-- |
-- ----------------------------------------------
-- |
-- v is consistent with
defining
-- _____________________________________ the divide operation in
-- | | terms of the
multiplicative
-- | | inverse
{-
class (Reciprocate b recip, Multiply a recip c) => Divide a b c | a b -> c
where
(/) :: a -> b -> c
(/) x y = x * (recip y)
-}
-- This definition of (/) works. However, taking the reciprocal and then
-- multiplying may not always be the best way of dividing. So, I'd like
to
-- put this into a divide class, so (/) can be defined differently for
-- different types.
{-
(/) :: (Reciprocate b recip, Multiply a recip c) => a -> b -> c
(/) a b = a * (recip b)
-}
-- I finally discovered that the following definition of a Divide
-- class works
class (Reciprocate b recip_of_b, Multiply a recip_of_b c)
=> Divide a b c recip_of_b | a b -> c recip_of_b where
(/) :: a -> b -> c
(/) a b = a * (recip b) -- Default definition can be overridden
-- The thing I don't like is that when defining a new Divide class, I have
-- to place the reciprocal of the "b" type into the class definition.
-- Here are some examples of Divide:
--
-- This type ----------------------------
-- must be the type that is |
-- returned when this |
-- type ------------------ |
-- is passed to recip. | |
-- | |
-- v v
instance Divide Double Double Double Double where
(/) x y = (P./) x y -- For Doubles
-- Another example:
--
-- This type ------------------------------------------
-- must be the type that is |
-- returned when this |
-- type ------------------- |
-- is passed to recip. | |
-- | |
-- v v
instance Divide Integer Integer (Ratio Integer) (Ratio Integer) where
(/) x y = x % y
-- The reason I don't like it is there is enough information available to
infer
-- the type of recip_of_b in the following class. The Reciprocate class
is
-- defined with functional dependencies, so that recip_of_b can be
determined
-- by the type of b.--
-- |
-- ______________________
-- | |
--
-- class (Reciprocate b recip_of_b, Multiply a recip_of_b c)
-- => Divide a b c recip_of_b | a b -> c recip_of_b
where
-- (/) :: a -> b -> c
-- (/) a b = a * (recip b)
--
-- Respecifying the recip_of_b when I declare an instance of Divide
-- seem redundant. I'm wondering if there is a better way to
-- define this. I also, wonder if it would be appropriate to include
-- in future versions of Haskell, the ability to infer functional
-- dependences in a new class definition, so that my first attempt
-- at a definition of class Divide works.
