id,summary,reporter,owner,description,type,status,priority,milestone,component,version,resolution,keywords,cc,os,architecture,failure,difficulty,testcase,blockedby,blocking,related
2017,Normal Guards are internally spliced as Pattern Guards causing compiler warnings,fons,igloo,"Here is an example

Foo.hs
{{{
{-# OPTIONS_GHC -XTemplateHaskell -ddump-splices #-}

module Foo where

import Language.Haskell.TH

$(do e <- [d| f a b 
                | a == b = a
                | otherwise = b |]
     runIO (putStrLn $ show e)
     return e) 
}}}

The example shows that even if the quasiquotes lift the declarations as normal guards, they are, for some reson, internally spliced as equivalent pattern guards. That shouldn't be a big problem as long as the compiler didn't cause warnings for it.


See the compilation result:

{{{
$ ghci Foo.hs 
GHCi, version 6.8.2: http://www.haskell.org/ghc/  :? for help
Loading package base ... linking ... done.
[1 of 1] Compiling Foo              ( Foo.hs, interpreted )
Loading package array-0.1.0.0 ... linking ... done.
Loading package packedstring-0.1.0.0 ... linking ... done.
Loading package pretty-1.0.0.0 ... linking ... done.
Loading package containers-0.1.0.1 ... linking ... done.
Loading package template-haskell ... linking ... done.
[FunD f [Clause [VarP a_1627394778,VarP b_1627394779] (GuardedB [(NormalG (InfixE (Just (VarE a_1627394778)) (VarE GHC.Base.==) (Just (VarE b_1627394779))),VarE a_1627394778),(NormalG (VarE GHC.Base.otherwise),VarE b_1627394779)]) []]]
Foo.hs:1:0:
    Foo.hs:1:0: Splicing declarations
        let
          >>= = (>>=) @ Q $dMonad
          $dMonad = $dMonad
          >> = (>>) @ Q $dMonad
          $dMonad = Language.Haskell.TH.Syntax.$f22
          show = show @ [Dec] $dShow
          $dShow = GHC.Show.$f21 @ Dec $dShow
          $dShow = Language.Haskell.TH.Syntax.$f52
          return = return @ Q $dMonad
          $dMonad = $dMonad
        in
          do e <- [d| :THFake.f a b
                                  | a == b = a
                                  | otherwise = b |]
             runIO @ () (($) @ String @ (IO ()) putStrLn show e)
             return @ [Dec] e
      ======>
        Foo.hs:(7,2)-(11,12)
        f a[a1fQ] b[a1fR]
            | True <- (a[a1fQ] `GHC.Base.==` b[a1fR]) = a[a1fQ]
            | True <- GHC.Base.otherwise = b[a1fR]

Foo.hs:7:2:
    Warning: accepting non-standard pattern guards (use -XPatternGuards to suppress this message)
                 True <- (a[a1fQ] == b[a1fR])

Foo.hs:7:2:
    Warning: accepting non-standard pattern guards (use -XPatternGuards to suppress this message)
                 True <- otherwise
Ok, modules loaded: Foo.
*Foo> 
}}}

The logical thing a user would expect is to see the guards spliced as:

{{{
   | (a[a1fQ] `GHC.Base.==` b[a1fR]) = a[a1fQ]
}}}

and not

{{{
   | True <- (a[a1fQ] `GHC.Base.==` b[a1fR]) = a[a1fQ]
}}}


As expected and suggested by the compiler the warnings are silenced with the -XPatternGuards.",merge,closed,normal,,Template Haskell,6.8.2,fixed,,,Unknown/Multiple,Unknown/Multiple,,Unknown,TH_spliceGuard,,,