Compile-time assertions with GHC Haskell?

Question

Coming from C++, I'm used to be able to build simple forms of compile-time assertions, where I could emit warnings or errors during compilation if some simple conditions (e.g. over simple algebraic expressions) weren't met via use of template meta-programming and/or cpp(1)

For instance, if I wanted to make sure my program compiles only when Int has at least a certain minBound/maxBound range or alternatively, if a loss-free (as in reversible) conversion from Int64 to Int is possible with the current compilation target. Is this possible with some GHC Haskell extension? My first guess would have been to use TH. Are there other GHC facilities that could be exploited to this end?

(Un)fortunately, there are no dependent types in Haskell, which would have been great for this purpose (but which would likely require you put many more type annotations). — Alexandre C., Jul 11 '11 at 10:27
@Alexandre: Sounds interesting... Could you elaborate on how dependent types could be used to, say, determine whether `Int64` fits into an `Int` at compile-time? — hvr, Jul 11 '11 at 10:34
Dependent types encode a full blown theorem prover into the type system. Any property of data can be expressed in its type. — kamatsu, Jul 11 '11 at 10:44
@hvr: you can use an `Int lo hi` type when `lo` and `hi` are bounds on the integer. Now, eg. `(+)` has type `Int l1 h1 -> Int l2 h2 -> Int (l1 + l2) (h1 + h2)`. — Alexandre C., Jul 11 '11 at 10:44
For the `minBound/maxBound` check you can also use a `configure` script. — Mikhail Glushenkov, Jul 11 '11 at 10:49
I don't know if you can use it for this purpose, but GHC allows you to run the C preprocessor over your Haskell code with the `-XCPP` flag (or `{-# LANGUAGE CPP #-}` directive). — Antal Spector-Zabusky, Jul 11 '11 at 14:27

score 11 · Accepted Answer · edited May 23 '17 at 11:48

11

Here's a generalized and slightly simplified version of Anthony's example:

{-# LANGUAGE TemplateHaskell #-}
module StaticAssert (staticAssert) where

import Control.Monad (unless)
import Language.Haskell.TH (report)

staticAssert cond mesg = do
    unless cond $ report True $ "Compile time assertion failed: " ++ mesg
    return [] -- No need to make a dummy declaration

Usage:

{-# LANGUAGE TemplateHaskell #-}
import StaticAssert

$(staticAssert False "Not enough waffles")

edited May 23 '17 at 11:48

Community

1
1

answered Jul 11 '11 at 18:45

hammar

138,522
17
304
385

This is indeed a refinement of my noodling around with TH! – Anthony Jul 11 '11 at 18:55
Thanks to you both, @hammar and @Anthony. The required TH-voodoo looks easier than I expected :-)... btw, why do you use the `$( .. )` syntax? isn't that optional for top-level TH invocations? – hvr Jul 11 '11 at 20:04
@hvr: Yes, though I like to use it anyway to make it easier to mentally separate the TH from normal code. – hammar Jul 11 '11 at 20:08
5

Even if it's optional, it's *way* clearer to use the splice syntax uniformly. – Carl Jul 11 '11 at 20:11
@Carl makes a very good point. Haskell's macro culture is still nascent, so we need to tread lightly to avoid brutalizing what prettiness we currently have. – Anthony Jul 12 '11 at 00:19

score 6 · Answer 2 · answered Jul 11 '11 at 17:55

Using TH for this isn't too bad. Here is a module that defines the desired assertion as part of a vestigial declaration:

{-# LANGUAGE TemplateHaskell #-}
module CompileTimeWarning where
import Control.Monad (unless)
import Data.Int (Int64)
import Language.Haskell.TH

assertInt = let test = fromIntegral (maxBound::Int) == (maxBound::Int64)
            in do unless test $ report True "Int is not safe!"
                  n <- newName "assertion"
                  e <- fmap NormalB [|()|]
                  return $ [FunD n [Clause [] e []]]

Using the assertion involves a top-level declaration that isn't used for anything other than the assertion:

{-# LANGUAGE TemplateHaskell #-}
import CompileTimeWarning
$(assertInt)

Compile-time assertions with GHC Haskell?

2 Answers2