Redundant Bang Patterns [GHC-38520]

Flag: -Wredundant-bang-patterns

The BangPatterns extension allows the user to mark parts of a pattern as strict by prefixing the pattern with an exclamation mark. By default, Haskell only evaluates an expression as little as it needs to determine whether the pattern matches or not. Using bang patterns causes the matched expression to always be evaluated to weak head normal form (WHNF) before the rest of the clauses, any guard patterns, or the right-hand side of the clause are executed.

However, there are cases where a bang pattern can be redundant. This happens either because a previous match clause already forced the evaluation, because the user is trying to match on a strict field of a data type, or because the type of the value being matched on is of an unlifted or unboxed type like Int# or Array#.

In all of these cases, the Bang Pattern has no added effect, so it is redundant.

Examples

Already deconstructed

Warning message

AlreadyDeconstructed.hs:5:15: warning: [-Wredundant-bang-patterns]
    Pattern match has redundant bang
    In an equation for ‘doubleIfTrue’: doubleIfTrue x = ...
  |
5 | doubleIfTrue !x         = fst x
  |               ^

Explanation

It is possible that a previous clause already forced the evaluation of an expression. For example, doubleIfTrue’s first clause already deconstructs the pair tuple, so a bang pattern on the tuple as a whole has no effect in the second clause.

AlreadyDeconstructed.hs

Before

module AlreadyDeconstructed where

doubleIfTrue :: (Int, Bool) -> Int
doubleIfTrue (x, y) | y = x * 2
doubleIfTrue !x         = fst x

After

module AlreadyDeconstructed where

doubleIfTrue :: (Int, Bool) -> Int
doubleIfTrue (x, y) | y = x * 2
doubleIfTrue x          = fst x

Strict fields

Warning message

UnliftedTypes.hs:17:6: warning: [-Wredundant-bang-patterns]
    Pattern match has redundant bang
    In an equation for ‘foo’: foo a = ...
   |
17 | foo !a !b !c = ()
   |      ^

Explanation

Haskell allows a user to annotate fields of a datatype as strict, by prepending their type with an exclamation mark. Pattern matching on such a constructor forces it to WHNF, but this also automatically forces any strict fields to evaluate to WHNF as well. Thus, a Bang Pattern has no effect on a strict field.

StrictField.hs

Before

module StrictField where

data Foo = MkFoo !Int Int

foo :: Foo -> Foo -> ()
foo !a (MkFoo !b !c) = ()

After

module StrictField where

data Foo = MkFoo !Int Int

foo :: Foo -> Foo -> ()
foo !a (MkFoo b !c) = ()

Unlifted and unboxed types

Warning messages

UnliftedTypes.hs:17:6: warning: [-Wredundant-bang-patterns]
    Pattern match has redundant bang
    In an equation for ‘foo’: foo a = ...
   |
17 | foo !a !b !c = ()
   |      ^

UnliftedTypes.hs:17:9: warning: [-Wredundant-bang-patterns]
    Pattern match has redundant bang
    In an equation for ‘foo’: foo b = ...
   |
17 | foo !a !b !c = ()
   |         ^

UnliftedTypes.hs:17:12: warning: [-Wredundant-bang-patterns]
    Pattern match has redundant bang
    In an equation for ‘foo’: foo c = ...
   |
17 | foo !a !b !c = ()
   |            ^

Explanation

Forcing the evaluation of a value up to WHNF does not make sense for unlifted and unboxed types, because these types can never be represented by an unevaluated expression at runtime. Thus, trying to enforce strictness via a bang pattern has no effect.

UnliftedTypes.hs

Before

{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE UnliftedNewtypes #-}

module UnliftedTypes where

import GHC.Exts

newtype MyInt :: TYPE 'IntRep where
  MkMyInt :: Int# -> MyInt

foo :: Int# -> MyInt -> (# Int, Int #) -> ()
foo !a !b !c = ()

After

{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE UnliftedNewtypes #-}

module UnliftedTypes where

import GHC.Exts

newtype MyInt :: TYPE 'IntRep where
  MkMyInt :: Int# -> MyInt

foo :: Int# -> MyInt -> (# Int, Int #) -> ()
foo a b c = ()