Functional Modeling Examples

This is example code as suggested on FunctionalModeling. Code collected by ShaeErisson

module Truck where

-- http://c2.com/cgi-bin/wiki?FunctionalModeling

-- 1. truck and tire as types
-- we alias Pressure to Integer here, following the OnceAndOnlyOnce principle
type Pressure = Integer

-- tire as unification type
data Tires = Michelin Pressure | Pirelli Pressure

checkPressure                     :: Tires -> Pressure
checkPressure (Michelin pressure) = pressure
checkPressure (Pirelli pressure)  = pressure

{-
interactively:
*Truck> let x = Pirelli 5
*Truck> checkPressure x
5
-},

-- 2. tire as typeclass
-- a typeclass describes an operation
-- any type can provide an implementation of this operation
class Tire a where
    getPressure   :: a -> Pressure

-- some random type
data MyFoo = Foo Pressure deriving (Show, Eq)

instance Tire MyFoo where
    getPressure (Foo a) = a

{-
interactively:
*Truck> let y = Foo 5
*Truck> getPressure y
5
-},

-- 3. unified type with records
-- from HalDaume III
-- a record is ... well.. like a database record sort of...
data Tires' = Michelin' { checkPressure' :: Pressure }, | Pirelli' { checkPressure' :: Pressure },


-- 4. alternate tire typeclasses
-- from EsaPulkkinen
class Tire' a where 
    createTire' :: Pressure -> a
    getPressure' :: a -> Pressure

-- Esa: This will cause some problems for the user 
-- Esa: he has to choose a representation
-- Esa: that is, getPressure (createTire x) does not work.

-- another idea is to use a factory to build tires
class Tire'' a where 
    getPressure'' :: a -> Pressure

class TireFactory'' f where 
    createTire :: Tire'' a => f a -> Pressure -> a

data MyTireFactory a = MyTireFactory { myTireFromPressure :: Pressure -> a },
data MyTire = MyTire { myTirePressure :: Pressure },

myTireFactory :: MyTireFactory MyTire
myTireFactory = MyTireFactory (\p -> MyTire p)

instance TireFactory'' MyTireFactory where
    createTire (MyTireFactory f) p = f p

instance Tire'' MyTire where
    getPressure = myTirePressure

-- Esa: you could embed Pressure in the factory as well
-- Esa: so that constructing factory will be the place where the pressure is required.

-- Esa: you could have a design where a car encloses all tire and pressure handling
class Car c t where 
    getTires    :: c -> [t]
    getPressure :: c -> t -> Pressure 

class Car' c where 
    getTires    :: c t -> [t]
    getPressure :: c t -> t -> Pressure

-- Esa: but that has a problem that it does not properly describe 
-- Esa: the connection between a tire and a car 
-- Esa: [or you have to handle error cases 
-- Esa: where you ask a pressure from a tire 
-- Esa: that is not in the same car that you specified]

-- Esa: Another alternative is to represent this using a mapping from cars to tires:
class CarTireMapping m where
    getTires :: m c t -> c -> [t]
    getPressure :: m c t -> t -> Pressure

-- Truck class using functional dependencies
-- from AndrewBromage (under construction)
-- class Truck truck tyre | truck -> tyre where { ... },