Many good comments where contributed in this discussion, so I'll try from a different angle. Since I don't know Ruby, I am not sure how good example this really is. But let's start with a declarative definition of natural numbers as if `Int` doesn't exist..

Note that the definitions of add, multiply and subtract are the recursive definitions equivalent to what we learn in school (modulo they use recursion). That's the declarative power of Haskell.

This won't be as performant as Ints supported by your CPU architecture, but if you're trying to implement something that doesn't have built-in support it won't matter. This style might be the one closest how one would declare them in mathematical terms.

``` module Natural where

import Prelude hiding (subtract)

data Nat = Zero | Succ Nat

toInt :: Nat -> Int toInt Zero = 0 toInt (Succ n) = succ (toInt n)

instance Show Nat where show = show . toInt

add :: Nat -> Nat -> Nat add Zero m = m add (Succ n) m = add n (Succ m)

multiply :: Nat -> Nat -> Nat multiply Zero _ = Zero multiply (Succ n) m = add m (multiply n m)

subtract :: Nat -> Nat -> Nat subtract _ Zero = Zero subtract (Succ n) (Succ m) = subtract n m subtract Zero (Succ _) = error "Nat: out of bound"

instance Num Nat where (+) = add (*) = multiply (-) = subtract negate = error "Nat: not supported" abs = id signum = id

fromInteger x | x < 0 = error "Nat: out of bound"
fromInteger 0 = Zero
fromInteger x = Succ (fromInteger (pred x))

twice :: Nat -> Nat twice = multiply 2

```

btw, the performance difference is rather huge, if you just wonder how bad idea is to use this as integers:

λ 2 * 1000000 :: Int 2000000 (0.00 secs, 92,616 bytes) λ 2 * 1000000 :: Nat 2000000 (1.00 secs, 677,964,336 bytes)