Commit 08d595c0 authored by Ben Gamari's avatar Ben Gamari 🐢 Committed by Marge Bot

Give seq a more precise type and remove magic

`GHC.Prim.seq` previously had the rather plain type:

    seq :: forall a b. a -> b -> b

However, it also had a special typing rule to applications
where `b` is not of kind `Type`.

Issue #17440 noted that levity polymorphism allows us to rather give
it the more precise type:

    seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b

This allows us to remove the special typing rule that we previously
required to allow applications on unlifted arguments. T9404 contains a
non-Type application of `seq` which should verify that this works as
expected.

Closes #17440.
parent a8adb5b4
Pipeline #12952 passed with stages
in 466 minutes and 35 seconds
......@@ -1392,7 +1392,6 @@ seqId = pcMiscPrelId seqName ty info
where
info = noCafIdInfo `setInlinePragInfo` inline_prag
`setUnfoldingInfo` mkCompulsoryUnfolding rhs
`setNeverLevPoly` ty
inline_prag
= alwaysInlinePragma `setInlinePragmaActivation` ActiveAfter
......@@ -1402,11 +1401,15 @@ seqId = pcMiscPrelId seqName ty info
-- LHS of rules. That way we can have rules for 'seq';
-- see Note [seqId magic]
ty = mkSpecForAllTys [alphaTyVar,betaTyVar]
(mkVisFunTy alphaTy (mkVisFunTy betaTy betaTy))
-- seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b
ty =
mkInvForAllTy runtimeRep2TyVar
$ mkSpecForAllTys [alphaTyVar, openBetaTyVar]
$ mkVisFunTy alphaTy (mkVisFunTy openBetaTy openBetaTy)
[x,y] = mkTemplateLocals [alphaTy, betaTy]
rhs = mkLams [alphaTyVar,betaTyVar,x,y] (Case (Var x) x betaTy [(DEFAULT, [], Var y)])
[x,y] = mkTemplateLocals [alphaTy, openBetaTy]
rhs = mkLams ([runtimeRep2TyVar, alphaTyVar, openBetaTyVar, x, y]) $
Case (Var x) x openBetaTy [(DEFAULT, [], Var y)]
------------------------------------------------
lazyId :: Id -- See Note [lazyId magic]
......@@ -1492,19 +1495,20 @@ Note [seqId magic]
~~~~~~~~~~~~~~~~~~
'GHC.Prim.seq' is special in several ways.
a) In source Haskell its second arg can have an unboxed type
x `seq` (v +# w)
But see Note [Typing rule for seq] in TcExpr, which
explains why we give seq itself an ordinary type
seq :: forall a b. a -> b -> b
and treat it as a language construct from a typing point of view.
a) Its fixity is set in LoadIface.ghcPrimIface
b) Its fixity is set in LoadIface.ghcPrimIface
c) It has quite a bit of desugaring magic.
b) It has quite a bit of desugaring magic.
See DsUtils.hs Note [Desugaring seq (1)] and (2) and (3)
d) There is some special rule handing: Note [User-defined RULES for seq]
c) There is some special rule handing: Note [User-defined RULES for seq]
Historical note:
In TcExpr we used to need a special typing rule for 'seq', to handle calls
whose second argument had an unboxed type, e.g. x `seq` 3#
However, with levity polymorphism we can now give seq the type seq ::
forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b which handles this
case without special treatment in the typechecker.
Note [User-defined RULES for seq]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
......@@ -1530,13 +1534,16 @@ If we wrote
RULE "f/seq" forall n e. seq (f n) e = seq n e
with rule arity 2, then two bad things would happen:
- The magical desugaring done in Note [seqId magic] item (c)
- The magical desugaring done in Note [seqId magic] item (b)
for saturated application of 'seq' would turn the LHS into
a case expression!
- The code in Simplify.rebuildCase would need to actually supply
the value argument, which turns out to be awkward.
See also: Note [User-defined RULES for seq] in Simplify.
Note [lazyId magic]
~~~~~~~~~~~~~~~~~~~
lazy :: forall a?. a? -> a? (i.e. works for unboxed types too)
......
......@@ -408,82 +408,88 @@ mkErrorAppDs err_id ty msg = do
return (mkApps (Var err_id) [Type (getRuntimeRep ty), Type ty, core_msg])
{-
'mkCoreAppDs' and 'mkCoreAppsDs' hand the special-case desugaring of 'seq'.
Note [Desugaring seq (1)] cf #1031
~~~~~~~~~~~~~~~~~~~~~~~~~
f x y = x `seq` (y `seq` (# x,y #))
The [CoreSyn let/app invariant] means that, other things being equal, because
the argument to the outer 'seq' has an unlifted type, we'll use call-by-value thus:
f x y = case (y `seq` (# x,y #)) of v -> x `seq` v
But that is bad for two reasons:
(a) we now evaluate y before x, and
(b) we can't bind v to an unboxed pair
Seq is very, very special! So we recognise it right here, and desugar to
case x of _ -> case y of _ -> (# x,y #)
Note [Desugaring seq (2)] cf #2273
~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
let chp = case b of { True -> fst x; False -> 0 }
in chp `seq` ...chp...
Here the seq is designed to plug the space leak of retaining (snd x)
for too long.
If we rely on the ordinary inlining of seq, we'll get
let chp = case b of { True -> fst x; False -> 0 }
case chp of _ { I# -> ...chp... }
But since chp is cheap, and the case is an alluring contet, we'll
inline chp into the case scrutinee. Now there is only one use of chp,
so we'll inline a second copy. Alas, we've now ruined the purpose of
the seq, by re-introducing the space leak:
case (case b of {True -> fst x; False -> 0}) of
I# _ -> ...case b of {True -> fst x; False -> 0}...
We can try to avoid doing this by ensuring that the binder-swap in the
case happens, so we get his at an early stage:
case chp of chp2 { I# -> ...chp2... }
But this is fragile. The real culprit is the source program. Perhaps we
should have said explicitly
let !chp2 = chp in ...chp2...
But that's painful. So the code here does a little hack to make seq
more robust: a saturated application of 'seq' is turned *directly* into
the case expression, thus:
x `seq` e2 ==> case x of x -> e2 -- Note shadowing!
e1 `seq` e2 ==> case x of _ -> e2
So we desugar our example to:
let chp = case b of { True -> fst x; False -> 0 }
case chp of chp { I# -> ...chp... }
And now all is well.
The reason it's a hack is because if you define mySeq=seq, the hack
won't work on mySeq.
Note [Desugaring seq (3)] cf #2409
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The isLocalId ensures that we don't turn
True `seq` e
into
case True of True { ... }
which stupidly tries to bind the datacon 'True'.
'mkCoreAppDs' and 'mkCoreAppsDs' handle the special-case desugaring of 'seq'.
Note [Desugaring seq]
~~~~~~~~~~~~~~~~~~~~~
There are a few subtleties in the desugaring of `seq`:
1. (as described in #1031)
Consider,
f x y = x `seq` (y `seq` (# x,y #))
The [CoreSyn let/app invariant] means that, other things being equal, because
the argument to the outer 'seq' has an unlifted type, we'll use call-by-value thus:
f x y = case (y `seq` (# x,y #)) of v -> x `seq` v
But that is bad for two reasons:
(a) we now evaluate y before x, and
(b) we can't bind v to an unboxed pair
Seq is very, very special! So we recognise it right here, and desugar to
case x of _ -> case y of _ -> (# x,y #)
2. (as described in #2273)
Consider
let chp = case b of { True -> fst x; False -> 0 }
in chp `seq` ...chp...
Here the seq is designed to plug the space leak of retaining (snd x)
for too long.
If we rely on the ordinary inlining of seq, we'll get
let chp = case b of { True -> fst x; False -> 0 }
case chp of _ { I# -> ...chp... }
But since chp is cheap, and the case is an alluring contet, we'll
inline chp into the case scrutinee. Now there is only one use of chp,
so we'll inline a second copy. Alas, we've now ruined the purpose of
the seq, by re-introducing the space leak:
case (case b of {True -> fst x; False -> 0}) of
I# _ -> ...case b of {True -> fst x; False -> 0}...
We can try to avoid doing this by ensuring that the binder-swap in the
case happens, so we get his at an early stage:
case chp of chp2 { I# -> ...chp2... }
But this is fragile. The real culprit is the source program. Perhaps we
should have said explicitly
let !chp2 = chp in ...chp2...
But that's painful. So the code here does a little hack to make seq
more robust: a saturated application of 'seq' is turned *directly* into
the case expression, thus:
x `seq` e2 ==> case x of x -> e2 -- Note shadowing!
e1 `seq` e2 ==> case x of _ -> e2
So we desugar our example to:
let chp = case b of { True -> fst x; False -> 0 }
case chp of chp { I# -> ...chp... }
And now all is well.
The reason it's a hack is because if you define mySeq=seq, the hack
won't work on mySeq.
3. (as described in #2409)
The isLocalId ensures that we don't turn
True `seq` e
into
case True of True { ... }
which stupidly tries to bind the datacon 'True'.
-}
-- NB: Make sure the argument is not levity polymorphic
mkCoreAppDs :: SDoc -> CoreExpr -> CoreExpr -> CoreExpr
mkCoreAppDs _ (Var f `App` Type ty1 `App` Type ty2 `App` arg1) arg2
| f `hasKey` seqIdKey -- Note [Desugaring seq (1), (2)]
mkCoreAppDs _ (Var f `App` Type _r `App` Type ty1 `App` Type ty2 `App` arg1) arg2
| f `hasKey` seqIdKey -- Note [Desugaring seq], points (1) and (2)
= Case arg1 case_bndr ty2 [(DEFAULT,[],arg2)]
where
case_bndr = case arg1 of
Var v1 | isInternalName (idName v1)
-> v1 -- Note [Desugaring seq (2) and (3)]
-> v1 -- Note [Desugaring seq], points (2) and (3)
_ -> mkWildValBinder ty1
mkCoreAppDs s fun arg = mkCoreApp s fun arg -- The rest is done in MkCore
......
......@@ -2090,11 +2090,16 @@ trySeqRules in_env scrut rhs cont
no_cast_scrut = drop_casts scrut
scrut_ty = exprType no_cast_scrut
seq_id_ty = idType seqId
res1_ty = piResultTy seq_id_ty rhs_rep
res2_ty = piResultTy res1_ty scrut_ty
rhs_ty = substTy in_env (exprType rhs)
out_args = [ TyArg { as_arg_ty = scrut_ty
rhs_rep = getRuntimeRep rhs_ty
out_args = [ TyArg { as_arg_ty = rhs_rep
, as_hole_ty = seq_id_ty }
, TyArg { as_arg_ty = scrut_ty
, as_hole_ty = res1_ty }
, TyArg { as_arg_ty = rhs_ty
, as_hole_ty = piResultTy seq_id_ty scrut_ty }
, as_hole_ty = res2_ty }
, ValArg no_cast_scrut]
rule_cont = ApplyToVal { sc_dup = NoDup, sc_arg = rhs
, sc_env = in_env, sc_cont = cont }
......
......@@ -63,9 +63,8 @@ import TyCoSubst (substTyWithInScope)
import Type
import TcEvidence
import VarSet
import MkId( seqId )
import TysWiredIn
import TysPrim( intPrimTy, mkTemplateTyVars, tYPE )
import TysPrim( intPrimTy )
import PrimOp( tagToEnumKey )
import PrelNames
import DynFlags
......@@ -335,39 +334,9 @@ rule just for saturated applications of ($).
* Decompose it; should be of form (arg2_ty -> res_ty),
where arg2_ty might be a polytype
* Use arg2_ty to typecheck arg2
Note [Typing rule for seq]
~~~~~~~~~~~~~~~~~~~~~~~~~~
We want to allow
x `seq` (# p,q #)
which suggests this type for seq:
seq :: forall (a:*) (b:Open). a -> b -> b,
with (b:Open) meaning that be can be instantiated with an unboxed
tuple. The trouble is that this might accept a partially-applied
'seq', and I'm just not certain that would work. I'm only sure it's
only going to work when it's fully applied, so it turns into
case x of _ -> (# p,q #)
So it seems more uniform to treat 'seq' as if it was a language
construct.
See also Note [seqId magic] in MkId
-}
tcExpr expr@(OpApp fix arg1 op arg2) res_ty
| (L loc (HsVar _ (L lv op_name))) <- op
, op_name `hasKey` seqIdKey -- Note [Typing rule for seq]
= do { arg1_ty <- newFlexiTyVarTy liftedTypeKind
; let arg2_exp_ty = res_ty
; arg1' <- tcArg op arg1 arg1_ty 1
; arg2' <- addErrCtxt (funAppCtxt op arg2 2) $
tc_poly_expr_nc arg2 arg2_exp_ty
; arg2_ty <- readExpType arg2_exp_ty
; op_id <- tcLookupId op_name
; let op' = L loc (mkHsWrap (mkWpTyApps [arg1_ty, arg2_ty])
(HsVar noExtField (L lv op_id)))
; return $ OpApp fix arg1' op' arg2' }
| (L loc (HsVar _ (L lv op_name))) <- op
, op_name `hasKey` dollarIdKey -- Note [Typing rule for ($)]
= do { traceTc "Application rule" (ppr op)
......@@ -1161,26 +1130,11 @@ tcApp m_herald fun@(L loc (HsRecFld _ fld_lbl)) args res_ty
; (tc_fun, fun_ty) <- tcInferRecSelId (Unambiguous sel_name lbl)
; tcFunApp m_herald fun (L loc tc_fun) fun_ty args res_ty }
tcApp m_herald fun@(L loc (HsVar _ (L _ fun_id))) args res_ty
tcApp _m_herald (L loc (HsVar _ (L _ fun_id))) args res_ty
-- Special typing rule for tagToEnum#
| fun_id `hasKey` tagToEnumKey
, n_val_args == 1
= tcTagToEnum loc fun_id args res_ty
-- Special typing rule for 'seq'
-- In the saturated case, behave as if seq had type
-- forall a (b::TYPE r). a -> b -> b
-- for some type r. See Note [Typing rule for seq]
| fun_id `hasKey` seqIdKey
, n_val_args == 2
= do { rep <- newFlexiTyVarTy runtimeRepTy
; let [alpha, beta] = mkTemplateTyVars [liftedTypeKind, tYPE rep]
seq_ty = mkSpecForAllTys [alpha,beta]
(mkTyVarTy alpha `mkVisFunTy` mkTyVarTy beta `mkVisFunTy` mkTyVarTy beta)
seq_fun = L loc (HsVar noExtField (L loc seqId))
-- seq_ty = forall (a:*) (b:TYPE r). a -> b -> b
-- where 'r' is a meta type variable
; tcFunApp m_herald fun seq_fun seq_ty args res_ty }
where
n_val_args = count isHsValArg args
......
......@@ -2,7 +2,7 @@
-- This test checks that the magic treatment of RULES
-- for 'seq' works right.
--
-- See Note [RULES for seq] in MkId for more details
-- See Note [User-defined RULES for seq] in MkId for more details
module Main where
......
......@@ -12,10 +12,6 @@ T13050.hs:4:9: warning: [-Wtyped-holes (in -Wdefault)]
f :: Int -> Int -> Int (bound at T13050.hs:4:1)
g :: Int -> Int -> Int (bound at T13050.hs:5:1)
q :: Int -> Int -> Int (bound at T13050.hs:6:1)
seq :: forall a b. a -> b -> b
with seq @Int @Int
(imported from ‘Prelude’ at T13050.hs:1:8-17
(and originally defined in ‘GHC.Prim’))
(-) :: forall a. Num a => a -> a -> a
with (-) @Int
(imported from ‘Prelude’ at T13050.hs:1:8-17
......@@ -76,6 +72,10 @@ T13050.hs:4:9: warning: [-Wtyped-holes (in -Wdefault)]
with min @Int
(imported from ‘Prelude’ at T13050.hs:1:8-17
(and originally defined in ‘GHC.Classes’))
seq :: forall a b. a -> b -> b
with seq @Int @Int
(imported from ‘Prelude’ at T13050.hs:1:8-17
(and originally defined in ‘GHC.Prim’))
return :: forall (m :: * -> *) a. Monad m => a -> m a
with return @((->) Int) @Int
(imported from ‘Prelude’ at T13050.hs:1:8-17
......@@ -98,10 +98,6 @@ T13050.hs:5:11: warning: [-Wtyped-holes (in -Wdefault)]
g :: Int -> Int -> Int (bound at T13050.hs:5:1)
f :: Int -> Int -> Int (defined at T13050.hs:4:1)
q :: Int -> Int -> Int (bound at T13050.hs:6:1)
seq :: forall a b. a -> b -> b
with seq @Int @Int
(imported from ‘Prelude’ at T13050.hs:1:8-17
(and originally defined in ‘GHC.Prim’))
(-) :: forall a. Num a => a -> a -> a
with (-) @Int
(imported from ‘Prelude’ at T13050.hs:1:8-17
......@@ -162,6 +158,10 @@ T13050.hs:5:11: warning: [-Wtyped-holes (in -Wdefault)]
with min @Int
(imported from ‘Prelude’ at T13050.hs:1:8-17
(and originally defined in ‘GHC.Classes’))
seq :: forall a b. a -> b -> b
with seq @Int @Int
(imported from ‘Prelude’ at T13050.hs:1:8-17
(and originally defined in ‘GHC.Prim’))
return :: forall (m :: * -> *) a. Monad m => a -> m a
with return @((->) Int) @Int
(imported from ‘Prelude’ at T13050.hs:1:8-17
......@@ -185,10 +185,6 @@ T13050.hs:6:11: warning: [-Wtyped-holes (in -Wdefault)]
q :: Int -> Int -> Int (bound at T13050.hs:6:1)
f :: Int -> Int -> Int (defined at T13050.hs:4:1)
g :: Int -> Int -> Int (defined at T13050.hs:5:1)
seq :: forall a b. a -> b -> b
with seq @Int @Int
(imported from ‘Prelude’ at T13050.hs:1:8-17
(and originally defined in ‘GHC.Prim’))
(-) :: forall a. Num a => a -> a -> a
with (-) @Int
(imported from ‘Prelude’ at T13050.hs:1:8-17
......@@ -249,6 +245,10 @@ T13050.hs:6:11: warning: [-Wtyped-holes (in -Wdefault)]
with min @Int
(imported from ‘Prelude’ at T13050.hs:1:8-17
(and originally defined in ‘GHC.Classes’))
seq :: forall a b. a -> b -> b
with seq @Int @Int
(imported from ‘Prelude’ at T13050.hs:1:8-17
(and originally defined in ‘GHC.Prim’))
return :: forall (m :: * -> *) a. Monad m => a -> m a
with return @((->) Int) @Int
(imported from ‘Prelude’ at T13050.hs:1:8-17
......
......@@ -13,10 +13,6 @@ T14590.hs:4:13: warning: [-Wtyped-holes (in -Wdefault)]
f2 :: Int -> Int -> Int (bound at T14590.hs:5:1)
f3 :: Int -> Int -> Int (bound at T14590.hs:6:1)
f4 :: Int -> Int -> Int (bound at T14590.hs:7:1)
seq :: forall a b. a -> b -> b
with seq @Int @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
(and originally defined in ‘GHC.Prim’))
(-) :: forall a. Num a => a -> a -> a
with (-) @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
......@@ -77,6 +73,10 @@ T14590.hs:4:13: warning: [-Wtyped-holes (in -Wdefault)]
with min @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
(and originally defined in ‘GHC.Classes’))
seq :: forall a b. a -> b -> b
with seq @Int @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
(and originally defined in ‘GHC.Prim’))
return :: forall (m :: * -> *) a. Monad m => a -> m a
with return @((->) Int) @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
......@@ -101,10 +101,6 @@ T14590.hs:5:13: warning: [-Wtyped-holes (in -Wdefault)]
f1 :: Int -> Int -> Int (defined at T14590.hs:4:1)
f3 :: Int -> Int -> Int (bound at T14590.hs:6:1)
f4 :: Int -> Int -> Int (bound at T14590.hs:7:1)
seq :: forall a b. a -> b -> b
with seq @Int @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
(and originally defined in ‘GHC.Prim’))
(-) :: forall a. Num a => a -> a -> a
with (-) @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
......@@ -165,6 +161,10 @@ T14590.hs:5:13: warning: [-Wtyped-holes (in -Wdefault)]
with min @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
(and originally defined in ‘GHC.Classes’))
seq :: forall a b. a -> b -> b
with seq @Int @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
(and originally defined in ‘GHC.Prim’))
return :: forall (m :: * -> *) a. Monad m => a -> m a
with return @((->) Int) @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
......@@ -188,10 +188,6 @@ T14590.hs:6:11: warning: [-Wtyped-holes (in -Wdefault)]
f1 :: Int -> Int -> Int (defined at T14590.hs:4:1)
f2 :: Int -> Int -> Int (defined at T14590.hs:5:1)
f4 :: Int -> Int -> Int (bound at T14590.hs:7:1)
seq :: forall a b. a -> b -> b
with seq @Int @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
(and originally defined in ‘GHC.Prim’))
(-) :: forall a. Num a => a -> a -> a
with (-) @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
......@@ -252,6 +248,10 @@ T14590.hs:6:11: warning: [-Wtyped-holes (in -Wdefault)]
with min @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
(and originally defined in ‘GHC.Classes’))
seq :: forall a b. a -> b -> b
with seq @Int @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
(and originally defined in ‘GHC.Prim’))
return :: forall (m :: * -> *) a. Monad m => a -> m a
with return @((->) Int) @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
......@@ -276,10 +276,6 @@ T14590.hs:7:11: warning: [-Wtyped-holes (in -Wdefault)]
f1 :: Int -> Int -> Int (defined at T14590.hs:4:1)
f2 :: Int -> Int -> Int (defined at T14590.hs:5:1)
f3 :: Int -> Int -> Int (defined at T14590.hs:6:1)
seq :: forall a b. a -> b -> b
with seq @Int @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
(and originally defined in ‘GHC.Prim’))
(-) :: forall a. Num a => a -> a -> a
with (-) @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
......@@ -340,6 +336,10 @@ T14590.hs:7:11: warning: [-Wtyped-holes (in -Wdefault)]
with min @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
(and originally defined in ‘GHC.Classes’))
seq :: forall a b. a -> b -> b
with seq @Int @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
(and originally defined in ‘GHC.Prim’))
return :: forall (m :: * -> *) a. Monad m => a -> m a
with return @((->) Int) @Int
(imported from ‘Prelude’ at T14590.hs:1:8-13
......
......@@ -108,10 +108,10 @@ abstract_refinement_hole_fits.hs:4:5: warning: [-Wtyped-holes (in -Wdefault)]
where fst :: forall a b. (a, b) -> a
snd (_ :: (a0, [Integer] -> Integer))
where snd :: forall a b. (a, b) -> b
seq (_ :: a13) (_ :: [Integer] -> Integer)
where seq :: forall a b. a -> b -> b
const (_ :: [Integer] -> Integer) (_ :: b6)
where const :: forall a b. a -> b -> a
seq (_ :: a13) (_ :: [Integer] -> Integer)
where seq :: forall a b. a -> b -> b
($) (_ :: a5 -> [Integer] -> Integer) (_ :: a5)
where ($) :: forall a b. (a -> b) -> a -> b
return (_ :: [Integer] -> Integer) (_ :: t1)
......@@ -228,10 +228,10 @@ abstract_refinement_hole_fits.hs:7:5: warning: [-Wtyped-holes (in -Wdefault)]
where fst :: forall a b. (a, b) -> a
snd (_ :: (a0, Integer -> [Integer] -> Integer))
where snd :: forall a b. (a, b) -> b
seq (_ :: a13) (_ :: Integer -> [Integer] -> Integer)
where seq :: forall a b. a -> b -> b
const (_ :: Integer -> [Integer] -> Integer) (_ :: b6)
where const :: forall a b. a -> b -> a
seq (_ :: a13) (_ :: Integer -> [Integer] -> Integer)
where seq :: forall a b. a -> b -> b
($) (_ :: a5 -> Integer -> [Integer] -> Integer) (_ :: a5)
where ($) :: forall a b. (a -> b) -> a -> b
return (_ :: Integer -> [Integer] -> Integer) (_ :: t1)
......
......@@ -164,7 +164,6 @@ holes.hs:11:15: warning: [-Wtyped-holes (in -Wdefault)]
quot :: forall a. Integral a => a -> a -> a
quotRem :: forall a. Integral a => a -> a -> (a, a)
rem :: forall a. Integral a => a -> a -> a
seq :: forall a b. a -> b -> b
zip :: forall a b. [a] -> [b] -> [(a, b)]
fst :: forall a b. (a, b) -> a
snd :: forall a b. (a, b) -> b
......@@ -185,6 +184,7 @@ holes.hs:11:15: warning: [-Wtyped-holes (in -Wdefault)]
a -> (b, a)
round :: forall a b. (RealFrac a, Integral b) => a -> b
truncate :: forall a b. (RealFrac a, Integral b) => a -> b
seq :: forall a b. a -> b -> b
($) :: forall a b. (a -> b) -> a -> b
either :: forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
curry :: forall a b c. ((a, b) -> c) -> a -> b -> c
......
......@@ -167,7 +167,6 @@ holes3.hs:11:15: error:
quot :: forall a. Integral a => a -> a -> a
quotRem :: forall a. Integral a => a -> a -> (a, a)
rem :: forall a. Integral a => a -> a -> a
seq :: forall a b. a -> b -> b
zip :: forall a b. [a] -> [b] -> [(a, b)]
fst :: forall a b. (a, b) -> a
snd :: forall a b. (a, b) -> b
......@@ -188,6 +187,7 @@ holes3.hs:11:15: error:
a -> (b, a)
round :: forall a b. (RealFrac a, Integral b) => a -> b
truncate :: forall a b. (RealFrac a, Integral b) => a -> b
seq :: forall a b. a -> b -> b
($) :: forall a b. (a -> b) -> a -> b
either :: forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
curry :: forall a b c. ((a, b) -> c) -> a -> b -> c
......
PluralS.hs:15:17: warning: [-Wtype-defaults (in -Wall)]
• Defaulting the following constraint to type ‘Integer’
Num t0 arising from the literal ‘123’
Num a0 arising from the literal ‘123’
• In the first argument of ‘seq’, namely ‘123’
In the expression: 123 `seq` ()
In an equation for ‘defaultingNum’: defaultingNum = 123 `seq` ()
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment