Haskell type classes, data, and newtype.

type Metres = Int declares a type synonym: a second name for Int. It makes no new type. To GHC, Metres and Seconds below are both Int, so either one fits wherever the other is expected.

That is the trap. pace takes the time first and the distance second. The application pace 5000 1500 has them the other way round, and GHC accepts it. The program runs and gives a wrong number, 3333 instead of 300.

A type synonym is still useful. It tells a reader what a number means, and it shortens a long type, such as type Board = [(String, Int)]. It never stops a mix-up.

A type synonym is another name for the same type; two synonyms of Int mix freely.

newtype Metres = Metres Int declares a separate type, Metres, with one data constructor, also called Metres, that wraps one Int. The type and the constructor may share a name. The type appears in signatures, and the constructor in expressions and patterns. Metres 5000 builds a value. The pattern (Metres distance) takes the value apart and names the Int inside.

Now Metres, Seconds, and Int are three different types. With the arguments swapped, GHC reports Couldn’t match expected type ‘Seconds’ with actual type ‘Metres’, and the same error the other way round for the second argument.

A newtype costs nothing when the program runs: GHC gives it the same representation as the Int inside, so wrapping and unwrapping do no work. In exchange, a newtype has exactly one constructor with exactly one field. For anything else, use data: several fields, as in data Run = Run Metres Seconds, or several constructors, as in Alternatives and combinations.

A newtype is a separate type with one constructor and one field; GHC rejects a swap, and the wrapper costs nothing at run time.

A new type, from newtype or data, starts with no instances: no show, no ==, no <. Equality and comparison derived Eq. deriving (Show, Eq, Ord) asks GHC to write three instances at once.

A derived show writes the value as Haskell code: Finished 1620, or Runner {name = "Ivy", time = 1620} for a record. A derived == compares the constructor and every field.

A derived compare first compares the constructors, in the order the data declaration lists them: a constructor listed earlier is smaller. Only when both values have the same constructor does it compare the fields, from left to right. Below, Finished is listed before Retired, so every Finished value is smaller than Retired. minimum gives the smallest element of a list, so it finds the fastest finisher and never a runner who retired.

A derived Ord compares constructors in the order they are declared, then fields from left to right.

When the derived meaning is wrong for your type, write the instance yourself, as Interfaces, traits, and type classes did for a class of its own. A Show instance defines show. Below, s `mod` 60 is the remainder of s divided by 60, so show (Seconds 1490) gives 24 min 50 s instead of Seconds 1490.

An Ord instance defines compare, which returns LT, EQ, or GT. The class builds <, >, max, min, and the others from it. Below, runners are compared by time, and by name when the times are equal. compare (a, x) (b, y) compares two pairs: the first parts, and the second parts only when the first are equal. Comparing the names too keeps Ord in agreement with the derived ==: compare gives EQ only for two equal runners.

A constraint in a signature asks for an instance. best :: Ord a => [a] -> a, defined as best times = minimum times, can be applied to a [Runner], because Runner has an Ord instance. For a newtype with no Ord instance, GHC reports No instance for (Ord Seconds) arising from a use of ‘best’.

Write an instance when the derived meaning is wrong; an Ord instance defines compare and must agree with ==.

A newtype gets nothing from the type it wraps. Metres holds an Int, but Metres has none of Int’s instances. deriving (Show, Eq, Ord) adds those three. Num, the class of +, *, and number literals, cannot be derived in Haskell 2010. deriving Num reports Can’t make a derived instance of ‘Num Metres’: ‘Num’ is not a stock derivable class (Eq, Show, etc.). Without an instance, sum [Metres 400, Metres 800] reports No instance for (Num Metres) arising from a use of ‘sum’.

You can write a Num instance yourself, but Num asks for more than adding. * must also give Metres, so 400 metres times 400 metres is Metres 160000, which is not a distance. fromInteger turns every number literal into Metres, so lap + 5 compiles, and nothing says what the 5 measures. For a unit, write only the functions it needs, such as addMetres below, and keep Num away.

A newtype starts with no instances; derive the ones that make sense, and think before you give a unit Num.

Four mistakes with types and instances are common in real Haskell code.

Units that mix through a type synonym. type UserId = Int and type OrderId = Int let a function receive an order id where it expects a user id, and the lookup quietly finds the wrong user. Make each a newtype; it costs nothing at run time.

A derived Ord that sorts by the wrong field. sort, from Data.List, puts a list in order with compare. A record declared with the name first sorts by name, whatever the field you meant. The experiment below shows a results list in name order. Put the field that should decide first, or write compare yourself.

An orphan instance. A module that writes instance Show Colour, where Colour comes from a library and Show from the Prelude, declares an orphan instance. When another module does the same, a module that imports both and shows a Colour stops compiling with Overlapping instances for Show Colour. Wrap the library type in a newtype and give the newtype the instance. GHC’s -Worphans option, part of -Wall, warns about orphans.

show used for saving, and read for loading. read turns text back into a value, and read (show x) gives x back while both instances are derived. A hand-written Show for display, such as 24 min 50 s, breaks loading:

Give each unit a newtype, check which field a derived Ord compares first, declare an instance next to its type or class, and keep show for saving apart from display.

Decide what each derived instance compares, and what the derived show writes.