[1 of 2] Compiling ValidHoleFits    ( ValidHoleFits.hs, ValidHoleFits.o )
[2 of 2] Compiling Foo              ( valid_hole_fits.hs, valid_hole_fits.o )

valid_hole_fits.hs:9:6: warning: [-Wdeferred-out-of-scope-variables (in -Wdefault)]
    • Variable not in scope: putStrLn :: String -> IO ()
    • Perhaps you meant one of these:
        ‘System.IO.putStrLn’ (imported from System.IO),
        ‘System.IO.putStr’ (imported from System.IO)
      Perhaps you want to remove ‘putStrLn’ from the explicit hiding list
      in the import of ‘Prelude’ (valid_hole_fits.hs:3:1-40).

valid_hole_fits.hs:17:17: warning: [-Wtyped-holes (in -Wdefault)]
    • Found hole: _ :: Int -> IO Int
    • In a stmt of a 'do' block: y <- _ x
      In the expression:
        do x <- a 0
           y <- _ x
           return y
      In an equation for ‘c’:
          c _
            = do x <- a 0
                 y <- _ x
                 return y
    • Relevant bindings include
        x :: Int (bound at valid_hole_fits.hs:16:12)
        c :: Int -> IO Int (bound at valid_hole_fits.hs:16:1)
      Valid hole fits include
        c :: Int -> IO Int (bound at valid_hole_fits.hs:16:1)
        a :: Int -> IO Int (bound at valid_hole_fits.hs:12:1)
        b :: Int -> IO Int (bound at valid_hole_fits.hs:14:1)
        return :: forall (m :: * -> *) a. Monad m => a -> m a
          with return @IO @Int
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Base’))
        pure :: forall (f :: * -> *) a. Applicative f => a -> f a
          with pure @IO @Int
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Base’))

valid_hole_fits.hs:21:8: warning: [-Wtyped-holes (in -Wdefault)]
    • Found hole: _ :: [Maybe a] -> [a]
      Where: ‘a’ is a rigid type variable bound by
               the type signature for:
                 test :: forall a. [Maybe a] -> [a]
               at valid_hole_fits.hs:20:1-24
    • In an equation for ‘test’: test = _
    • Relevant bindings include
        test :: [Maybe a] -> [a] (bound at valid_hole_fits.hs:21:1)
      Valid hole fits include
        test :: [Maybe a] -> [a] (bound at valid_hole_fits.hs:21:1)
        catMaybes :: forall a. [Maybe a] -> [a]
          with catMaybes @a
          (imported from ‘Data.Maybe’ at valid_hole_fits.hs:5:1-17)
        mempty :: forall a. Monoid a => a
          with mempty @([Maybe a] -> [a])
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Base’))

valid_hole_fits.hs:24:9: warning: [-Wtyped-holes (in -Wdefault)]
    • Found hole: _ :: Integer -> ValidHoleFits.Moo
    • In an equation for ‘test2’: test2 = _
    • Relevant bindings include
        test2 :: Integer -> ValidHoleFits.Moo
          (bound at valid_hole_fits.hs:24:1)
      Valid hole fits include
        test2 :: Integer -> ValidHoleFits.Moo
          (bound at valid_hole_fits.hs:24:1)
        ValidHoleFits.Moo :: Integer -> ValidHoleFits.Moo
          (imported qualified from ‘ValidHoleFits’ at valid_hole_fits.hs:6:1-30
           (and originally defined at ValidHoleFits.hs:4:12-22))

valid_hole_fits.hs:27:5: warning: [-Wtyped-holes (in -Wdefault)]
    • Found hole: _ :: t0 -> Maybe Integer
      Where: ‘t0’ is an ambiguous type variable
    • In the expression: _ 2
      In an equation for ‘k’: k = _ 2
    • Relevant bindings include
        k :: Maybe Integer (bound at valid_hole_fits.hs:27:1)
      Valid hole fits include
        Just :: forall a. a -> Maybe a
          with Just @Integer
          (imported from ‘Data.Maybe’ at valid_hole_fits.hs:5:1-17
           (and originally defined in ‘GHC.Maybe’))
        return :: forall (m :: * -> *) a. Monad m => a -> m a
          with return @Maybe @Integer
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Base’))
        pure :: forall (f :: * -> *) a. Applicative f => a -> f a
          with pure @Maybe @Integer
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Base’))

valid_hole_fits.hs:30:10: warning: [-Wtyped-holes (in -Wdefault)]
    • Found hole: _ :: a1
      Where: ‘a1’ is an ambiguous type variable
    • In the first argument of ‘show’, namely ‘_’
      In the expression: show _
      In an equation for ‘f’: f = show _
    • Relevant bindings include
        f :: String (bound at valid_hole_fits.hs:30:1)
      Valid hole fits include
        f :: String (bound at valid_hole_fits.hs:30:1)
        k :: Maybe Integer (defined at valid_hole_fits.hs:27:1)
        h :: String (bound at valid_hole_fits.hs:34:1)
        otherwise :: Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Base’))
        False :: Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Types’))
        True :: Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Types’))
        LT :: Ordering
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Types’))
        EQ :: Ordering
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Types’))
        GT :: Ordering
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Types’))
        () :: () (bound at <wired into compiler>)
        pi :: forall a. Floating a => a
          with pi @Double
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Float’))

valid_hole_fits.hs:34:11: warning: [-Wtyped-holes (in -Wdefault)]
    • Found hole: _ :: Bool -> a0
      Where: ‘a0’ is an ambiguous type variable
    • In the first argument of ‘show’, namely ‘(_ (_ :: Bool))’
      In the expression: show (_ (_ :: Bool))
      In an equation for ‘h’: h = show (_ (_ :: Bool))
    • Relevant bindings include
        h :: String (bound at valid_hole_fits.hs:34:1)
      Valid hole fits include
        not :: Bool -> Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Classes’))
        enumFrom :: forall a. Enum a => a -> [a]
          with enumFrom @Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Enum’))
        Just :: forall a. a -> Maybe a
          with Just @Bool
          (imported from ‘Data.Maybe’ at valid_hole_fits.hs:5:1-17
           (and originally defined in ‘GHC.Maybe’))
        Solo :: forall a. a -> Solo a
          with Solo @Bool
          (bound at <wired into compiler>)
        id :: forall a. a -> a
          with id @Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Base’))
        repeat :: forall a. a -> [a]
          with repeat @Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.List’))
        fromEnum :: forall a. Enum a => a -> Int
          with fromEnum @Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Enum’))
        pred :: forall a. Enum a => a -> a
          with pred @Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Enum’))
        succ :: forall a. Enum a => a -> a
          with succ @Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Enum’))
        show :: forall a. Show a => a -> String
          with show @Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Show’))

valid_hole_fits.hs:34:14: warning: [-Wtyped-holes (in -Wdefault)]
    • Found hole: _ :: Bool
    • In the first argument of ‘_’, namely ‘(_ :: Bool)’
      In the first argument of ‘show’, namely ‘(_ (_ :: Bool))’
      In the expression: show (_ (_ :: Bool))
    • Relevant bindings include
        h :: String (bound at valid_hole_fits.hs:34:1)
      Valid hole fits include
        otherwise :: Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Base’))
        False :: Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Types’))
        True :: Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Types’))
        maxBound :: forall a. Bounded a => a
          with maxBound @Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Enum’))
        minBound :: forall a. Bounded a => a
          with minBound @Bool
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Enum’))

valid_hole_fits.hs:38:10: warning: [-Wtyped-holes (in -Wdefault)]
    • Found hole: _ :: a -> [a] -> [a]
      Where: ‘a’ is a rigid type variable bound by
               the type signature for:
                 myCons :: forall a. a -> [a] -> [a]
               at valid_hole_fits.hs:37:1-25
    • In an equation for ‘myCons’: myCons = _
    • Relevant bindings include
        myCons :: a -> [a] -> [a] (bound at valid_hole_fits.hs:38:1)
      Valid hole fits include
        myCons :: a -> [a] -> [a] (bound at valid_hole_fits.hs:38:1)
        (:) :: forall a. a -> [a] -> [a]
          with (:) @a
          (bound at <wired into compiler>)
        (<$) :: forall (f :: * -> *) a b. Functor f => a -> f b -> f a
          with (<$) @[] @a @a
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Base’))
        seq :: forall a b. a -> b -> b
          with seq @a @[a]
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Prim’))
        mempty :: forall a. Monoid a => a
          with mempty @(a -> [a] -> [a])
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Base’))

valid_hole_fits.hs:41:8: warning: [-Wtyped-holes (in -Wdefault)]
    • Found hole: _ :: String -> IO ()
    • In the expression: _ "hello, world"
      In an equation for ‘main’: main = _ "hello, world"
    • Relevant bindings include
        main :: IO () (bound at valid_hole_fits.hs:41:1)
      Valid hole fits include
        ps :: String -> IO () (defined at valid_hole_fits.hs:9:1)
        System.IO.putStr :: String -> IO ()
          (imported qualified from ‘System.IO’ at valid_hole_fits.hs:4:29-34)
        System.IO.putStrLn :: String -> IO ()
          (imported qualified from ‘System.IO’ at valid_hole_fits.hs:4:37-44)
        readIO :: forall a. Read a => String -> IO a
          with readIO @()
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘System.IO’))
        print :: forall a. Show a => a -> IO ()
          with print @String
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘System.IO’))
        fail :: forall (m :: * -> *) a. MonadFail m => String -> m a
          with fail @IO @()
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘Control.Monad.Fail’))
        mempty :: forall a. Monoid a => a
          with mempty @(String -> IO ())
          (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
           (and originally defined in ‘GHC.Base’))