Question

In many articles about Haskell they say it allows to make some checks during compile time instead of run time. So, I want to implement the simplest check possible – allow a function to be called only on integers greater than zero. How can I do it?

Answer 1

Haskell can perform some checks at compile time that other languages perform at runtime. Your question seems to imply you are hoping for arbitrary checks to be lifted to compile time, which isn’t possible without a large potential for proof obligations (which could mean you, the programmer, would need to prove the property is true for all uses).

In the below, I don’t feel like I’m saying anything more than what pigworker touched on while mentioning the very cool sounding Inch tool. Hopefully the additional words on each topic will clarify some of the solution space for you.

What People Mean (when speaking of Haskell’s static guarantees)

Typically when I hear people talk about the static guarantees provided by Haskell they are talking about the Hindley Milner style static type checking. This means one type can not be confused for another – any such misuse is caught at compile time (ex: let x = "5" in x + 1 is invalid). Obviously, this only scratches the surface and we can discuss some more aspects of static checking in Haskell.

Smart Constructors: Check once at runtime, ensure safety via types

Gabriel’s solution is to have a type, Positive, that can only be positive. Building positive values still requires a check at runtime but once you have a positive there are no checks required by consuming functions – the static (compile time) type checking can be leveraged from here.

This is a good solution for many many problems. I recommended the same thing when discussing golden numbers. Never-the-less, I don’t think this is what you are fishing for.

Exact Representations

dflemstr commented that you can use a type, Word, which is unable to represent negative numbers (a slightly different issue than representing positives). In this manner you really don’t need to use a guarded constructor (as above) because there is no inhabitant of the type that violates your invariant.

A more common example of using proper representations is non-empty lists. If you want a type that can never be empty then you could just make a non-empty list type:

data NonEmptyList a = Single a | Cons a (NonEmptyList a)

This is in contrast to the traditional list definition using Nil instead of Single a.

Going back to the positive example, you could use a form of Peano numbers:

data NonNegative = One | S NonNegative

Or user GADTs to build unsigned binary numbers (and you can add Num, and other instances, allowing functions like +):

{-# LANGUAGE GADTs #-}

data Zero
data NonZero
data Binary a where
  I :: Binary a -> Binary NonZero
  O :: Binary a -> Binary a
  Z :: Binary Zero
  N :: Binary NonZero

instance Show (Binary a) where
        show (I x) = "1" ++ show x
        show (O x) = "0" ++ show x
        show (Z)   = "0" 
        show (N)   = "1"

External Proofs

While not part of the Haskell universe, it is possible to generate Haskell using alternate systems (such as Coq) that allow richer properties to be stated and proven. In this manner the Haskell code can simply omit checks like x > 0 but the fact that x will always be greater than 0 will be a static guarantee (again: the safety is not due to Haskell).

From what pigworker said, I would classify Inch in this category. Haskell has not grown sufficiently to perform your desired tasks, but tools to generate Haskell (in this case, very thin layers over Haskell) continue to make progress.

Research on More Descriptive Static Properties

The research community that works with Haskell is wonderful. While too immature for general use, people have developed tools to do things like statically check function partiality and contracts. If you look around you’ll find it’s a rich field.