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 { ... }