compiler/basicTypes/OccName.lhs

@@ -261,6 +261,11 @@ instance Data OccName where
 instance Outputable OccName where
     ppr = pprOccName
 
+instance OutputableBndr OccName where
+    pprBndr _ = ppr
+    pprInfixOcc n = pprInfixVar (isSymOcc n) (ppr n)
+    pprPrefixOcc n = pprPrefixVar (isSymOcc n) (ppr n)
+
 pprOccName :: OccName -> SDoc
 pprOccName (OccName sp occ) 
   = getPprStyle $ \ sty ->
@@ -496,7 +501,7 @@ isDataSymOcc _                    = False
 -- it is a data constructor or variable or whatever)
 isSymOcc :: OccName -> Bool
 isSymOcc (OccName DataName s)  = isLexConSym s
-isSymOcc (OccName TcClsName s) = isLexConSym s || isLexVarSym s
+isSymOcc (OccName TcClsName s) = isLexSym s
 isSymOcc (OccName VarName s)   = isLexSym s
 isSymOcc (OccName TvName s)    = isLexSym s
 -- Pretty inefficient!
@@ -864,6 +869,15 @@ isTupleOcc_maybe (OccName ns fs)
 These functions test strings to see if they fit the lexical categories
 defined in the Haskell report.
 
+Note [Classification of generated names]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Some names generated for internal use can show up in debugging output,
+e.g.  when using -ddump-simpl. These generated names start with a $
+but should still be pretty-printed using prefix notation. We make sure
+this is the case in isLexVarSym by only classifying a name as a symbol
+if all its characters are symbols, not just its first one.
+
 \begin{code}
 isLexCon,   isLexVar,    isLexId,    isLexSym    :: FastString -> Bool
 isLexConId, isLexConSym, isLexVarId, isLexVarSym :: FastString -> Bool
@@ -890,19 +904,23 @@ isLexConSym cs				-- Infix type or data constructors
   | cs == (fsLit "->") = True
   | otherwise	       = startsConSym (headFS cs)
 
-isLexVarSym cs				-- Infix identifiers
-  | nullFS cs	      = False		-- 	e.g. "+"
-  | otherwise         = startsVarSym (headFS cs)
+isLexVarSym fs				-- Infix identifiers e.g. "+"
+  = case (if nullFS fs then [] else unpackFS fs) of
+      [] -> False
+      (c:cs) -> startsVarSym c && all isVarSymChar cs
 
 -------------
 startsVarSym, startsVarId, startsConSym, startsConId :: Char -> Bool
-startsVarSym c = isSymbolASCII c || (ord c > 0x7f && isSymbol c) -- Infix Ids
-startsConSym c = c == ':'				-- Infix data constructors
+startsVarSym c = isSymbolASCII c || (ord c > 0x7f && isSymbol c)  -- Infix Ids
+startsConSym c = c == ':'		-- Infix data constructors
 startsVarId c  = isLower c || c == '_'	-- Ordinary Ids
 startsConId c  = isUpper c || c == '('	-- Ordinary type constructors and data constructors
 
 isSymbolASCII :: Char -> Bool
 isSymbolASCII c = c `elem` "!#$%&*+./<=>?@\\^|~-"
+
+isVarSymChar :: Char -> Bool
+isVarSymChar c = c == ':' || startsVarSym c
 \end{code}
 
 %************************************************************************

compiler/iface/IfaceSyn.lhs

@@ -55,6 +55,7 @@ import TysWiredIn ( eqTyConName )
 import Fingerprint
 import Binary
 import BooleanFormula ( BooleanFormula )
+import HsBinds
 
 import Control.Monad
 import System.IO.Unsafe
@@ -1046,7 +1047,7 @@ instance Outputable IfaceDecl where
 pprIfaceDecl :: IfaceDecl -> SDoc
 pprIfaceDecl (IfaceId {ifName = var, ifType = ty,
                        ifIdDetails = details, ifIdInfo = info})
-  = sep [ ppr var <+> dcolon <+> ppr ty,
+  = sep [ pprPrefixOcc var <+> dcolon <+> ppr ty,
           nest 2 (ppr details),
           nest 2 (ppr info) ]
 
@@ -1099,32 +1100,27 @@ pprIfaceDecl (IfaceClass {ifCtxt = context, ifName = clas, ifTyVars = tyvars,
                 sep (map ppr sigs)])
 
 pprIfaceDecl (IfaceAxiom {ifName = name, ifTyCon = tycon, ifAxBranches = branches })
-  = hang (ptext (sLit "axiom") <+> ppr name <> colon)
+  = hang (ptext (sLit "axiom") <+> ppr name <> dcolon)
        2 (vcat $ map (pprAxBranch $ Just tycon) branches)
 
 pprIfaceDecl (IfacePatSyn { ifName = name, ifPatHasWrapper = has_wrap,
                             ifPatIsInfix = is_infix,
-                            ifPatUnivTvs = univ_tvs, ifPatExTvs = ex_tvs,
+                            ifPatUnivTvs = _univ_tvs, ifPatExTvs = _ex_tvs,
                             ifPatProvCtxt = prov_ctxt, ifPatReqCtxt = req_ctxt,
                             ifPatArgs = args,
                             ifPatTy = ty })
-  = hang (text "pattern" <+> header)
-       4 details
+  = pprPatSynSig name has_wrap args' ty' (pprCtxt prov_ctxt) (pprCtxt req_ctxt)
   where
-    header = ppr name <+> dcolon <+>
-             (pprIfaceForAllPart univ_tvs req_ctxt $
-              pprIfaceForAllPart ex_tvs prov_ctxt $
-              pp_tau)
+    args' = case (is_infix, map snd args) of
+        (True, [left_ty, right_ty]) ->
+            InfixPatSyn (pprParendIfaceType left_ty) (pprParendIfaceType right_ty)
+        (_, tys) ->
+            PrefixPatSyn (map pprParendIfaceType tys)
 
-    details = sep [ if is_infix then text "Infix" else empty
-                  , if has_wrap then text "HasWrapper" else empty
-                  ]
+    ty' = pprParendIfaceType ty
 
-    pp_tau = case map pprParendIfaceType (arg_tys ++ [ty]) of
-        (t:ts) -> fsep (t : map (arrow <+>) ts)
-        []     -> panic "pp_tau"
-
-    arg_tys = map snd args
+    pprCtxt [] = Nothing
+    pprCtxt ctxt = Just $ pprIfaceContext ctxt
 
 pprCType :: Maybe CType -> SDoc
 pprCType Nothing = ptext (sLit "No C type associated")
@@ -1152,7 +1148,7 @@ instance Outputable IfaceAT where
 
 pprIfaceDeclHead :: IfaceContext -> OccName -> [IfaceTvBndr] -> SDoc
 pprIfaceDeclHead context thing tyvars
-  = hsep [pprIfaceContext context, parenSymOcc thing (ppr thing),
+  = hsep [pprIfaceContextArr context, parenSymOcc thing (ppr thing),
           pprIfaceTvBndrs tyvars]
 
 pp_condecls :: OccName -> IfaceConDecls -> SDoc

compiler/iface/IfaceType.lhs

@@ -22,7 +22,7 @@ module IfaceType (
         toIfaceCoercion,
 
         -- Printing
-        pprIfaceType, pprParendIfaceType, pprIfaceContext,
+        pprIfaceType, pprParendIfaceType, pprIfaceContext, pprIfaceContextArr,
         pprIfaceIdBndr, pprIfaceTvBndr, pprIfaceTvBndrs,
         pprIfaceBndrs,
         tOP_PREC, tYCON_PREC, noParens, maybeParen, pprIfaceForAllPart,
@@ -31,6 +31,8 @@ module IfaceType (
     ) where
 
 import Coercion
+import TcType
+import DynFlags
 import TypeRep hiding( maybeParen )
 import Unique( hasKey )
 import TyCon
@@ -248,15 +250,18 @@ ppr_ty ctxt_prec ty@(IfaceForAllTy _ _)
  where
     (tvs, theta, tau) = splitIfaceSigmaTy ty
 
- -------------------
+-------------------
 -- needs to handle type contexts and coercion contexts, hence the
 -- generality
 pprIfaceForAllPart :: Outputable a => [IfaceTvBndr] -> [a] -> SDoc -> SDoc
 pprIfaceForAllPart tvs ctxt doc
-  = sep [ppr_tvs, pprIfaceContext ctxt, doc]
+  = sep [ppr_tvs, pprIfaceContextArr ctxt, doc]
   where
     ppr_tvs | null tvs  = empty
-            | otherwise = ptext (sLit "forall") <+> pprIfaceTvBndrs tvs <> dot
+            | otherwise = sdocWithDynFlags $ \ dflags ->
+            if gopt Opt_PrintExplicitForalls dflags
+            then ptext (sLit "forall") <+> pprIfaceTvBndrs tvs <> dot
+            else empty
 
 -------------------
 ppr_tc_app :: (Int -> a -> SDoc) -> Int -> IfaceTyCon -> [a] -> SDoc
@@ -386,14 +391,14 @@ instance Binary IfaceTyLit where
          _ -> panic ("get IfaceTyLit " ++ show tag)
 
 -------------------
-pprIfaceContext :: Outputable a => [a] -> SDoc
+pprIfaceContextArr :: Outputable a => [a] -> SDoc
 -- Prints "(C a, D b) =>", including the arrow
-pprIfaceContext []    = empty
-pprIfaceContext theta = ppr_preds theta <+> darrow
+pprIfaceContextArr []    = empty
+pprIfaceContextArr theta = pprIfaceContext theta <+> darrow
 
-ppr_preds :: Outputable a => [a] -> SDoc
-ppr_preds [pred] = ppr pred    -- No parens
-ppr_preds preds  = parens (sep (punctuate comma (map ppr preds)))
+pprIfaceContext :: Outputable a => [a] -> SDoc
+pprIfaceContext [pred] = ppr pred    -- No parens
+pprIfaceContext preds  = parens (sep (punctuate comma (map ppr preds)))
 
 instance Binary IfaceType where
     put_ bh (IfaceForAllTy aa ab) = do

compiler/iface/MkIface.lhs

@@ -1461,7 +1461,7 @@ tyThingToIfaceDecl (AnId id)      = idToIfaceDecl id
 tyThingToIfaceDecl (ATyCon tycon) = tyConToIfaceDecl emptyTidyEnv tycon
 tyThingToIfaceDecl (ACoAxiom ax)  = coAxiomToIfaceDecl ax
 tyThingToIfaceDecl (AConLike cl)  = case cl of
-    RealDataCon dc -> pprPanic "toIfaceDecl" (ppr dc) -- Should be trimmed out earlier
+    RealDataCon dc -> dataConToIfaceDecl dc -- for ppr purposes only
     PatSynCon ps   -> patSynToIfaceDecl ps
 
 --------------------------
@@ -1476,6 +1476,14 @@ idToIfaceDecl id
               ifIdDetails = toIfaceIdDetails (idDetails id),
               ifIdInfo    = toIfaceIdInfo (idInfo id) }
 
+--------------------------
+dataConToIfaceDecl :: DataCon -> IfaceDecl
+dataConToIfaceDecl dataCon
+  = IfaceId { ifName      = getOccName dataCon,
+              ifType      = toIfaceType (dataConUserType dataCon),
+              ifIdDetails = IfVanillaId,
+              ifIdInfo    = NoInfo }
+
 --------------------------
 patSynToIfaceDecl :: PatSyn -> IfaceDecl
 patSynToIfaceDecl ps

compiler/main/PprTyThing.hs

@@ -23,20 +23,18 @@ module PprTyThing (
   ) where
 
 import TypeRep ( TyThing(..) )
-import ConLike
 import DataCon
-import PatSyn
 import Id
 import TyCon
 import Class
-import Coercion( pprCoAxiom, pprCoAxBranch )
+import Coercion( pprCoAxBranch )
 import CoAxiom( CoAxiom(..), brListMap )
 import HscTypes( tyThingParent_maybe )
-import HsBinds( pprPatSynSig )
 import Type( tidyTopType, tidyOpenType, splitForAllTys, funResultTy )
 import Kind( synTyConResKind )
 import TypeRep( pprTvBndrs, pprForAll, suppressKinds )
 import TysPrim( alphaTyVars )
+import MkIface ( tyThingToIfaceDecl )
 import TcType
 import Name
 import VarEnv( emptyTidyEnv )
@@ -44,7 +42,6 @@ import StaticFlags( opt_PprStyle_Debug )
 import DynFlags
 import Outputable
 import FastString
-import Data.Maybe
 
 -- -----------------------------------------------------------------------------
 -- Pretty-printing entities that we get from the GHC API
@@ -76,7 +73,7 @@ pprTyThingLoc tyThing
 
 -- | Pretty-prints a 'TyThing'.
 pprTyThing :: TyThing -> SDoc
-pprTyThing thing = ppr_ty_thing showAll thing
+pprTyThing thing = ppr_ty_thing (Just showAll) thing
 
 -- | Pretty-prints a 'TyThing' in context: that is, if the entity
 -- is a data constructor, record selector, or class method, then
@@ -88,7 +85,7 @@ pprTyThingInContext thing
   where
     go ss thing = case tyThingParent_maybe thing of
                     Just parent -> go (getName thing : ss) parent
-                    Nothing     -> ppr_ty_thing ss thing
+                    Nothing     -> ppr_ty_thing (Just ss) thing
 
 -- | Like 'pprTyThingInContext', but adds the defining location.
 pprTyThingInContextLoc :: TyThing -> SDoc
@@ -100,21 +97,18 @@ pprTyThingInContextLoc tyThing
 -- the function is equivalent to 'pprTyThing' but for type constructors
 -- and classes it prints only the header part of the declaration.
 pprTyThingHdr :: TyThing -> SDoc
-pprTyThingHdr (AnId id)          = pprId         id
-pprTyThingHdr (AConLike conLike) = case conLike of
-    RealDataCon dataCon -> pprDataConSig dataCon
-    PatSynCon patSyn    -> pprPatSyn     patSyn
-pprTyThingHdr (ATyCon tyCon)     = pprTyConHdr   tyCon
-pprTyThingHdr (ACoAxiom ax)      = pprCoAxiom ax
+pprTyThingHdr = ppr_ty_thing Nothing
 
 ------------------------
-ppr_ty_thing :: ShowSub -> TyThing -> SDoc
-ppr_ty_thing _  (AnId id)          = pprId         id
-ppr_ty_thing _  (AConLike conLike) = case conLike of
-    RealDataCon dataCon -> pprDataConSig dataCon
-    PatSynCon patSyn    -> pprPatSyn     patSyn
-ppr_ty_thing ss (ATyCon tyCon)     = pprTyCon      ss tyCon
-ppr_ty_thing _  (ACoAxiom ax)      = pprCoAxiom    ax
+-- NOTE: We pretty-print 'TyThing' via 'IfaceDecl' so that we can reuse the
+-- 'TyCon' tidying happening in 'tyThingToIfaceDecl'. See #8776 for details.
+ppr_ty_thing :: Maybe ShowSub -> TyThing -> SDoc
+ppr_ty_thing mss tyThing = case tyThing of
+    AnId id -> pprId id
+    ATyCon tyCon -> case mss of
+        Nothing -> pprTyConHdr tyCon
+        Just ss -> pprTyCon ss tyCon
+    _ -> ppr $ tyThingToIfaceDecl tyThing
 
 pprTyConHdr :: TyCon -> SDoc
 pprTyConHdr tyCon
@@ -143,10 +137,6 @@ pprTyConHdr tyCon
 	| isAlgTyCon tyCon = pprThetaArrowTy (tyConStupidTheta tyCon)
 	| otherwise	   = empty	-- Returns 'empty' if null theta
 
-pprDataConSig :: DataCon -> SDoc
-pprDataConSig dataCon
-  = ppr_bndr dataCon <+> dcolon <+> pprTypeForUser (dataConUserType dataCon)
-
 pprClassHdr :: Class -> SDoc
 pprClassHdr cls
   = sdocWithDynFlags $ \dflags ->
@@ -163,23 +153,6 @@ pprId ident
   = hang (ppr_bndr ident <+> dcolon)
 	 2 (pprTypeForUser (idType ident))
 
-pprPatSyn :: PatSyn -> SDoc
-pprPatSyn patSyn
-  = pprPatSynSig ident is_bidir args (pprTypeForUser rhs_ty) prov req
-  where
-    ident = patSynId patSyn
-    is_bidir = isJust $ patSynWrapper patSyn
-
-    args = fmap pprParendType (patSynTyDetails patSyn)
-    prov = pprThetaOpt prov_theta
-    req = pprThetaOpt req_theta
-
-    pprThetaOpt [] = Nothing
-    pprThetaOpt theta = Just $ pprTheta theta
-
-    (_univ_tvs, _ex_tvs, (prov_theta, req_theta)) = patSynSig patSyn
-    rhs_ty = patSynType patSyn
-
 pprTypeForUser :: Type -> SDoc
 -- We do two things here.
 -- a) We tidy the type, regardless

testsuite/tests/ghci/scripts/T8776.hs

+{-# LANGUAGE PatternSynonyms, GADTs #-}
+data A x y = (Num x, Eq y) => B
+
+data R = R{ rX :: Int }
+
+pattern P = B

testsuite/tests/ghci/scripts/T8776.script

+:load T8776.hs
+:i P

testsuite/tests/ghci/scripts/T8776.stdout

+pattern (Num t, Eq t1) => P :: (A t t1) 	-- Defined at T8776.hs:6:9

testsuite/tests/ghci/scripts/all.T

@@ -166,3 +166,5 @@ test('T8579', normal, ghci_script, ['T8579.script'])
 test('T8649', normal, ghci_script, ['T8649.script'])
 test('T8674', normal, ghci_script, ['T8674.script'])
 test('T8696', normal, ghci_script, ['T8696.script'])
+test('T8776', normal, ghci_script, ['T8776.script'])
+

testsuite/tests/indexed-types/should_compile/T3017.stderr

@@ -14,7 +14,7 @@ TYPE CONSTRUCTORS
     No C type associated
     Roles: [representational]
     RecFlag NonRecursive, Promotable
-    = L :: forall a. [a] -> ListColl a Stricts: _
+    = L :: [a] -> ListColl a Stricts: _
     FamilyInstance: none
 COERCION AXIOMS
   axiom Foo.TFCo:R:ElemListColl :: Elem (ListColl a) = a

testsuite/tests/roles/should_compile/Roles1.stderr

@@ -2,53 +2,53 @@ TYPE SIGNATURES
 TYPE CONSTRUCTORS
   T1 :: * -> *
   data T1 a
-      No C type associated
-      Roles: [nominal]
-      RecFlag NonRecursive, Promotable
-      = K1 :: forall a. a -> T1 a Stricts: _
-      FamilyInstance: none
+    No C type associated
+    Roles: [nominal]
+    RecFlag NonRecursive, Promotable
+    = K1 :: forall a. a -> T1 a Stricts: _
+    FamilyInstance: none
   T2 :: * -> *
   data T2 a
-      No C type associated
-      Roles: [representational]
-      RecFlag NonRecursive, Promotable
-      = K2 :: forall a. a -> T2 a Stricts: _
-      FamilyInstance: none
+    No C type associated
+    Roles: [representational]
+    RecFlag NonRecursive, Promotable
+    = K2 :: forall a. a -> T2 a Stricts: _
+    FamilyInstance: none
   T3 :: k -> *
   data T3 (k::BOX) (a::k)
-      No C type associated
-      Roles: [nominal, phantom]
-      RecFlag NonRecursive, Not promotable
-      = K3 :: forall (k::BOX) (a::k). T3 k a
-      FamilyInstance: none
+    No C type associated
+    Roles: [nominal, phantom]
+    RecFlag NonRecursive, Not promotable
+    = K3 :: forall (k::BOX) (a::k). T3 k a
+    FamilyInstance: none
   T4 :: (* -> *) -> * -> *
   data T4 (a::* -> *) b
-      No C type associated
-      Roles: [nominal, nominal]
-      RecFlag NonRecursive, Not promotable
-      = K4 :: forall (a::* -> *) b. (a b) -> T4 a b Stricts: _
-      FamilyInstance: none
+    No C type associated
+    Roles: [nominal, nominal]
+    RecFlag NonRecursive, Not promotable
+    = K4 :: forall (a::* -> *) b. (a b) -> T4 a b Stricts: _
+    FamilyInstance: none
   T5 :: * -> *
   data T5 a
-      No C type associated
-      Roles: [representational]
-      RecFlag NonRecursive, Promotable
-      = K5 :: forall a. a -> T5 a Stricts: _
-      FamilyInstance: none
+    No C type associated
+    Roles: [representational]
+    RecFlag NonRecursive, Promotable
+    = K5 :: forall a. a -> T5 a Stricts: _
+    FamilyInstance: none
   T6 :: k -> *
   data T6 (k::BOX) (a::k)
-      No C type associated
-      Roles: [nominal, phantom]
-      RecFlag NonRecursive, Not promotable
-      = K6 :: forall (k::BOX) (a::k). T6 k a
-      FamilyInstance: none
+    No C type associated
+    Roles: [nominal, phantom]
+    RecFlag NonRecursive, Not promotable
+    = K6 :: forall (k::BOX) (a::k). T6 k a
+    FamilyInstance: none
   T7 :: k -> * -> *
   data T7 (k::BOX) (a::k) b
-      No C type associated
-      Roles: [nominal, phantom, representational]
-      RecFlag NonRecursive, Not promotable
-      = K7 :: forall (k::BOX) (a::k) b. b -> T7 k a b Stricts: _
-      FamilyInstance: none
+    No C type associated
+    Roles: [nominal, phantom, representational]
+    RecFlag NonRecursive, Not promotable
+    = K7 :: forall (k::BOX) (a::k) b. b -> T7 k a b Stricts: _
+    FamilyInstance: none
 COERCION AXIOMS
 Dependent modules: []
 Dependent packages: [base, ghc-prim, integer-gmp]

testsuite/tests/roles/should_compile/Roles2.stderr

@@ -2,18 +2,18 @@ TYPE SIGNATURES
 TYPE CONSTRUCTORS
   T1 :: * -> *
   data T1 a
-      No C type associated
-      Roles: [representational]
-      RecFlag NonRecursive, Not promotable
-      = K1 :: forall a. (IO a) -> T1 a Stricts: _
-      FamilyInstance: none
+    No C type associated
+    Roles: [representational]
+    RecFlag NonRecursive, Not promotable
+    = K1 :: forall a. (IO a) -> T1 a Stricts: _
+    FamilyInstance: none
   T2 :: * -> *
   data T2 a
-      No C type associated
-      Roles: [representational]
-      RecFlag NonRecursive, Not promotable
-      = K2 :: forall a. (FunPtr a) -> T2 a Stricts: _
-      FamilyInstance: none
+    No C type associated
+    Roles: [representational]
+    RecFlag NonRecursive, Not promotable
+    = K2 :: forall a. (FunPtr a) -> T2 a Stricts: _
+    FamilyInstance: none
 COERCION AXIOMS
 Dependent modules: []
 Dependent packages: [base, ghc-prim, integer-gmp]

testsuite/tests/roles/should_compile/all.T

-test('Roles1', only_ways('normal'), compile, ['-ddump-tc'])
-test('Roles2', only_ways('normal'), compile, ['-ddump-tc'])
+test('Roles1', only_ways('normal'), compile, ['-ddump-tc -fprint-explicit-foralls'])
+test('Roles2', only_ways('normal'), compile, ['-ddump-tc -fprint-explicit-foralls'])
 test('Roles3', only_ways('normal'), compile, ['-ddump-tc'])
 test('Roles4', only_ways('normal'), compile, ['-ddump-tc'])
 test('Roles13', only_ways('normal'), compile, ['-ddump-simpl -dsuppress-uniques'])
 test('Roles14', only_ways('normal'), compile, ['-ddump-tc'])
-test('RolesIArray', only_ways('normal'), compile, [''])
\ No newline at end of file
+test('RolesIArray', only_ways('normal'), compile, [''])

testsuite/tests/typecheck/should_compile/tc231.stderr

@@ -10,21 +10,20 @@ TYPE CONSTRUCTORS
     No C type associated
     Roles: [representational, representational, representational]
     RecFlag NonRecursive, Promotable
-    = Node :: forall s a chain. s -> a -> chain -> Q s a chain
-        Stricts: _ _ _
+    = Node :: s -> a -> chain -> Q s a chain Stricts: _ _ _
     FamilyInstance: none
   Z :: * -> *
   data Z a
     No C type associated
     Roles: [representational]
     RecFlag NonRecursive, Promotable
-    = Z :: forall a. a -> Z a Stricts: _
+    = Z :: a -> Z a Stricts: _
     FamilyInstance: none
   Zork :: * -> * -> * -> Constraint
   class Zork s a b | a -> b
     Roles: [nominal, nominal, nominal]
     RecFlag NonRecursive
-    huh :: forall chain. Q s a chain -> ST s ()
+    huh :: Q s a chain -> ST s ()
 COERCION AXIOMS
   axiom ShouldCompile.NTCo:Zork ::
       Zork s a b = forall chain. Q s a chain -> ST s ()