Difference between revisions of "Peano numbers"
(example implementations) |
(applications) |
||
Line 1: | Line 1: | ||
'''Peano numbers''' are a simple way of representing the natural numbers using only a zero value and a successor function. In Haskell it is easy to create a type of Peano number values, but they are more often used to do [[type arithmetic]]. |
'''Peano numbers''' are a simple way of representing the natural numbers using only a zero value and a successor function. In Haskell it is easy to create a type of Peano number values, but they are more often used to do [[type arithmetic]]. |
||
− | == |
+ | == Overview == |
+ | |||
+ | === Peano number values === |
||
data Peano = Zero | Succ Peano |
data Peano = Zero | Succ Peano |
||
Line 14: | Line 16: | ||
See an [http://darcs.haskell.org/htam/src/Number/PeanoNumber.hs example implementation]. |
See an [http://darcs.haskell.org/htam/src/Number/PeanoNumber.hs example implementation]. |
||
− | == Peano number types == |
+ | === Peano number types === |
data Zero |
data Zero |
||
Line 35: | Line 37: | ||
See [[type arithmetic]] for other functions and encodings. |
See [[type arithmetic]] for other functions and encodings. |
||
+ | |||
+ | == Applications == |
||
+ | |||
+ | === Lazy counting === |
||
+ | |||
+ | The lazy nature of Peano numbers rehabilitates the use of list functions which count list elements. |
||
+ | As described in [[Things to avoid#Don.27t_ask_for_the_length_of_a_list_when_you_don.27t_need_it|Things to avoid]] |
||
+ | one should not write |
||
+ | <haskell> |
||
+ | length xs == 0 |
||
+ | </haskell> |
||
+ | because <hask>length</hask> constructs all list nodes, |
||
+ | although after you have seen only one, it is obvious that the list is not empty. |
||
+ | The above expression can be simply replaced by <hask>null</hask>, |
||
+ | but with Peano numbers you achieve the same |
||
+ | <haskell> |
||
+ | genericLength xs == Zero |
||
+ | -- or |
||
+ | genericLength xs == (0::Peano) |
||
+ | </haskell> |
||
+ | |||
+ | The expression |
||
+ | <haskell> |
||
+ | length xs == length ys |
||
+ | </haskell> |
||
+ | is harder to make lazy without Peano numbers. |
||
+ | With them (and an appropriate <hask>Num</hask> instance) this becomes rather simple, because |
||
+ | <haskell> |
||
+ | genericLength xs == (genericLength ys :: Peano) |
||
+ | </haskell> |
||
+ | constructs only as much list nodes, as the shorter list has. |
||
+ | |||
+ | |||
+ | === Equation solving === |
||
+ | |||
+ | Lazy Peano numbers can also be used within "[[Tying the Knot]]" techniques. |
||
+ | There is a [http://darcs.haskell.org/unique-logic/haskell98/src/UniqueLogic/Lazy/Peano.hs package] for determining the right order for solving equations, |
||
+ | where an equation is only solved if only one of its variables is still indeterminate. |
||
+ | |||
== See also == |
== See also == |
Revision as of 12:06, 3 July 2007
Peano numbers are a simple way of representing the natural numbers using only a zero value and a successor function. In Haskell it is easy to create a type of Peano number values, but they are more often used to do type arithmetic.
Overview
Peano number values
data Peano = Zero | Succ Peano
Here Zero and Succ are values (constructors). Zero has type Peano, and Succ has type Peano -> Peano. The natural number zero is represented by Zero, one by Succ Zero, two by Succ (Succ Zero) and so forth.
Here's a simple addition function:
add Zero b = b add (Succ a) b = Succ (add a b)
See an example implementation.
Peano number types
data Zero
data Succ a
Here Zero and Succ are types. Zero has kind *, and Succ has kind * -> *. The natural numbers are represented by types (of kind *) Zero, Succ Zero, Succ (Succ Zero) etc.
Arithmetic can be done using fundeps:
class Add a b ab | a b -> ab instance Add Zero b b instance (Add a b ab) => Add (Succ a) b (Succ ab)
Note that classes express relationships between types, rather than functions from type to type. Accordingly, with the instance declarations above one can add another fundep to the class declaration to get subtraction for free:
class Add a b ab | a b -> ab, a ab -> b instance Add Zero b b instance (Add a b ab) => Add (Succ a) b (Succ ab)
See type arithmetic for other functions and encodings.
Applications
Lazy counting
The lazy nature of Peano numbers rehabilitates the use of list functions which count list elements. As described in Things to avoid one should not write
length xs == 0
because length
constructs all list nodes,
although after you have seen only one, it is obvious that the list is not empty.
The above expression can be simply replaced by null
,
but with Peano numbers you achieve the same
genericLength xs == Zero
-- or
genericLength xs == (0::Peano)
The expression
length xs == length ys
is harder to make lazy without Peano numbers.
With them (and an appropriate Num
instance) this becomes rather simple, because
genericLength xs == (genericLength ys :: Peano)
constructs only as much list nodes, as the shorter list has.
Equation solving
Lazy Peano numbers can also be used within "Tying the Knot" techniques. There is a package for determining the right order for solving equations, where an equation is only solved if only one of its variables is still indeterminate.
See also
See example implementations: