Commit 83c60bb7 authored by Simon Peyton Jones's avatar Simon Peyton Jones
Browse files

Accept output

parent 8bae12e2
<interactive>:1:1:
Ambiguous type variable `t' in the constraint:
`Show t' arising from a use of `print' at <interactive>:1:1
(Show t) arising from a use of `print'
Cannot resolve unknown runtime types: t
Use :print or :force to determine these types
In a stmt of an interactive GHCi command: print it
<interactive>:1:1:
No instance for (Show (t -> a))
arising from a use of `print' at <interactive>:1:1
arising from a use of `print'
Possible fix: add an instance declaration for (Show (t -> a))
In a stmt of an interactive GHCi command: print it
<interactive>:1:1:
Ambiguous type variable `a' in the constraint:
`Show a' arising from a use of `print' at <interactive>:1:1-3
(Show a) arising from a use of `print'
Cannot resolve unknown runtime types: a
Use :print or :force to determine these types
In a stmt of an interactive GHCi command: print it
<interactive>:1:1:
Ambiguous type variable `a' in the constraint:
`Show a' arising from a use of `print' at <interactive>:1:1
(Show a) arising from a use of `print'
Cannot resolve unknown runtime types: a
Use :print or :force to determine these types
In a stmt of an interactive GHCi command: print it
<interactive>:1:1:
Ambiguous type variable `t1' in the constraint:
`Show t1' arising from a use of `print' at <interactive>:1:1-3
(Show t1) arising from a use of `print'
Cannot resolve unknown runtime types: t1
Use :print or :force to determine these types
In a stmt of an interactive GHCi command: print it
($$$) :: [b -> b1] -> [b] -> [b1]
-- Defined at <interactive>:1:8-10
($$$) :: [a -> b] -> [a] -> [b] -- Defined at <interactive>:1:8-10
-- test :browse! functionality
:browse! *T
-- defined locally
T.length :: T.Integer
class N a
class S a
class C a b where
c1 :: N b => a -> b
c2 :: (N b, S b) => a -> b
c3 :: a1 -> b
c4 :: a1 -> b
c1 :: (C a b, N b) => a -> b
c2 :: (C a b, N b, S b) => a -> b
c3 :: C a b => a1 -> b
c4 :: C a b => a1 -> b
-- imported via Control.Monad
class Monad m => MonadPlus m where
mzero :: m a
mplus :: m a -> m a -> m a
mplus :: MonadPlus m => m a -> m a -> m a
mzero :: MonadPlus m => m a
-- imported via Control.Monad, Prelude
(>>) :: Monad m => m a -> m b -> m b
(>>=) :: Monad m => m a -> (a -> m b) -> m b
fail :: Monad m => GHC.Base.String -> m a
return :: Monad m => a -> m a
-- imported via Control.Monad, Prelude, T
class Monad m where
(>>=) :: m a -> (a -> m b) -> m b
(>>) :: m a -> m b -> m b
return :: a -> m a
fail :: GHC.Base.String -> m a
-- imported via Data.Maybe
catMaybes :: [Maybe a] -> [a]
fromJust :: Maybe a -> a
fromMaybe :: a -> Maybe a -> a
isJust :: Maybe a -> GHC.Bool.Bool
isNothing :: Maybe a -> GHC.Bool.Bool
listToMaybe :: [a] -> Maybe a
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
maybe :: b -> (a -> b) -> Maybe a -> b
maybeToList :: Maybe a -> [a]
-- imported via Data.Maybe, Prelude
Just :: a -> Maybe a
data Maybe a = Nothing | Just a
Nothing :: Maybe a
-- imported via Prelude
(+) :: GHC.Num.Num a => a -> a -> a
(=<<) :: Monad m => (a -> m b) -> m a -> m b
class Eq a where
(GHC.Classes.==) :: a -> a -> GHC.Bool.Bool
(GHC.Classes./=) :: a -> a -> GHC.Bool.Bool
-- imported via Prelude, T
Prelude.length :: [a] -> GHC.Types.Int
-- imported via T
data T.Integer
= integer-gmp:GHC.Integer.Type.S# GHC.Prim.Int#
| integer-gmp:GHC.Integer.Type.J# GHC.Prim.Int# GHC.Prim.ByteArray#
T.length :: Data.ByteString.Internal.ByteString -> GHC.Types.Int
:browse! T
-- defined locally
T.length :: T.Integer
class N a
class S a
class C a b where
c1 :: N b => a -> b
c2 :: (N b, S b) => a -> b
c3 :: a1 -> b
c4 :: a1 -> b
c1 :: (C a b, N b) => a -> b
c2 :: (C a b, N b, S b) => a -> b
c3 :: C a b => a1 -> b
c4 :: C a b => a1 -> b
:browse! T -- with -fglasgow-exts
-- defined locally
T.length :: T.Integer
class N a
class S a
class C a b where
c1 :: N b => a -> b
c2 :: (N b, S b) => a -> b
c3 :: forall a1. a1 -> b
c4 :: forall a1. a1 -> b
c1 :: forall a b. (C a b, N b) => a -> b
c2 :: forall a b. (C a b, N b, S b) => a -> b
c3 :: forall a b. C a b => forall a1. a1 -> b
c4 :: forall a b. C a b => forall a1. a1 -> b
-- test :browse! <target> relative to different contexts
:browse! C -- from *C>
-- defined locally
g :: forall a. Num a => a -> a
h :: forall a. Integral a => a -> a
-- imported via D
f :: forall a. Num a => a -> a
:browse! C -- from *B>, after :add B
-- imported via C
g :: forall a. Num a => a -> a
h :: forall a. Integral a => a -> a
f :: forall a. Num a => a -> a
:browse! C -- from *C>, after :m *C
-- defined locally
g :: forall a. Num a => a -> a
h :: forall a. Integral a => a -> a
-- imported via D
f :: forall a. Num a => a -> a
:browse! C -- from *D>, after :m *D
-- not currently imported
C.g :: forall a. Num a => a -> a
C.h :: forall a. Integral a => a -> a
-- defined locally
f :: forall a. Num a => a -> a
-- test :browse! functionality
:browse! *T
-- defined locally
T.length :: T.Integer
class N a
class S a
class C a b where
c1 :: N b => a -> b
c2 :: (N b, S b) => a -> b
c3 :: a1 -> b
c4 :: a1 -> b
c1 :: (C a b, N b) => a -> b
c2 :: (C a b, N b, S b) => a -> b
c3 :: C a b => forall a1. a1 -> b
c4 :: C a b => forall a1. a1 -> b
-- imported via Control.Monad
class Monad m => MonadPlus m where
mzero :: m a
mplus :: m a -> m a -> m a
mplus :: MonadPlus m => forall a. m a -> m a -> m a
mzero :: MonadPlus m => forall a. m a
-- imported via Control.Monad, Prelude
(>>) :: Monad m => forall a b. m a -> m b -> m b
(>>=) :: Monad m => forall a b. m a -> (a -> m b) -> m b
fail :: Monad m => forall a. GHC.Base.String -> m a
return :: Monad m => forall a. a -> m a
-- imported via Control.Monad, Prelude, T
class Monad m where
(>>=) :: m a -> (a -> m b) -> m b
(>>) :: m a -> m b -> m b
return :: a -> m a
fail :: GHC.Base.String -> m a
-- imported via Data.Maybe
catMaybes :: [Maybe a] -> [a]
fromJust :: Maybe a -> a
fromMaybe :: a -> Maybe a -> a
isJust :: Maybe a -> GHC.Bool.Bool
isNothing :: Maybe a -> GHC.Bool.Bool
listToMaybe :: [a] -> Maybe a
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
maybe :: b -> (a -> b) -> Maybe a -> b
maybeToList :: Maybe a -> [a]
-- imported via Data.Maybe, Prelude
Just :: a -> Maybe a
data Maybe a = Nothing | Just a
Nothing :: Maybe a
-- imported via Prelude
(+) :: GHC.Num.Num a => a -> a -> a
(=<<) :: Monad m => (a -> m b) -> m a -> m b
class Eq a where
(GHC.Classes.==) :: a -> a -> GHC.Bool.Bool
(GHC.Classes./=) :: a -> a -> GHC.Bool.Bool
-- imported via Prelude, T
Prelude.length :: [a] -> GHC.Types.Int
-- imported via T
data T.Integer
= integer-gmp:GHC.Integer.Type.S# GHC.Prim.Int#
| integer-gmp:GHC.Integer.Type.J# GHC.Prim.Int# GHC.Prim.ByteArray#
T.length :: Data.ByteString.Internal.ByteString -> GHC.Types.Int
:browse! T
-- defined locally
T.length :: T.Integer
class N a
class S a
class C a b where
c1 :: N b => a -> b
c2 :: (N b, S b) => a -> b
c3 :: a1 -> b
c4 :: a1 -> b
c1 :: (C a b, N b) => a -> b
c2 :: (C a b, N b, S b) => a -> b
c3 :: C a b => forall a1. a1 -> b
c4 :: C a b => forall a1. a1 -> b
:browse! T -- with -fglasgow-exts
-- defined locally
T.length :: T.Integer
class N a
class S a
class C a b where
c1 :: N b => a -> b
c2 :: (N b, S b) => a -> b
c3 :: forall a1. a1 -> b
c4 :: forall a1. a1 -> b
c1 :: forall a b. (C a b, N b) => a -> b
c2 :: forall a b. (C a b, N b, S b) => a -> b
c3 :: forall a b. C a b => forall a1. a1 -> b
c4 :: forall a b. C a b => forall a1. a1 -> b
-- test :browse! <target> relative to different contexts
:browse! C -- from *C>
-- defined locally
g :: forall a. Num a => a -> a
h :: forall a. Integral a => a -> a
-- imported via D
f :: forall a. Num a => a -> a
:browse! C -- from *B>, after :add B
-- imported via C
g :: forall a. Num a => a -> a
h :: forall a. Integral a => a -> a
f :: forall a. Num a => a -> a
:browse! C -- from *C>, after :m *C
-- defined locally
g :: forall a. Num a => a -> a
h :: forall a. Integral a => a -> a
-- imported via D
f :: forall a. Num a => a -> a
:browse! C -- from *D>, after :m *D
-- not currently imported
C.g :: forall a. Num a => a -> a
C.h :: forall a. Integral a => a -> a
-- defined locally
f :: forall a. Num a => a -> a
==================== Tidy Core ====================
Rec {
xs :: GHC.Prim.Int# -> ()
T3772.foo_xs [Occ=LoopBreaker] :: GHC.Prim.Int# -> ()
[GblId, Arity=1, Caf=NoCafRefs, Str=DmdType L]
xs =
T3772.foo_xs =
\ (m :: GHC.Prim.Int#) ->
case GHC.Prim.<=# m 1 of _ {
GHC.Bool.False -> xs (GHC.Prim.-# m 1);
GHC.Bool.False -> T3772.foo_xs (GHC.Prim.-# m 1);
GHC.Bool.True -> GHC.Unit.()
}
end Rec }
T3772.foo [InlPrag=NOINLINE (sat-args=1)] :: GHC.Types.Int -> ()
[GblId, Arity=1, Caf=NoCafRefs, Str=DmdType U(L)]
T3772.foo =
\ (n :: GHC.Types.Int) ->
case n of _ { GHC.Types.I# n# ->
case GHC.Prim.<=# n# 0 of _ {
GHC.Bool.False -> xs n#; GHC.Bool.True -> GHC.Unit.()
}
T3772.$wfoo :: GHC.Prim.Int# -> ()
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=DmdType L,
Unf=Unf{Src=<vanilla>, TopLvl=True, Arity=1, Value=True,
ConLike=True, Cheap=True, Expandable=True,
Guidance=IF_ARGS [0] 5 1}]
T3772.$wfoo =
\ (ww :: GHC.Prim.Int#) ->
case GHC.Prim.<=# ww 0 of _ {
GHC.Bool.False -> T3772.foo_xs ww; GHC.Bool.True -> GHC.Unit.()
}
T3772.foo [InlPrag=INLINE[0]] :: GHC.Types.Int -> ()
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=DmdType U(L),
Unf=Unf{Src=Worker=T3772.$wfoo, TopLvl=True, Arity=1, Value=True,
ConLike=True, Cheap=True, Expandable=True,
Guidance=ALWAYS_IF(unsat_ok=True,boring_ok=False)
Tmpl= \ (w [Occ=Once!] :: GHC.Types.Int) ->
case w of _ { GHC.Types.I# ww [Occ=Once] -> T3772.$wfoo ww }}]
T3772.foo =
\ (w :: GHC.Types.Int) ->
case w of _ { GHC.Types.I# ww -> T3772.$wfoo ww }
......@@ -23,10 +23,10 @@ Total ticks: 11
1 f
1 m
1 a
1 b
1 m
1 a
1 a
1 m
1 a
8 SimplifierDone
8
......
T3899.hs:6:7:
T3899.hs:6:7-19: Splicing expression
nestedTuple 3 ======> \ (Cons x (Cons x (Cons x Nil))) -> (x, x, x)
In the expression: $(nestedTuple 3)
In an equation for `f': f = $(nestedTuple 3)
T3899.hs:6:7-19: Splicing expression
nestedTuple 3 ======> \ (Cons x (Cons x (Cons x Nil))) -> (x, x, x)
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