Cannot compile phase 2 after recent Roles patch

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
3 messages Options
Reply | Threaded
Open this post in threaded view
|

Cannot compile phase 2 after recent Roles patch

Dr. ERDI Gergo
Hi,

I cannot compile GHC starting from e8aa8ccb 'Implement "roles" into GHC'.
The error message I get is:

>>>>>>>>>>>>>>>>>>>>>>>>>
*** Core Lint errors : in result of Desugar (after optimization) ***
{-# LINE 290 "libraries/terminfo/System/Console/Terminfo/Base.hs #-}:
Warning:
     [RHS of System.Console.Terminfo.Base.mkCallback ::
     System.Console.Terminfo.Base.CharOutput ->
         GHC.Types.IO (GHC.Ptr.FunPtr System.Console.Terminfo.Base.CharOutput)]

     Role incompatibility: expected P, got R
     in Sym Foreign.C.Types.NTCo:CInt[0]
        -> (GHC.Types.IO (Sym Foreign.C.Types.NTCo:CInt[0]))_R
<<<<<<<<<<<<<<<<<<<<<<<<

followed by a dump of Core (see attached).

--

   .--= ULLA! =-----------------.
    \     http://gergo.erdi.hu   \
     `---= gergo at erdi.hu =-------'
chown -R us.us yourbase (#gnome)
-------------- next part --------------
===--- building phase 0
make -r --no-print-directory -f ghc.mk phase=0 phase_0_builds
make[1]: Nothing to be done for `phase_0_builds'.
===--- building phase 1
make -r --no-print-directory -f ghc.mk phase=1 phase_1_builds
===--- building final phase
make -r --no-print-directory -f ghc.mk phase=final all
"inplace/bin/ghc-stage1" -hisuf hi -osuf  o -hcsuf hc -static  -H64m -O -fasm    -package-name terminfo-0.3.2.5 -hide-all-packages -i -ilibraries/terminfo/. -ilibraries/terminfo/dist-install/build -ilibraries/terminfo/dist-install/build/autogen -Ilibraries/terminfo/dist-install/build -Ilibraries/terminfo/dist-install/build/autogen -Ilibraries/terminfo/.    -optP-include -optPlibraries/terminfo/dist-install/build/autogen/cabal_macros.h -package base-4.7.0.0 -Wall -XHaskell98 -XCPP -XForeignFunctionInterface -XDeriveDataTypeable -XEmptyDataDecls -XScopedTypeVariables -XFlexibleInstances -O -dcore-lint  -no-user-package-db -rtsopts      -odir libraries/terminfo/dist-install/build -hidir libraries/terminfo/dist-install/build -stubdir libraries/terminfo/dist-install/build  -dynamic-too -c libraries/terminfo/./System/Console/Terminfo/Base.hs -o libraries/terminfo/dist-install/build/System/Console/Terminfo/Base.o -dyno libraries/terminfo/dist-install/build/System/Console/Terminfo/Base.dyn_o
*** Core Lint errors : in result of Desugar (after optimization) ***
{-# LINE 290 "libraries/terminfo/System/Console/Terminfo/Base.hs #-}: Warning:
    [RHS of System.Console.Terminfo.Base.mkCallback :: System.Console.Terminfo.Base.CharOutput
                                                       -> GHC.Types.IO
                                                            (GHC.Ptr.FunPtr
                                                               System.Console.Terminfo.Base.CharOutput)]
    Role incompatibility: expected P, got R
    in Sym Foreign.C.Types.NTCo:CInt[0]
       -> (GHC.Types.IO (Sym Foreign.C.Types.NTCo:CInt[0]))_R
*** Offending Program ***
System.Console.Terminfo.Base.fromStr
  :: System.Console.Terminfo.Base.LinesAffected
     -> GHC.Base.String -> System.Console.Terminfo.Base.TermOutput
[LclId, Str=DmdType]
System.Console.Terminfo.Base.fromStr =
  \ (la_a1sF :: System.Console.Terminfo.Base.LinesAffected)
    (s_a1sG :: GHC.Base.String) ->
    System.Console.Terminfo.Base.TermOutput
      (GHC.Types.:
         @ System.Console.Terminfo.Base.TermOutputType
         (System.Console.Terminfo.Base.TOCmd la_a1sF s_a1sG))

System.Console.Terminfo.Base.<#>
  :: forall m_a145.
     Data.Monoid.Monoid m_a145 =>
     m_a145 -> m_a145 -> m_a145
[LclIdX, Str=DmdType]
System.Console.Terminfo.Base.<#> = Data.Monoid.mappend

System.Console.Terminfo.Base.termText
  :: GHC.Base.String -> System.Console.Terminfo.Base.TermOutput
[LclIdX, Str=DmdType]
System.Console.Terminfo.Base.termText =
  \ (str_a1lL :: GHC.Base.String) ->
    System.Console.Terminfo.Base.TermOutput
      (GHC.Types.:
         @ System.Console.Terminfo.Base.TermOutputType
         (System.Console.Terminfo.Base.TOStr str_a1lL))

Rec {
System.Console.Terminfo.Base.strHasPadding [Occ=LoopBreaker]
  :: GHC.Base.String -> GHC.Types.Bool
[LclId, Str=DmdType]
System.Console.Terminfo.Base.strHasPadding =
  \ (ds_d1Qy :: [GHC.Types.Char]) ->
    case ds_d1Qy of _ {
      [] -> GHC.Types.False;
      : ds_d1Qz ds_d1QA ->
        let {
          fail_d1QF :: GHC.Prim.State# GHC.Prim.RealWorld -> GHC.Types.Bool
          [LclId, Str=DmdType]
          fail_d1QF =
            \ _ -> System.Console.Terminfo.Base.strHasPadding ds_d1QA } in
        case ds_d1Qz of _ { GHC.Types.C# ds_d1QB ->
        case ds_d1QB of _ {
          __DEFAULT -> fail_d1QF GHC.Prim.realWorld#;
          '$' ->
            case ds_d1QA of _ {
              __DEFAULT -> fail_d1QF GHC.Prim.realWorld#;
              : ds_d1QC _ ->
                case ds_d1QC of _ { GHC.Types.C# ds_d1QE ->
                case ds_d1QE of _ {
                  __DEFAULT -> fail_d1QF GHC.Prim.realWorld#;
                  '<' -> GHC.Types.True
                }
                }
            }
        }
        }
    }
end Rec }

System.Console.Terminfo.Base.cur_term
  :: GHC.Ptr.Ptr (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
[LclId, Str=DmdType]
System.Console.Terminfo.Base.cur_term =
  GHC.Ptr.Ptr
    @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
    (__label "cur_term" (data))

System.Console.Terminfo.Base.del_curterm
  :: GHC.Ptr.FunPtr
       (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL
        -> GHC.Types.IO ())
[LclId, Str=DmdType]
System.Console.Terminfo.Base.del_curterm =
  GHC.Ptr.FunPtr
    @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL
       -> GHC.Types.IO ())
    (__label "del_curterm" (function))

System.Console.Terminfo.Base.mkCallback [InlPrag=[NEVER]]
  :: System.Console.Terminfo.Base.CharOutput
     -> GHC.Types.IO
          (GHC.Ptr.FunPtr System.Console.Terminfo.Base.CharOutput)
[LclId, Str=DmdType]
System.Console.Terminfo.Base.mkCallback =
  (\ (ds_d1Ry :: GHC.Int.Int32 -> GHC.Types.IO GHC.Int.Int32) ->
     GHC.Base.bindIO
       @ (GHC.Stable.StablePtr
            (GHC.Int.Int32 -> GHC.Types.IO GHC.Int.Int32))
       @ (GHC.Ptr.FunPtr (GHC.Int.Int32 -> GHC.Types.IO GHC.Int.Int32))
       (GHC.Stable.newStablePtr
          @ (GHC.Int.Int32 -> GHC.Types.IO GHC.Int.Int32) ds_d1Ry)
       (\ (ds_d1Sp
             :: GHC.Stable.StablePtr
                  (GHC.Int.Int32 -> GHC.Types.IO GHC.Int.Int32)) ->
          case ds_d1Sp of _ { GHC.Stable.StablePtr ds_d1Sw ->
          GHC.Types.IO
            @ (GHC.Ptr.FunPtr (GHC.Int.Int32 -> GHC.Types.IO GHC.Int.Int32))
            (\ (ds_d1Sz :: GHC.Prim.State# GHC.Prim.RealWorld) ->
               case {__pkg_ccall createAdjustor GHC.Prim.Int#
                            -> GHC.Prim.StablePtr#
                                 (GHC.Int.Int32 -> GHC.Types.IO GHC.Int.Int32)
                            -> GHC.Prim.Addr#
                            -> GHC.Prim.Addr#
                            -> GHC.Prim.State# GHC.Prim.RealWorld
                            -> (# GHC.Prim.State# GHC.Prim.RealWorld, GHC.Prim.Addr# #)}_d1SA
                      1
                      ds_d1Sw
                      (__label "SystemziConsoleziTerminfoziBase_d1Rx" (function))
                      "L"#
                      ds_d1Sz
               of _ { (# ds_d1Sy, ds_d1Sx #) ->
               (# ds_d1Sy,
                  GHC.Ptr.FunPtr
                    @ (GHC.Int.Int32 -> GHC.Types.IO GHC.Int.Int32) ds_d1Sx #)
               })
          }))
  `cast` ((Sym Foreign.C.Types.NTCo:CInt[0]
           -> (GHC.Types.IO (Sym Foreign.C.Types.NTCo:CInt[0]))_R)
          -> (GHC.Types.IO
                (GHC.Ptr.FunPtr
                   (Sym Foreign.C.Types.NTCo:CInt[0]
                    -> (GHC.Types.IO (Sym Foreign.C.Types.NTCo:CInt[0]))_R))_R)_R
          :: ((GHC.Int.Int32 -> GHC.Types.IO GHC.Int.Int32)
              -> GHC.Types.IO
                   (GHC.Ptr.FunPtr (GHC.Int.Int32 -> GHC.Types.IO GHC.Int.Int32)))
               ~#
             ((Foreign.C.Types.CInt -> GHC.Types.IO Foreign.C.Types.CInt)
              -> GHC.Types.IO
                   (GHC.Ptr.FunPtr
                      (Foreign.C.Types.CInt -> GHC.Types.IO Foreign.C.Types.CInt))))

System.Console.Terminfo.Base.set_curterm
  :: GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL
     -> GHC.Types.IO (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
[LclId,
 Str=DmdType,
 Unf=Unf{Src=InlineStable, TopLvl=True, Arity=1, Value=True,
         ConLike=True, WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)
         Tmpl= \ (ds_d1TL [Occ=Once!]
                    :: GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL) ->
                 case ds_d1TL of _ { GHC.Ptr.Ptr ds_d1TN [Occ=Once] ->
                 GHC.Types.IO
                   @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
                   (\ (ds_d1TQ [Occ=Once] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
                      case {__pkg_ccall_GC terminfo-0.3.2.5 set_curterm GHC.Prim.Addr#
                                             -> GHC.Prim.State# GHC.Prim.RealWorld
                                             -> (# GHC.Prim.State# GHC.Prim.RealWorld,
                                                   GHC.Prim.Addr# #)}_d1TR
                             ds_d1TN ds_d1TQ
                      of _ { (# ds_d1TP [Occ=Once], ds_d1TO [Occ=Once] #) ->
                      (# ds_d1TP,
                         GHC.Ptr.Ptr @ System.Console.Terminfo.Base.TERMINAL ds_d1TO #)
                      })
                 }}]
System.Console.Terminfo.Base.set_curterm =
  \ (ds_d1TL :: GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL) ->
    case ds_d1TL of _ { GHC.Ptr.Ptr ds_d1TN ->
    GHC.Types.IO
      @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
      (\ (ds_d1TQ :: GHC.Prim.State# GHC.Prim.RealWorld) ->
         case {__pkg_ccall_GC terminfo-0.3.2.5 set_curterm GHC.Prim.Addr#
                                             -> GHC.Prim.State# GHC.Prim.RealWorld
                                             -> (# GHC.Prim.State# GHC.Prim.RealWorld,
                                                   GHC.Prim.Addr# #)}_d1TR
                ds_d1TN ds_d1TQ
         of _ { (# ds_d1TP, ds_d1TO #) ->
         (# ds_d1TP,
            GHC.Ptr.Ptr @ System.Console.Terminfo.Base.TERMINAL ds_d1TO #)
         })
    }

System.Console.Terminfo.Base.setupterm [Occ=OnceL!]
  :: Foreign.C.String.CString
     -> Foreign.C.Types.CInt
     -> GHC.Ptr.Ptr Foreign.C.Types.CInt
     -> GHC.Types.IO ()
[LclId,
 Str=DmdType,
 Unf=Unf{Src=InlineStable, TopLvl=True, Arity=3, Value=True,
         ConLike=True, WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)
         Tmpl= (\ (ds_d1Ty [Occ=Once!] :: GHC.Ptr.Ptr Foreign.C.Types.CChar)
                  (ds_d1Tz [Occ=Once!] :: GHC.Int.Int32)
                  (ds_d1TA [Occ=Once!] :: GHC.Ptr.Ptr Foreign.C.Types.CInt) ->
                  case ds_d1Ty of _ { GHC.Ptr.Ptr ds_d1TC [Occ=Once] ->
                  case ds_d1Tz of _ { GHC.Int.I32# ds_d1TE [Occ=Once] ->
                  case ds_d1TA of _ { GHC.Ptr.Ptr ds_d1TG [Occ=Once] ->
                  GHC.Types.IO
                    @ ()
                    (\ (ds_d1TI [Occ=Once] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
                       case {__pkg_ccall_GC terminfo-0.3.2.5 setupterm GHC.Prim.Addr#
                                           -> GHC.Prim.Int#
                                           -> GHC.Prim.Addr#
                                           -> GHC.Prim.State# GHC.Prim.RealWorld
                                           -> (# GHC.Prim.State# GHC.Prim.RealWorld #)}_d1TJ
                              ds_d1TC ds_d1TE ds_d1TG ds_d1TI
                       of _ { (# ds_d1TH [Occ=Once] #) ->
                       (# ds_d1TH, GHC.Tuple.() #)
                       })
                  }
                  }
                  })
               `cast` (<GHC.Ptr.Ptr Foreign.C.Types.CChar>_R
                       -> Sym Foreign.C.Types.NTCo:CInt[0]
                       -> <GHC.Ptr.Ptr Foreign.C.Types.CInt -> GHC.Types.IO ()>_R
                       :: (GHC.Ptr.Ptr Foreign.C.Types.CChar
                           -> GHC.Int.Int32
                           -> GHC.Ptr.Ptr Foreign.C.Types.CInt
                           -> GHC.Types.IO ())
                            ~#
                          (GHC.Ptr.Ptr Foreign.C.Types.CChar
                           -> Foreign.C.Types.CInt
                           -> GHC.Ptr.Ptr Foreign.C.Types.CInt
                           -> GHC.Types.IO ()))}]
System.Console.Terminfo.Base.setupterm =
  (\ (ds_d1Ty :: GHC.Ptr.Ptr Foreign.C.Types.CChar)
     (ds_d1Tz :: GHC.Int.Int32)
     (ds_d1TA :: GHC.Ptr.Ptr Foreign.C.Types.CInt) ->
     case ds_d1Ty of _ { GHC.Ptr.Ptr ds_d1TC ->
     case ds_d1Tz of _ { GHC.Int.I32# ds_d1TE ->
     case ds_d1TA of _ { GHC.Ptr.Ptr ds_d1TG ->
     GHC.Types.IO
       @ ()
       (\ (ds_d1TI :: GHC.Prim.State# GHC.Prim.RealWorld) ->
          case {__pkg_ccall_GC terminfo-0.3.2.5 setupterm GHC.Prim.Addr#
                                           -> GHC.Prim.Int#
                                           -> GHC.Prim.Addr#
                                           -> GHC.Prim.State# GHC.Prim.RealWorld
                                           -> (# GHC.Prim.State# GHC.Prim.RealWorld #)}_d1TJ
                 ds_d1TC ds_d1TE ds_d1TG ds_d1TI
          of _ { (# ds_d1TH #) ->
          (# ds_d1TH, GHC.Tuple.() #)
          })
     }
     }
     })
  `cast` (<GHC.Ptr.Ptr Foreign.C.Types.CChar>_R
          -> Sym Foreign.C.Types.NTCo:CInt[0]
          -> <GHC.Ptr.Ptr Foreign.C.Types.CInt -> GHC.Types.IO ()>_R
          :: (GHC.Ptr.Ptr Foreign.C.Types.CChar
              -> GHC.Int.Int32
              -> GHC.Ptr.Ptr Foreign.C.Types.CInt
              -> GHC.Types.IO ())
               ~#
             (GHC.Ptr.Ptr Foreign.C.Types.CChar
              -> Foreign.C.Types.CInt
              -> GHC.Ptr.Ptr Foreign.C.Types.CInt
              -> GHC.Types.IO ()))

System.Console.Terminfo.Base.tigetnum [Occ=OnceL]
  :: Foreign.C.String.CString -> GHC.Types.IO Foreign.C.Types.CInt
[LclId,
 Str=DmdType,
 Unf=Unf{Src=InlineStable, TopLvl=True, Arity=1, Value=True,
         ConLike=True, WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)
         Tmpl= (\ (ds_d1Tq [Occ=Once!]
                     :: GHC.Ptr.Ptr Foreign.C.Types.CChar) ->
                  case ds_d1Tq of _ { GHC.Ptr.Ptr ds_d1Ts [Occ=Once] ->
                  GHC.Types.IO
                    @ GHC.Int.Int32
                    (\ (ds_d1Tv [Occ=Once] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
                       case {__pkg_ccall_GC terminfo-0.3.2.5 tigetnum GHC.Prim.Addr#
                                          -> GHC.Prim.State# GHC.Prim.RealWorld
                                          -> (# GHC.Prim.State# GHC.Prim.RealWorld,
                                                GHC.Prim.Int# #)}_d1Tw
                              ds_d1Ts ds_d1Tv
                       of _ { (# ds_d1Tu [Occ=Once], ds_d1Tt [Occ=Once] #) ->
                       (# ds_d1Tu, GHC.Int.I32# (GHC.Prim.narrow32Int# ds_d1Tt) #)
                       })
                  })
               `cast` (<GHC.Ptr.Ptr Foreign.C.Types.CChar>_R
                       -> (GHC.Types.IO (Sym Foreign.C.Types.NTCo:CInt[0]))_R
                       :: (GHC.Ptr.Ptr Foreign.C.Types.CChar
                           -> GHC.Types.IO GHC.Int.Int32)
                            ~#
                          (GHC.Ptr.Ptr Foreign.C.Types.CChar
                           -> GHC.Types.IO Foreign.C.Types.CInt))}]
System.Console.Terminfo.Base.tigetnum =
  (\ (ds_d1Tq :: GHC.Ptr.Ptr Foreign.C.Types.CChar) ->
     case ds_d1Tq of _ { GHC.Ptr.Ptr ds_d1Ts ->
     GHC.Types.IO
       @ GHC.Int.Int32
       (\ (ds_d1Tv :: GHC.Prim.State# GHC.Prim.RealWorld) ->
          case {__pkg_ccall_GC terminfo-0.3.2.5 tigetnum GHC.Prim.Addr#
                                          -> GHC.Prim.State# GHC.Prim.RealWorld
                                          -> (# GHC.Prim.State# GHC.Prim.RealWorld,
                                                GHC.Prim.Int# #)}_d1Tw
                 ds_d1Ts ds_d1Tv
          of _ { (# ds_d1Tu, ds_d1Tt #) ->
          (# ds_d1Tu, GHC.Int.I32# (GHC.Prim.narrow32Int# ds_d1Tt) #)
          })
     })
  `cast` (<GHC.Ptr.Ptr Foreign.C.Types.CChar>_R
          -> (GHC.Types.IO (Sym Foreign.C.Types.NTCo:CInt[0]))_R
          :: (GHC.Ptr.Ptr Foreign.C.Types.CChar
              -> GHC.Types.IO GHC.Int.Int32)
               ~#
             (GHC.Ptr.Ptr Foreign.C.Types.CChar
              -> GHC.Types.IO Foreign.C.Types.CInt))

System.Console.Terminfo.Base.tigetflag [Occ=OnceL]
  :: Foreign.C.String.CString -> GHC.Types.IO Foreign.C.Types.CInt
[LclId,
 Str=DmdType,
 Unf=Unf{Src=InlineStable, TopLvl=True, Arity=1, Value=True,
         ConLike=True, WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)
         Tmpl= (\ (ds_d1Ti [Occ=Once!]
                     :: GHC.Ptr.Ptr Foreign.C.Types.CChar) ->
                  case ds_d1Ti of _ { GHC.Ptr.Ptr ds_d1Tk [Occ=Once] ->
                  GHC.Types.IO
                    @ GHC.Int.Int32
                    (\ (ds_d1Tn [Occ=Once] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
                       case {__pkg_ccall_GC terminfo-0.3.2.5 tigetflag GHC.Prim.Addr#
                                           -> GHC.Prim.State# GHC.Prim.RealWorld
                                           -> (# GHC.Prim.State# GHC.Prim.RealWorld,
                                                 GHC.Prim.Int# #)}_d1To
                              ds_d1Tk ds_d1Tn
                       of _ { (# ds_d1Tm [Occ=Once], ds_d1Tl [Occ=Once] #) ->
                       (# ds_d1Tm, GHC.Int.I32# (GHC.Prim.narrow32Int# ds_d1Tl) #)
                       })
                  })
               `cast` (<GHC.Ptr.Ptr Foreign.C.Types.CChar>_R
                       -> (GHC.Types.IO (Sym Foreign.C.Types.NTCo:CInt[0]))_R
                       :: (GHC.Ptr.Ptr Foreign.C.Types.CChar
                           -> GHC.Types.IO GHC.Int.Int32)
                            ~#
                          (GHC.Ptr.Ptr Foreign.C.Types.CChar
                           -> GHC.Types.IO Foreign.C.Types.CInt))}]
System.Console.Terminfo.Base.tigetflag =
  (\ (ds_d1Ti :: GHC.Ptr.Ptr Foreign.C.Types.CChar) ->
     case ds_d1Ti of _ { GHC.Ptr.Ptr ds_d1Tk ->
     GHC.Types.IO
       @ GHC.Int.Int32
       (\ (ds_d1Tn :: GHC.Prim.State# GHC.Prim.RealWorld) ->
          case {__pkg_ccall_GC terminfo-0.3.2.5 tigetflag GHC.Prim.Addr#
                                           -> GHC.Prim.State# GHC.Prim.RealWorld
                                           -> (# GHC.Prim.State# GHC.Prim.RealWorld,
                                                 GHC.Prim.Int# #)}_d1To
                 ds_d1Tk ds_d1Tn
          of _ { (# ds_d1Tm, ds_d1Tl #) ->
          (# ds_d1Tm, GHC.Int.I32# (GHC.Prim.narrow32Int# ds_d1Tl) #)
          })
     })
  `cast` (<GHC.Ptr.Ptr Foreign.C.Types.CChar>_R
          -> (GHC.Types.IO (Sym Foreign.C.Types.NTCo:CInt[0]))_R
          :: (GHC.Ptr.Ptr Foreign.C.Types.CChar
              -> GHC.Types.IO GHC.Int.Int32)
               ~#
             (GHC.Ptr.Ptr Foreign.C.Types.CChar
              -> GHC.Types.IO Foreign.C.Types.CInt))

System.Console.Terminfo.Base.tigetstr [Occ=OnceL]
  :: Foreign.C.String.CString
     -> GHC.Types.IO Foreign.C.String.CString
[LclId,
 Str=DmdType,
 Unf=Unf{Src=InlineStable, TopLvl=True, Arity=1, Value=True,
         ConLike=True, WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)
         Tmpl= \ (ds_d1Ta [Occ=Once!]
                    :: GHC.Ptr.Ptr Foreign.C.Types.CChar) ->
                 case ds_d1Ta of _ { GHC.Ptr.Ptr ds_d1Tc [Occ=Once] ->
                 GHC.Types.IO
                   @ (GHC.Ptr.Ptr Foreign.C.Types.CChar)
                   (\ (ds_d1Tf [Occ=Once] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
                      case {__pkg_ccall_GC terminfo-0.3.2.5 tigetstr GHC.Prim.Addr#
                                          -> GHC.Prim.State# GHC.Prim.RealWorld
                                          -> (# GHC.Prim.State# GHC.Prim.RealWorld,
                                                GHC.Prim.Addr# #)}_d1Tg
                             ds_d1Tc ds_d1Tf
                      of _ { (# ds_d1Te [Occ=Once], ds_d1Td [Occ=Once] #) ->
                      (# ds_d1Te, GHC.Ptr.Ptr @ Foreign.C.Types.CChar ds_d1Td #)
                      })
                 }}]
System.Console.Terminfo.Base.tigetstr =
  \ (ds_d1Ta :: GHC.Ptr.Ptr Foreign.C.Types.CChar) ->
    case ds_d1Ta of _ { GHC.Ptr.Ptr ds_d1Tc ->
    GHC.Types.IO
      @ (GHC.Ptr.Ptr Foreign.C.Types.CChar)
      (\ (ds_d1Tf :: GHC.Prim.State# GHC.Prim.RealWorld) ->
         case {__pkg_ccall_GC terminfo-0.3.2.5 tigetstr GHC.Prim.Addr#
                                          -> GHC.Prim.State# GHC.Prim.RealWorld
                                          -> (# GHC.Prim.State# GHC.Prim.RealWorld,
                                                GHC.Prim.Addr# #)}_d1Tg
                ds_d1Tc ds_d1Tf
         of _ { (# ds_d1Te, ds_d1Td #) ->
         (# ds_d1Te, GHC.Ptr.Ptr @ Foreign.C.Types.CChar ds_d1Td #)
         })
    }

System.Console.Terminfo.Base.tparm [Occ=OnceL!]
  :: Foreign.C.String.CString
     -> Foreign.C.Types.CLong
     -> Foreign.C.Types.CLong
     -> Foreign.C.Types.CLong
     -> Foreign.C.Types.CLong
     -> Foreign.C.Types.CLong
     -> Foreign.C.Types.CLong
     -> Foreign.C.Types.CLong
     -> Foreign.C.Types.CLong
     -> Foreign.C.Types.CLong
     -> GHC.Types.IO Foreign.C.String.CString
[LclId,
 Str=DmdType,
 Unf=Unf{Src=InlineStable, TopLvl=True, Arity=10, Value=True,
         ConLike=True, WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)
         Tmpl= (\ (ds_d1SB [Occ=Once!] :: GHC.Ptr.Ptr Foreign.C.Types.CChar)
                  (ds_d1SC [Occ=Once!] :: GHC.Int.Int64)
                  (ds_d1SD [Occ=Once!] :: GHC.Int.Int64)
                  (ds_d1SE [Occ=Once!] :: GHC.Int.Int64)
                  (ds_d1SF [Occ=Once!] :: GHC.Int.Int64)
                  (ds_d1SG [Occ=Once!] :: GHC.Int.Int64)
                  (ds_d1SH [Occ=Once!] :: GHC.Int.Int64)
                  (ds_d1SI [Occ=Once!] :: GHC.Int.Int64)
                  (ds_d1SJ [Occ=Once!] :: GHC.Int.Int64)
                  (ds_d1SK [Occ=Once!] :: GHC.Int.Int64) ->
                  case ds_d1SB of _ { GHC.Ptr.Ptr ds_d1SM [Occ=Once] ->
                  case ds_d1SC of _ { GHC.Int.I64# ds_d1SO [Occ=Once] ->
                  case ds_d1SD of _ { GHC.Int.I64# ds_d1SQ [Occ=Once] ->
                  case ds_d1SE of _ { GHC.Int.I64# ds_d1SS [Occ=Once] ->
                  case ds_d1SF of _ { GHC.Int.I64# ds_d1SU [Occ=Once] ->
                  case ds_d1SG of _ { GHC.Int.I64# ds_d1SW [Occ=Once] ->
                  case ds_d1SH of _ { GHC.Int.I64# ds_d1SY [Occ=Once] ->
                  case ds_d1SI of _ { GHC.Int.I64# ds_d1T0 [Occ=Once] ->
                  case ds_d1SJ of _ { GHC.Int.I64# ds_d1T2 [Occ=Once] ->
                  case ds_d1SK of _ { GHC.Int.I64# ds_d1T4 [Occ=Once] ->
                  GHC.Types.IO
                    @ (GHC.Ptr.Ptr Foreign.C.Types.CChar)
                    (\ (ds_d1T7 [Occ=Once] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
                       case {__pkg_ccall_GC terminfo-0.3.2.5 tparm GHC.Prim.Addr#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.State# GHC.Prim.RealWorld
                                       -> (# GHC.Prim.State# GHC.Prim.RealWorld, GHC.Prim.Addr# #)}_d1T8
                              ds_d1SM
                              ds_d1SO
                              ds_d1SQ
                              ds_d1SS
                              ds_d1SU
                              ds_d1SW
                              ds_d1SY
                              ds_d1T0
                              ds_d1T2
                              ds_d1T4
                              ds_d1T7
                       of _ { (# ds_d1T6 [Occ=Once], ds_d1T5 [Occ=Once] #) ->
                       (# ds_d1T6, GHC.Ptr.Ptr @ Foreign.C.Types.CChar ds_d1T5 #)
                       })
                  }
                  }
                  }
                  }
                  }
                  }
                  }
                  }
                  }
                  })
               `cast` (<GHC.Ptr.Ptr Foreign.C.Types.CChar>_R
                       -> Sym Foreign.C.Types.NTCo:CLong[0]
                       -> Sym Foreign.C.Types.NTCo:CLong[0]
                       -> Sym Foreign.C.Types.NTCo:CLong[0]
                       -> Sym Foreign.C.Types.NTCo:CLong[0]
                       -> Sym Foreign.C.Types.NTCo:CLong[0]
                       -> Sym Foreign.C.Types.NTCo:CLong[0]
                       -> Sym Foreign.C.Types.NTCo:CLong[0]
                       -> Sym Foreign.C.Types.NTCo:CLong[0]
                       -> Sym Foreign.C.Types.NTCo:CLong[0]
                       -> <GHC.Types.IO (GHC.Ptr.Ptr Foreign.C.Types.CChar)>_R
                       :: (GHC.Ptr.Ptr Foreign.C.Types.CChar
                           -> GHC.Int.Int64
                           -> GHC.Int.Int64
                           -> GHC.Int.Int64
                           -> GHC.Int.Int64
                           -> GHC.Int.Int64
                           -> GHC.Int.Int64
                           -> GHC.Int.Int64
                           -> GHC.Int.Int64
                           -> GHC.Int.Int64
                           -> GHC.Types.IO (GHC.Ptr.Ptr Foreign.C.Types.CChar))
                            ~#
                          (GHC.Ptr.Ptr Foreign.C.Types.CChar
                           -> Foreign.C.Types.CLong
                           -> Foreign.C.Types.CLong
                           -> Foreign.C.Types.CLong
                           -> Foreign.C.Types.CLong
                           -> Foreign.C.Types.CLong
                           -> Foreign.C.Types.CLong
                           -> Foreign.C.Types.CLong
                           -> Foreign.C.Types.CLong
                           -> Foreign.C.Types.CLong
                           -> GHC.Types.IO (GHC.Ptr.Ptr Foreign.C.Types.CChar)))}]
System.Console.Terminfo.Base.tparm =
  (\ (ds_d1SB :: GHC.Ptr.Ptr Foreign.C.Types.CChar)
     (ds_d1SC :: GHC.Int.Int64)
     (ds_d1SD :: GHC.Int.Int64)
     (ds_d1SE :: GHC.Int.Int64)
     (ds_d1SF :: GHC.Int.Int64)
     (ds_d1SG :: GHC.Int.Int64)
     (ds_d1SH :: GHC.Int.Int64)
     (ds_d1SI :: GHC.Int.Int64)
     (ds_d1SJ :: GHC.Int.Int64)
     (ds_d1SK :: GHC.Int.Int64) ->
     case ds_d1SB of _ { GHC.Ptr.Ptr ds_d1SM ->
     case ds_d1SC of _ { GHC.Int.I64# ds_d1SO ->
     case ds_d1SD of _ { GHC.Int.I64# ds_d1SQ ->
     case ds_d1SE of _ { GHC.Int.I64# ds_d1SS ->
     case ds_d1SF of _ { GHC.Int.I64# ds_d1SU ->
     case ds_d1SG of _ { GHC.Int.I64# ds_d1SW ->
     case ds_d1SH of _ { GHC.Int.I64# ds_d1SY ->
     case ds_d1SI of _ { GHC.Int.I64# ds_d1T0 ->
     case ds_d1SJ of _ { GHC.Int.I64# ds_d1T2 ->
     case ds_d1SK of _ { GHC.Int.I64# ds_d1T4 ->
     GHC.Types.IO
       @ (GHC.Ptr.Ptr Foreign.C.Types.CChar)
       (\ (ds_d1T7 :: GHC.Prim.State# GHC.Prim.RealWorld) ->
          case {__pkg_ccall_GC terminfo-0.3.2.5 tparm GHC.Prim.Addr#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.State# GHC.Prim.RealWorld
                                       -> (# GHC.Prim.State# GHC.Prim.RealWorld, GHC.Prim.Addr# #)}_d1T8
                 ds_d1SM
                 ds_d1SO
                 ds_d1SQ
                 ds_d1SS
                 ds_d1SU
                 ds_d1SW
                 ds_d1SY
                 ds_d1T0
                 ds_d1T2
                 ds_d1T4
                 ds_d1T7
          of _ { (# ds_d1T6, ds_d1T5 #) ->
          (# ds_d1T6, GHC.Ptr.Ptr @ Foreign.C.Types.CChar ds_d1T5 #)
          })
     }
     }
     }
     }
     }
     }
     }
     }
     }
     })
  `cast` (<GHC.Ptr.Ptr Foreign.C.Types.CChar>_R
          -> Sym Foreign.C.Types.NTCo:CLong[0]
          -> Sym Foreign.C.Types.NTCo:CLong[0]
          -> Sym Foreign.C.Types.NTCo:CLong[0]
          -> Sym Foreign.C.Types.NTCo:CLong[0]
          -> Sym Foreign.C.Types.NTCo:CLong[0]
          -> Sym Foreign.C.Types.NTCo:CLong[0]
          -> Sym Foreign.C.Types.NTCo:CLong[0]
          -> Sym Foreign.C.Types.NTCo:CLong[0]
          -> Sym Foreign.C.Types.NTCo:CLong[0]
          -> <GHC.Types.IO (GHC.Ptr.Ptr Foreign.C.Types.CChar)>_R
          :: (GHC.Ptr.Ptr Foreign.C.Types.CChar
              -> GHC.Int.Int64
              -> GHC.Int.Int64
              -> GHC.Int.Int64
              -> GHC.Int.Int64
              -> GHC.Int.Int64
              -> GHC.Int.Int64
              -> GHC.Int.Int64
              -> GHC.Int.Int64
              -> GHC.Int.Int64
              -> GHC.Types.IO (GHC.Ptr.Ptr Foreign.C.Types.CChar))
               ~#
             (GHC.Ptr.Ptr Foreign.C.Types.CChar
              -> Foreign.C.Types.CLong
              -> Foreign.C.Types.CLong
              -> Foreign.C.Types.CLong
              -> Foreign.C.Types.CLong
              -> Foreign.C.Types.CLong
              -> Foreign.C.Types.CLong
              -> Foreign.C.Types.CLong
              -> Foreign.C.Types.CLong
              -> Foreign.C.Types.CLong
              -> GHC.Types.IO (GHC.Ptr.Ptr Foreign.C.Types.CChar)))

System.Console.Terminfo.Base.tputs [Occ=OnceL!]
  :: Foreign.C.String.CString
     -> Foreign.C.Types.CInt
     -> GHC.Ptr.FunPtr System.Console.Terminfo.Base.CharOutput
     -> GHC.Types.IO ()
[LclId,
 Str=DmdType,
 Unf=Unf{Src=InlineStable, TopLvl=True, Arity=3, Value=True,
         ConLike=True, WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)
         Tmpl= (\ (ds_d1Rk [Occ=Once!] :: GHC.Ptr.Ptr Foreign.C.Types.CChar)
                  (ds_d1Rl [Occ=Once!] :: GHC.Int.Int32)
                  (ds_d1Rm [Occ=Once!]
                     :: GHC.Ptr.FunPtr (GHC.Int.Int32 -> GHC.Types.IO GHC.Int.Int32)) ->
                  case ds_d1Rk of _ { GHC.Ptr.Ptr ds_d1Ro [Occ=Once] ->
                  case ds_d1Rl of _ { GHC.Int.I32# ds_d1Rq [Occ=Once] ->
                  case ds_d1Rm of _ { GHC.Ptr.FunPtr ds_d1Rs [Occ=Once] ->
                  GHC.Types.IO
                    @ ()
                    (\ (ds_d1Ru [Occ=Once] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
                       case {__pkg_ccall_GC terminfo-0.3.2.5 tputs GHC.Prim.Addr#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Addr#
                                       -> GHC.Prim.State# GHC.Prim.RealWorld
                                       -> (# GHC.Prim.State# GHC.Prim.RealWorld #)}_d1Rv
                              ds_d1Ro ds_d1Rq ds_d1Rs ds_d1Ru
                       of _ { (# ds_d1Rt [Occ=Once] #) ->
                       (# ds_d1Rt, GHC.Tuple.() #)
                       })
                  }
                  }
                  })
               `cast` (<GHC.Ptr.Ptr Foreign.C.Types.CChar>_R
                       -> Sym Foreign.C.Types.NTCo:CInt[0]
                       -> (GHC.Ptr.FunPtr
                             (Sym Foreign.C.Types.NTCo:CInt[0]
                              -> (GHC.Types.IO (Sym Foreign.C.Types.NTCo:CInt[0]))_R))_R
                       -> <GHC.Types.IO ()>_R
                       :: (GHC.Ptr.Ptr Foreign.C.Types.CChar
                           -> GHC.Int.Int32
                           -> GHC.Ptr.FunPtr (GHC.Int.Int32 -> GHC.Types.IO GHC.Int.Int32)
                           -> GHC.Types.IO ())
                            ~#
                          (GHC.Ptr.Ptr Foreign.C.Types.CChar
                           -> Foreign.C.Types.CInt
                           -> GHC.Ptr.FunPtr
                                (Foreign.C.Types.CInt -> GHC.Types.IO Foreign.C.Types.CInt)
                           -> GHC.Types.IO ()))}]
System.Console.Terminfo.Base.tputs =
  (\ (ds_d1Rk :: GHC.Ptr.Ptr Foreign.C.Types.CChar)
     (ds_d1Rl :: GHC.Int.Int32)
     (ds_d1Rm
        :: GHC.Ptr.FunPtr (GHC.Int.Int32 -> GHC.Types.IO GHC.Int.Int32)) ->
     case ds_d1Rk of _ { GHC.Ptr.Ptr ds_d1Ro ->
     case ds_d1Rl of _ { GHC.Int.I32# ds_d1Rq ->
     case ds_d1Rm of _ { GHC.Ptr.FunPtr ds_d1Rs ->
     GHC.Types.IO
       @ ()
       (\ (ds_d1Ru :: GHC.Prim.State# GHC.Prim.RealWorld) ->
          case {__pkg_ccall_GC terminfo-0.3.2.5 tputs GHC.Prim.Addr#
                                       -> GHC.Prim.Int#
                                       -> GHC.Prim.Addr#
                                       -> GHC.Prim.State# GHC.Prim.RealWorld
                                       -> (# GHC.Prim.State# GHC.Prim.RealWorld #)}_d1Rv
                 ds_d1Ro ds_d1Rq ds_d1Rs ds_d1Ru
          of _ { (# ds_d1Rt #) ->
          (# ds_d1Rt, GHC.Tuple.() #)
          })
     }
     }
     })
  `cast` (<GHC.Ptr.Ptr Foreign.C.Types.CChar>_R
          -> Sym Foreign.C.Types.NTCo:CInt[0]
          -> (GHC.Ptr.FunPtr
                (Sym Foreign.C.Types.NTCo:CInt[0]
                 -> (GHC.Types.IO (Sym Foreign.C.Types.NTCo:CInt[0]))_R))_R
          -> <GHC.Types.IO ()>_R
          :: (GHC.Ptr.Ptr Foreign.C.Types.CChar
              -> GHC.Int.Int32
              -> GHC.Ptr.FunPtr (GHC.Int.Int32 -> GHC.Types.IO GHC.Int.Int32)
              -> GHC.Types.IO ())
               ~#
             (GHC.Ptr.Ptr Foreign.C.Types.CChar
              -> Foreign.C.Types.CInt
              -> GHC.Ptr.FunPtr
                   (Foreign.C.Types.CInt -> GHC.Types.IO Foreign.C.Types.CInt)
              -> GHC.Types.IO ()))

$cshow_a1Pp
  :: System.Console.Terminfo.Base.SetupTermError -> GHC.Base.String
[LclId, Str=DmdType]
$cshow_a1Pp =
  \ (ds_d1Rj :: System.Console.Terminfo.Base.SetupTermError) ->
    case ds_d1Rj
    of _ { System.Console.Terminfo.Base.SetupTermError str_a1tc ->
    GHC.Base.++
      @ GHC.Types.Char
      (GHC.CString.unpackCString# "setupTerm: "#)
      str_a1tc
    }

Rec {
System.Console.Terminfo.Base.$fShowSetupTermError [InlPrag=[ALWAYS] CONLIKE]
  :: GHC.Show.Show System.Console.Terminfo.Base.SetupTermError
[LclIdX[DFunId],
 Str=DmdType,
 Unf=DFun: \ ->
       GHC.Show.D:Show TYPE System.Console.Terminfo.Base.SetupTermError
                       $cshowsPrec_a1Pm
                       $cshow_a1Pp
                       $cshowList_a1Pu]
System.Console.Terminfo.Base.$fShowSetupTermError =
  GHC.Show.D:Show
    @ System.Console.Terminfo.Base.SetupTermError
    $cshowsPrec_a1Pm
    $cshow_a1Pp
    $cshowList_a1Pu

$cshowList_a1Pu [Occ=LoopBreaker]
  :: [System.Console.Terminfo.Base.SetupTermError] -> GHC.Show.ShowS
[LclId, Str=DmdType]
$cshowList_a1Pu =
  GHC.Show.$dmshowList
    @ System.Console.Terminfo.Base.SetupTermError
    System.Console.Terminfo.Base.$fShowSetupTermError

$cshowsPrec_a1Pm [Occ=LoopBreaker]
  :: GHC.Types.Int
     -> System.Console.Terminfo.Base.SetupTermError -> GHC.Show.ShowS
[LclId, Str=DmdType]
$cshowsPrec_a1Pm =
  GHC.Show.$dmshowsPrec
    @ System.Console.Terminfo.Base.SetupTermError
    System.Console.Terminfo.Base.$fShowSetupTermError
end Rec }

$cmappend_a1OV
  :: System.Console.Terminfo.Base.TermOutput
     -> System.Console.Terminfo.Base.TermOutput
     -> System.Console.Terminfo.Base.TermOutput
[LclId, Str=DmdType]
$cmappend_a1OV =
  \ (ds_d1Rh :: System.Console.Terminfo.Base.TermOutput)
    (ds_d1Ri :: System.Console.Terminfo.Base.TermOutput) ->
    System.Console.Terminfo.Base.TermOutput
      (GHC.Base..
         @ [System.Console.Terminfo.Base.TermOutputType]
         @ [System.Console.Terminfo.Base.TermOutputType]
         @ [System.Console.Terminfo.Base.TermOutputType]
         (ds_d1Rh
          `cast` (System.Console.Terminfo.Base.NTCo:TermOutput[0]
                  :: System.Console.Terminfo.Base.TermOutput
                       ~#
                     ([System.Console.Terminfo.Base.TermOutputType]
                      -> [System.Console.Terminfo.Base.TermOutputType])))
         (ds_d1Ri
          `cast` (System.Console.Terminfo.Base.NTCo:TermOutput[0]
                  :: System.Console.Terminfo.Base.TermOutput
                       ~#
                     ([System.Console.Terminfo.Base.TermOutputType]
                      -> [System.Console.Terminfo.Base.TermOutputType]))))

$cmempty_a1OQ :: System.Console.Terminfo.Base.TermOutput
[LclId, Str=DmdType]
$cmempty_a1OQ =
  System.Console.Terminfo.Base.TermOutput
    (GHC.Base.id @ [System.Console.Terminfo.Base.TermOutputType])

Rec {
System.Console.Terminfo.Base.$fMonoidTermOutput [InlPrag=[ALWAYS] CONLIKE]
  :: Data.Monoid.Monoid System.Console.Terminfo.Base.TermOutput
[LclIdX[DFunId],
 Str=DmdType,
 Unf=DFun: \ ->
       Data.Monoid.D:Monoid TYPE System.Console.Terminfo.Base.TermOutput
                            $cmempty_a1OQ
                            $cmappend_a1OV
                            $cmconcat_a1P2]
System.Console.Terminfo.Base.$fMonoidTermOutput =
  Data.Monoid.D:Monoid
    @ System.Console.Terminfo.Base.TermOutput
    $cmempty_a1OQ
    $cmappend_a1OV
    $cmconcat_a1P2

$cmconcat_a1P2 [Occ=LoopBreaker]
  :: [System.Console.Terminfo.Base.TermOutput]
     -> System.Console.Terminfo.Base.TermOutput
[LclId, Str=DmdType]
$cmconcat_a1P2 =
  Data.Monoid.$dmmconcat
    @ System.Console.Terminfo.Base.TermOutput
    System.Console.Terminfo.Base.$fMonoidTermOutput
end Rec }

$coutputCap_a1MC
  :: ([GHC.Types.Int] -> GHC.Base.String)
     -> [GHC.Types.Int] -> [GHC.Types.Char]
[LclId, Str=DmdType]
$coutputCap_a1MC =
  \ (f_a1sV :: [GHC.Types.Int] -> GHC.Base.String)
    (xs_a1sW :: [GHC.Types.Int]) ->
    f_a1sV (GHC.List.reverse @ GHC.Types.Int xs_a1sW)

$chasOkPadding_a1Mw
  :: [GHC.Types.Char] -> GHC.Base.String -> GHC.Types.Bool
[LclId, Str=DmdType]
$chasOkPadding_a1Mw =
  \ _ ->
    GHC.Base..
      @ GHC.Types.Bool
      @ GHC.Types.Bool
      @ GHC.Base.String
      GHC.Classes.not
      System.Console.Terminfo.Base.strHasPadding

System.Console.Terminfo.Base.$fOutputCap[] [InlPrag=[ALWAYS] CONLIKE]
  :: System.Console.Terminfo.Base.OutputCap [GHC.Types.Char]
[LclIdX[DFunId],
 Str=DmdType,
 Unf=DFun: \ ->
       System.Console.Terminfo.Base.D:OutputCap TYPE [GHC.Types.Char]
                                                $chasOkPadding_a1Mw
                                                $coutputCap_a1MC]
System.Console.Terminfo.Base.$fOutputCap[] =
  System.Console.Terminfo.Base.D:OutputCap
    @ [GHC.Types.Char] $chasOkPadding_a1Mw $coutputCap_a1MC

$coutputCap_a1Mm
  :: ([GHC.Types.Int] -> GHC.Base.String)
     -> [GHC.Types.Int] -> System.Console.Terminfo.Base.TermOutput
[LclId, Str=DmdType]
$coutputCap_a1Mm =
  \ (f_a1sT :: [GHC.Types.Int] -> GHC.Base.String)
    (xs_a1sU :: [GHC.Types.Int]) ->
    GHC.Base.$
      @ GHC.Base.String
      @ System.Console.Terminfo.Base.TermOutput
      (System.Console.Terminfo.Base.fromStr (GHC.Types.I# 1))
      (GHC.Base.$
         @ [GHC.Types.Int]
         @ GHC.Base.String
         f_a1sT
         (GHC.List.reverse @ GHC.Types.Int xs_a1sU))

$chasOkPadding_a1Mh
  :: System.Console.Terminfo.Base.TermOutput
     -> GHC.Base.String -> GHC.Types.Bool
[LclId, Str=DmdType]
$chasOkPadding_a1Mh =
  \ _ ->
    GHC.Base.const @ GHC.Types.Bool @ GHC.Base.String GHC.Types.True

System.Console.Terminfo.Base.$fOutputCapTermOutput [InlPrag=[ALWAYS] CONLIKE]
  :: System.Console.Terminfo.Base.OutputCap
       System.Console.Terminfo.Base.TermOutput
[LclIdX[DFunId],
 Str=DmdType,
 Unf=DFun: \ ->
       System.Console.Terminfo.Base.D:OutputCap TYPE System.Console.Terminfo.Base.TermOutput
                                                $chasOkPadding_a1Mh
                                                $coutputCap_a1Mm]
System.Console.Terminfo.Base.$fOutputCapTermOutput =
  System.Console.Terminfo.Base.D:OutputCap
    @ System.Console.Terminfo.Base.TermOutput
    $chasOkPadding_a1Mh
    $coutputCap_a1Mm

$coutputCap_a1M7
  :: forall p_a1sO f_a1sP.
     (GHC.Enum.Enum p_a1sO,
      System.Console.Terminfo.Base.OutputCap f_a1sP) =>
     ([GHC.Types.Int] -> GHC.Base.String)
     -> [GHC.Types.Int] -> p_a1sO -> f_a1sP
[LclId, Str=DmdType]
$coutputCap_a1M7 =
  \ (@ p_a1sO)
    (@ f_a1sP)
    ($dEnum_a1LY :: GHC.Enum.Enum p_a1sO)
    ($dOutputCap_a1LZ :: System.Console.Terminfo.Base.OutputCap f_a1sP)
    (f_a1sQ :: [GHC.Types.Int] -> GHC.Base.String)
    (xs_a1sR :: [GHC.Types.Int])
    (x_a1sS :: p_a1sO) ->
    System.Console.Terminfo.Base.outputCap
      @ f_a1sP
      $dOutputCap_a1LZ
      f_a1sQ
      (GHC.Types.:
         @ GHC.Types.Int
         (GHC.Enum.fromEnum @ p_a1sO $dEnum_a1LY x_a1sS)
         xs_a1sR)

$chasOkPadding_a1M0
  :: forall p_a1sO f_a1sP.
     (GHC.Enum.Enum p_a1sO,
      System.Console.Terminfo.Base.OutputCap f_a1sP) =>
     (p_a1sO -> f_a1sP) -> GHC.Base.String -> GHC.Types.Bool
[LclId, Str=DmdType]
$chasOkPadding_a1M0 =
  \ (@ p_a1sO)
    (@ f_a1sP)
    _
    ($dOutputCap_a1LZ :: System.Console.Terminfo.Base.OutputCap f_a1sP)
    _ ->
    System.Console.Terminfo.Base.hasOkPadding
      @ f_a1sP $dOutputCap_a1LZ (GHC.Err.undefined @ f_a1sP)

System.Console.Terminfo.Base.$fOutputCap(->) [InlPrag=[ALWAYS] CONLIKE]
  :: forall p_a1sO f_a1sP.
     (GHC.Enum.Enum p_a1sO,
      System.Console.Terminfo.Base.OutputCap f_a1sP) =>
     System.Console.Terminfo.Base.OutputCap (p_a1sO -> f_a1sP)
[LclIdX[DFunId],
 Str=DmdType,
 Unf=DFun: \ (@ p_a1sO)
             (@ f_a1sP)
             ($dEnum_a1LY :: GHC.Enum.Enum p_a1sO)
             ($dOutputCap_a1LZ
                :: System.Console.Terminfo.Base.OutputCap f_a1sP) ->
       System.Console.Terminfo.Base.D:OutputCap TYPE p_a1sO -> f_a1sP
                                                $chasOkPadding_a1M0
                                                  @ p_a1sO @ f_a1sP $dEnum_a1LY $dOutputCap_a1LZ
                                                $coutputCap_a1M7
                                                  @ p_a1sO @ f_a1sP $dEnum_a1LY $dOutputCap_a1LZ]
System.Console.Terminfo.Base.$fOutputCap(->) =
  \ (@ p_a1sO)
    (@ f_a1sP)
    ($dEnum_a1LY :: GHC.Enum.Enum p_a1sO)
    ($dOutputCap_a1LZ
       :: System.Console.Terminfo.Base.OutputCap f_a1sP) ->
    System.Console.Terminfo.Base.D:OutputCap
      @ (p_a1sO -> f_a1sP)
      ($chasOkPadding_a1M0
         @ p_a1sO @ f_a1sP $dEnum_a1LY $dOutputCap_a1LZ)
      ($coutputCap_a1M7 @ p_a1sO @ f_a1sP $dEnum_a1LY $dOutputCap_a1LZ)

System.Console.Terminfo.Base.$fTermStr[] [InlPrag=[ALWAYS] CONLIKE]
  :: System.Console.Terminfo.Base.TermStr [GHC.Types.Char]
[LclIdX[DFunId],
 Str=DmdType,
 Unf=DFun: \ ->
       System.Console.Terminfo.Base.D:TermStr TYPE [GHC.Types.Char]
                                              Data.Monoid.$fMonoid[] @ GHC.Types.Char
                                              System.Console.Terminfo.Base.$fOutputCap[]]
System.Console.Terminfo.Base.$fTermStr[] =
  System.Console.Terminfo.Base.D:TermStr
    @ [GHC.Types.Char]
    (Data.Monoid.$fMonoid[] @ GHC.Types.Char)
    System.Console.Terminfo.Base.$fOutputCap[]

System.Console.Terminfo.Base.$fTermStrTermOutput [InlPrag=[ALWAYS] CONLIKE]
  :: System.Console.Terminfo.Base.TermStr
       System.Console.Terminfo.Base.TermOutput
[LclIdX[DFunId],
 Str=DmdType,
 Unf=DFun: \ ->
       System.Console.Terminfo.Base.D:TermStr TYPE System.Console.Terminfo.Base.TermOutput
                                              System.Console.Terminfo.Base.$fMonoidTermOutput
                                              System.Console.Terminfo.Base.$fOutputCapTermOutput]
System.Console.Terminfo.Base.$fTermStrTermOutput =
  System.Console.Terminfo.Base.D:TermStr
    @ System.Console.Terminfo.Base.TermOutput
    System.Console.Terminfo.Base.$fMonoidTermOutput
    System.Console.Terminfo.Base.$fOutputCapTermOutput

$ctypeRep_a1LG
  :: forall (proxy_a1LI :: * -> *).
     proxy_a1LI System.Console.Terminfo.Base.SetupTermError
     -> Data.Typeable.Internal.TypeRep
[LclId, Str=DmdType]
$ctypeRep_a1LG =
  \ (@ (proxy_a1LM :: * -> *)) _ ->
    Data.Typeable.Internal.mkTyConApp
      (Data.Typeable.Internal.mkTyCon
         (__word 5421676122555392965)
         (__word 9997702193150505783)
         (GHC.CString.unpackCString# "terminfo-0.3.2.5"#)
         (GHC.CString.unpackCString# "System.Console.Terminfo.Base"#)
         (GHC.CString.unpackCString# "SetupTermError"#))
      (GHC.Types.[] @ Data.Typeable.Internal.TypeRep)

System.Console.Terminfo.Base.$fTypeableSetupTermError [InlPrag=INLINE (sat-args=0)]
  :: Data.Typeable.Internal.Typeable
       * System.Console.Terminfo.Base.SetupTermError
[LclIdX[DFunId(nt)],
 Str=DmdType,
 Unf=Unf{Src=InlineStable, TopLvl=True, Arity=0, Value=False,
         ConLike=False, WorkFree=False, Expandable=False,
         Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)
         Tmpl= Data.Typeable.Internal.D:Typeable
                 @ * @ System.Console.Terminfo.Base.SetupTermError $ctypeRep_a1LG}]
System.Console.Terminfo.Base.$fTypeableSetupTermError =
  Data.Typeable.Internal.D:Typeable
    @ * @ System.Console.Terminfo.Base.SetupTermError $ctypeRep_a1LG

Rec {
System.Console.Terminfo.Base.$fExceptionSetupTermError [InlPrag=[ALWAYS] CONLIKE]
  :: GHC.Exception.Exception
       System.Console.Terminfo.Base.SetupTermError
[LclIdX[DFunId],
 Str=DmdType,
 Unf=DFun: \ ->
       GHC.Exception.D:Exception TYPE System.Console.Terminfo.Base.SetupTermError
                                 System.Console.Terminfo.Base.$fTypeableSetupTermError
                                 System.Console.Terminfo.Base.$fShowSetupTermError
                                 $ctoException_a1P9
                                 $cfromException_a1Ph]
System.Console.Terminfo.Base.$fExceptionSetupTermError =
  GHC.Exception.D:Exception
    @ System.Console.Terminfo.Base.SetupTermError
    System.Console.Terminfo.Base.$fTypeableSetupTermError
    System.Console.Terminfo.Base.$fShowSetupTermError
    $ctoException_a1P9
    $cfromException_a1Ph

$cfromException_a1Ph [Occ=LoopBreaker]
  :: GHC.Exception.SomeException
     -> Data.Maybe.Maybe System.Console.Terminfo.Base.SetupTermError
[LclId, Str=DmdType]
$cfromException_a1Ph =
  GHC.Exception.$dmfromException
    @ System.Console.Terminfo.Base.SetupTermError
    System.Console.Terminfo.Base.$fExceptionSetupTermError

$ctoException_a1P9 [Occ=LoopBreaker]
  :: System.Console.Terminfo.Base.SetupTermError
     -> GHC.Exception.SomeException
[LclId, Str=DmdType]
$ctoException_a1P9 =
  GHC.Exception.$dmtoException
    @ System.Console.Terminfo.Base.SetupTermError
    System.Console.Terminfo.Base.$fExceptionSetupTermError
end Rec }

$dShow_a1KO :: GHC.Show.Show GHC.Base.String
[LclId, Str=DmdType]
$dShow_a1KO =
  GHC.Show.$fShow[] @ GHC.Types.Char GHC.Show.$fShowChar

System.Console.Terminfo.Base.tiGetFlag
  :: GHC.Base.String
     -> System.Console.Terminfo.Base.Capability GHC.Types.Bool
[LclIdX, Str=DmdType]
System.Console.Terminfo.Base.tiGetFlag =
  \ (cap_a1sg :: GHC.Base.String) ->
    GHC.Base.$
      @ (System.Console.Terminfo.Base.Terminal
         -> GHC.Types.IO (Data.Maybe.Maybe GHC.Types.Bool))
      @ (System.Console.Terminfo.Base.Capability GHC.Types.Bool)
      (System.Console.Terminfo.Base.Capability @ GHC.Types.Bool)
      (GHC.Base.$
         @ (GHC.Types.IO (Data.Maybe.Maybe GHC.Types.Bool))
         @ (System.Console.Terminfo.Base.Terminal
            -> GHC.Types.IO (Data.Maybe.Maybe GHC.Types.Bool))
         (GHC.Base.const
            @ (GHC.Types.IO (Data.Maybe.Maybe GHC.Types.Bool))
            @ System.Console.Terminfo.Base.Terminal)
         (GHC.Base.$
            @ (GHC.Types.IO Foreign.C.Types.CInt)
            @ (GHC.Types.IO (Data.Maybe.Maybe GHC.Types.Bool))
            (GHC.Base.fmap
               @ GHC.Types.IO
               GHC.Base.$fFunctorIO
               @ Foreign.C.Types.CInt
               @ (Data.Maybe.Maybe GHC.Types.Bool)
               (GHC.Base..
                  @ GHC.Types.Bool
                  @ (Data.Maybe.Maybe GHC.Types.Bool)
                  @ Foreign.C.Types.CInt
                  (Data.Maybe.Just @ GHC.Types.Bool)
                  (let {
                     ds_d1Qx :: Foreign.C.Types.CInt
                     [LclId, Str=DmdType]
                     ds_d1Qx =
                       GHC.Num.fromInteger
                         @ Foreign.C.Types.CInt Foreign.C.Types.$fNumCInt (__integer 0) } in
                   \ (ds_d1Qw :: Foreign.C.Types.CInt) ->
                     GHC.Classes.>
                       @ Foreign.C.Types.CInt Foreign.C.Types.$fOrdCInt ds_d1Qw ds_d1Qx)))
            (Foreign.C.String.withCString
               @ Foreign.C.Types.CInt
               cap_a1sg
               System.Console.Terminfo.Base.tigetflag)))

$cfmap_a1Om
  :: forall a_a1BF b_a1BG.
     (a_a1BF -> b_a1BG)
     -> System.Console.Terminfo.Base.Capability a_a1BF
     -> System.Console.Terminfo.Base.Capability b_a1BG
[LclId, Str=DmdType]
$cfmap_a1Om =
  \ (@ a_a1Oo)
    (@ b_a1Op)
    (f_a1t7 :: a_a1Oo -> b_a1Op)
    (ds_d1Rg :: System.Console.Terminfo.Base.Capability a_a1Oo) ->
    GHC.Base.$
      @ (System.Console.Terminfo.Base.Terminal
         -> GHC.Types.IO (Data.Maybe.Maybe b_a1Op))
      @ (System.Console.Terminfo.Base.Capability b_a1Op)
      (System.Console.Terminfo.Base.Capability @ b_a1Op)
      (\ (t_a1t9 :: System.Console.Terminfo.Base.Terminal) ->
         GHC.Base.fmap
           @ GHC.Types.IO
           GHC.Base.$fFunctorIO
           @ (Data.Maybe.Maybe a_a1Oo)
           @ (Data.Maybe.Maybe b_a1Op)
           (GHC.Base.fmap
              @ Data.Maybe.Maybe
              Data.Maybe.$fFunctorMaybe
              @ a_a1Oo
              @ b_a1Op
              f_a1t7)
           ((ds_d1Rg
             `cast` (System.Console.Terminfo.Base.NTCo:Capability[0] <a_a1Oo>_R
                     :: System.Console.Terminfo.Base.Capability a_a1Oo
                          ~#
                        (System.Console.Terminfo.Base.Terminal
                         -> GHC.Types.IO (Data.Maybe.Maybe a_a1Oo))))
              t_a1t9))

Rec {
System.Console.Terminfo.Base.$fFunctorCapability [InlPrag=[ALWAYS] CONLIKE]
  :: GHC.Base.Functor System.Console.Terminfo.Base.Capability
[LclIdX[DFunId],
 Str=DmdType,
 Unf=DFun: \ ->
       GHC.Base.D:Functor TYPE System.Console.Terminfo.Base.Capability
                          $cfmap_a1Om
                          $c<$_a1OG]
System.Console.Terminfo.Base.$fFunctorCapability =
  GHC.Base.D:Functor
    @ System.Console.Terminfo.Base.Capability $cfmap_a1Om $c<$_a1OG

$c<$_a1OG [Occ=LoopBreaker]
  :: forall a_a1OI b_a1OJ.
     a_a1OI
     -> System.Console.Terminfo.Base.Capability b_a1OJ
     -> System.Console.Terminfo.Base.Capability a_a1OI
[LclId, Str=DmdType]
$c<$_a1OG =
  GHC.Base.$dm<$
    @ System.Console.Terminfo.Base.Capability
    System.Console.Terminfo.Base.$fFunctorCapability
end Rec }

System.Console.Terminfo.Base.setupTerm
  :: GHC.Base.String
     -> GHC.Types.IO System.Console.Terminfo.Base.Terminal
[LclIdX, Str=DmdType]
System.Console.Terminfo.Base.setupTerm =
  \ (term_a17U :: GHC.Base.String) ->
    GHC.Base.$
      @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL
         -> GHC.Types.IO System.Console.Terminfo.Base.Terminal)
      @ (GHC.Types.IO System.Console.Terminfo.Base.Terminal)
      (Control.Exception.Base.bracket
         @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
         @ ()
         @ System.Console.Terminfo.Base.Terminal
         (Foreign.Storable.peek
            @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
            (Foreign.Storable.$fStorablePtr
               @ System.Console.Terminfo.Base.TERMINAL)
            System.Console.Terminfo.Base.cur_term)
         (Foreign.Storable.poke
            @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
            (Foreign.Storable.$fStorablePtr
               @ System.Console.Terminfo.Base.TERMINAL)
            System.Console.Terminfo.Base.cur_term))
      (\ _ ->
         GHC.Base.$
           @ (Foreign.C.String.CString
              -> GHC.Types.IO System.Console.Terminfo.Base.Terminal)
           @ (GHC.Types.IO System.Console.Terminfo.Base.Terminal)
           (Foreign.C.String.withCString
              @ System.Console.Terminfo.Base.Terminal term_a17U)
           (\ (c_term_a1aA :: Foreign.C.String.CString) ->
              GHC.Base.$
                @ (GHC.Ptr.Ptr Foreign.C.Types.CInt
                   -> GHC.Types.IO System.Console.Terminfo.Base.Terminal)
                @ (GHC.Types.IO System.Console.Terminfo.Base.Terminal)
                (Foreign.Marshal.Utils.with
                   @ Foreign.C.Types.CInt
                   @ System.Console.Terminfo.Base.Terminal
                   Foreign.C.Types.$fStorableCInt
                   (GHC.Num.fromInteger
                      @ Foreign.C.Types.CInt Foreign.C.Types.$fNumCInt (__integer 0)))
                (\ (ret_ptr_a1aN :: GHC.Ptr.Ptr Foreign.C.Types.CInt) ->
                   GHC.Base.>>
                     @ GHC.Types.IO
                     GHC.Base.$fMonadIO
                     @ ()
                     @ System.Console.Terminfo.Base.Terminal
                     (Foreign.Storable.poke
                        @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
                        (Foreign.Storable.$fStorablePtr
                           @ System.Console.Terminfo.Base.TERMINAL)
                        System.Console.Terminfo.Base.cur_term
                        (GHC.Ptr.nullPtr @ System.Console.Terminfo.Base.TERMINAL))
                     (GHC.Base.>>
                        @ GHC.Types.IO
                        GHC.Base.$fMonadIO
                        @ ()
                        @ System.Console.Terminfo.Base.Terminal
                        (System.Console.Terminfo.Base.setupterm
                           c_term_a1aA
                           (GHC.Num.fromInteger
                              @ Foreign.C.Types.CInt Foreign.C.Types.$fNumCInt (__integer 1))
                           ret_ptr_a1aN)
                        (GHC.Base.>>=
                           @ GHC.Types.IO
                           GHC.Base.$fMonadIO
                           @ Foreign.C.Types.CInt
                           @ System.Console.Terminfo.Base.Terminal
                           (Foreign.Storable.peek
                              @ Foreign.C.Types.CInt Foreign.C.Types.$fStorableCInt ret_ptr_a1aN)
                           (\ (ret_a1aP :: Foreign.C.Types.CInt) ->
                              case GHC.Classes./=
                                     @ Foreign.C.Types.CInt
                                     Foreign.C.Types.$fEqCInt
                                     ret_a1aP
                                     (GHC.Num.fromInteger
                                        @ Foreign.C.Types.CInt
                                        Foreign.C.Types.$fNumCInt
                                        (__integer 1))
                              of _ {
                                GHC.Types.False ->
                                  GHC.Base.>>=
                                    @ GHC.Types.IO
                                    GHC.Base.$fMonadIO
                                    @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
                                    @ System.Console.Terminfo.Base.Terminal
                                    (Foreign.Storable.peek
                                       @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
                                       (Foreign.Storable.$fStorablePtr
                                          @ System.Console.Terminfo.Base.TERMINAL)
                                       System.Console.Terminfo.Base.cur_term)
                                    (\ (cterm_a1gx
                                          :: GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL) ->
                                       GHC.Base.$
                                         @ (GHC.Types.IO
                                              (GHC.ForeignPtr.ForeignPtr
                                                 System.Console.Terminfo.Base.TERMINAL))
                                         @ (GHC.Types.IO System.Console.Terminfo.Base.Terminal)
                                         (GHC.Base.fmap
                                            @ GHC.Types.IO
                                            GHC.Base.$fFunctorIO
                                            @ (GHC.ForeignPtr.ForeignPtr
                                                 System.Console.Terminfo.Base.TERMINAL)
                                            @ System.Console.Terminfo.Base.Terminal
                                            System.Console.Terminfo.Base.Terminal)
                                         (Foreign.ForeignPtr.Imp.newForeignPtr
                                            @ System.Console.Terminfo.Base.TERMINAL
                                            System.Console.Terminfo.Base.del_curterm
                                            cterm_a1gx));
                                GHC.Types.True ->
                                  GHC.Base.$
                                    @ System.Console.Terminfo.Base.SetupTermError
                                    @ (GHC.Types.IO System.Console.Terminfo.Base.Terminal)
                                    (GHC.IO.throwIO
                                       @ System.Console.Terminfo.Base.SetupTermError
                                       @ System.Console.Terminfo.Base.Terminal
                                       System.Console.Terminfo.Base.$fExceptionSetupTermError)
                                    (GHC.Base.$
                                       @ GHC.Base.String
                                       @ System.Console.Terminfo.Base.SetupTermError
                                       System.Console.Terminfo.Base.SetupTermError
                                       (GHC.Base.++
                                          @ GHC.Types.Char
                                          (GHC.CString.unpackCString#
                                             "Couldn't look up terminfo entry "#)
                                          (GHC.Show.show @ GHC.Base.String $dShow_a1KO term_a17U)))
                              }))))))

System.Console.Terminfo.Base.setupTermFromEnv
  :: GHC.Types.IO System.Console.Terminfo.Base.Terminal
[LclIdX, Str=DmdType]
System.Console.Terminfo.Base.setupTermFromEnv =
  GHC.Base.>>=
    @ GHC.Types.IO
    GHC.Base.$fMonadIO
    @ GHC.Base.String
    @ System.Console.Terminfo.Base.Terminal
    (GHC.Base.$
       @ (GHC.Types.IO GHC.Base.String)
       @ (GHC.Types.IO GHC.Base.String)
       (Control.Exception.Base.handle
          @ GHC.IO.Exception.IOException
          @ GHC.Base.String
          GHC.IO.Exception.$fExceptionIOException
          (\ _ ->
             GHC.Base.return
               @ GHC.Types.IO
               GHC.Base.$fMonadIO
               @ GHC.Base.String
               (GHC.Types.[] @ GHC.Types.Char)))
       (System.Environment.getEnv (GHC.CString.unpackCString# "TERM"#)))
    (\ (env_term_a1l5 :: GHC.Base.String) ->
       System.Console.Terminfo.Base.setupTerm
         (case GHC.List.null @ GHC.Types.Char env_term_a1l5 of _ {
            GHC.Types.False -> env_term_a1l5;
            GHC.Types.True -> GHC.CString.unpackCString# "dumb"#
          }))

$cmzero_a1MI
  :: forall a_a1MK. System.Console.Terminfo.Base.Capability a_a1MK
[LclId, Str=DmdType]
$cmzero_a1MI =
  \ (@ a_a1ML) ->
    System.Console.Terminfo.Base.Capability
      @ a_a1ML
      (GHC.Base.$
         @ (GHC.Types.IO (Data.Maybe.Maybe a_a1ML))
         @ (System.Console.Terminfo.Base.Terminal
            -> GHC.Types.IO (Data.Maybe.Maybe a_a1ML))
         (GHC.Base.const
            @ (GHC.Types.IO (Data.Maybe.Maybe a_a1ML))
            @ System.Console.Terminfo.Base.Terminal)
         (GHC.Base.return
            @ GHC.Types.IO
            GHC.Base.$fMonadIO
            @ (Data.Maybe.Maybe a_a1ML)
            (Data.Maybe.Nothing @ a_a1ML)))

$cmplus_a1MY
  :: forall a_a1N0.
     System.Console.Terminfo.Base.Capability a_a1N0
     -> System.Console.Terminfo.Base.Capability a_a1N0
     -> System.Console.Terminfo.Base.Capability a_a1N0
[LclId, Str=DmdType]
$cmplus_a1MY =
  \ (@ a_a1N1)
    (ds_d1Ra :: System.Console.Terminfo.Base.Capability a_a1N1)
    (ds_d1Rb :: System.Console.Terminfo.Base.Capability a_a1N1) ->
    GHC.Base.$
      @ (System.Console.Terminfo.Base.Terminal
         -> GHC.Types.IO (Data.Maybe.Maybe a_a1N1))
      @ (System.Console.Terminfo.Base.Capability a_a1N1)
      (System.Console.Terminfo.Base.Capability @ a_a1N1)
      (\ (t_a1sZ :: System.Console.Terminfo.Base.Terminal) ->
         GHC.Base.>>=
           @ GHC.Types.IO
           GHC.Base.$fMonadIO
           @ (Data.Maybe.Maybe a_a1N1)
           @ (Data.Maybe.Maybe a_a1N1)
           ((ds_d1Ra
             `cast` (System.Console.Terminfo.Base.NTCo:Capability[0] <a_a1N1>_R
                     :: System.Console.Terminfo.Base.Capability a_a1N1
                          ~#
                        (System.Console.Terminfo.Base.Terminal
                         -> GHC.Types.IO (Data.Maybe.Maybe a_a1N1))))
              t_a1sZ)
           (\ (mx_a1t0 :: Data.Maybe.Maybe a_a1N1) ->
              case mx_a1t0 of _ {
                __DEFAULT ->
                  (\ _ ->
                     GHC.Base.return
                       @ GHC.Types.IO
                       GHC.Base.$fMonadIO
                       @ (Data.Maybe.Maybe a_a1N1)
                       mx_a1t0)
                    GHC.Prim.realWorld#;
                Data.Maybe.Nothing ->
                  (ds_d1Rb
                   `cast` (System.Console.Terminfo.Base.NTCo:Capability[0] <a_a1N1>_R
                           :: System.Console.Terminfo.Base.Capability a_a1N1
                                ~#
                              (System.Console.Terminfo.Base.Terminal
                               -> GHC.Types.IO (Data.Maybe.Maybe a_a1N1))))
                    t_a1sZ
              }))

$c>>=_a1Nk
  :: forall a_a1Bi b_a1Bj.
     System.Console.Terminfo.Base.Capability a_a1Bi
     -> (a_a1Bi -> System.Console.Terminfo.Base.Capability b_a1Bj)
     -> System.Console.Terminfo.Base.Capability b_a1Bj
[LclId, Str=DmdType]
$c>>=_a1Nk =
  \ (@ a_a1Nm)
    (@ b_a1Nn)
    (ds_d1Rf :: System.Console.Terminfo.Base.Capability a_a1Nm)
    (g_a1t2
       :: a_a1Nm -> System.Console.Terminfo.Base.Capability b_a1Nn) ->
    GHC.Base.$
      @ (System.Console.Terminfo.Base.Terminal
         -> GHC.Types.IO (Data.Maybe.Maybe b_a1Nn))
      @ (System.Console.Terminfo.Base.Capability b_a1Nn)
      (System.Console.Terminfo.Base.Capability @ b_a1Nn)
      (\ (t_a1t3 :: System.Console.Terminfo.Base.Terminal) ->
         GHC.Base.>>=
           @ GHC.Types.IO
           GHC.Base.$fMonadIO
           @ (Data.Maybe.Maybe a_a1Nm)
           @ (Data.Maybe.Maybe b_a1Nn)
           ((ds_d1Rf
             `cast` (System.Console.Terminfo.Base.NTCo:Capability[0] <a_a1Nm>_R
                     :: System.Console.Terminfo.Base.Capability a_a1Nm
                          ~#
                        (System.Console.Terminfo.Base.Terminal
                         -> GHC.Types.IO (Data.Maybe.Maybe a_a1Nm))))
              t_a1t3)
           (\ (mx_a1t4 :: Data.Maybe.Maybe a_a1Nm) ->
              case mx_a1t4 of _ {
                Data.Maybe.Nothing ->
                  GHC.Base.return
                    @ GHC.Types.IO
                    GHC.Base.$fMonadIO
                    @ (Data.Maybe.Maybe b_a1Nn)
                    (Data.Maybe.Nothing @ b_a1Nn);
                Data.Maybe.Just x_a1t5 ->
                  (let {
                     ds_d1Rc :: System.Console.Terminfo.Base.Capability b_a1Nn
                     [LclId, Str=DmdType]
                     ds_d1Rc = g_a1t2 x_a1t5 } in
                   ds_d1Rc
                   `cast` (System.Console.Terminfo.Base.NTCo:Capability[0] <b_a1Nn>_R
                           :: System.Console.Terminfo.Base.Capability b_a1Nn
                                ~#
                              (System.Console.Terminfo.Base.Terminal
                               -> GHC.Types.IO (Data.Maybe.Maybe b_a1Nn))))
                    t_a1t3
              }))

$creturn_a1NT
  :: forall a_a1Bz.
     a_a1Bz -> System.Console.Terminfo.Base.Capability a_a1Bz
[LclId, Str=DmdType]
$creturn_a1NT =
  \ (@ a_a1NV) ->
    GHC.Base..
      @ (System.Console.Terminfo.Base.Terminal
         -> GHC.Types.IO (Data.Maybe.Maybe a_a1NV))
      @ (System.Console.Terminfo.Base.Capability a_a1NV)
      @ a_a1NV
      (System.Console.Terminfo.Base.Capability @ a_a1NV)
      (GHC.Base..
         @ (GHC.Types.IO (Data.Maybe.Maybe a_a1NV))
         @ (System.Console.Terminfo.Base.Terminal
            -> GHC.Types.IO (Data.Maybe.Maybe a_a1NV))
         @ a_a1NV
         (GHC.Base.const
            @ (GHC.Types.IO (Data.Maybe.Maybe a_a1NV))
            @ System.Console.Terminfo.Base.Terminal)
         (GHC.Base..
            @ (Data.Maybe.Maybe a_a1NV)
            @ (GHC.Types.IO (Data.Maybe.Maybe a_a1NV))
            @ a_a1NV
            (GHC.Base.return
               @ GHC.Types.IO GHC.Base.$fMonadIO @ (Data.Maybe.Maybe a_a1NV))
            (Data.Maybe.Just @ a_a1NV)))

Rec {
System.Console.Terminfo.Base.$fMonadCapability [InlPrag=[ALWAYS] CONLIKE]
  :: GHC.Base.Monad System.Console.Terminfo.Base.Capability
[LclIdX[DFunId],
 Str=DmdType,
 Unf=DFun: \ ->
       GHC.Base.D:Monad TYPE System.Console.Terminfo.Base.Capability
                        $c>>=_a1Nk
                        $c>>_a1NM
                        $creturn_a1NT
                        $cfail_a1Og]
System.Console.Terminfo.Base.$fMonadCapability =
  GHC.Base.D:Monad
    @ System.Console.Terminfo.Base.Capability
    $c>>=_a1Nk
    $c>>_a1NM
    $creturn_a1NT
    $cfail_a1Og

$c>>_a1NM [InlPrag=INLINE (sat-args=2), Occ=LoopBreaker]
  :: forall a_a1Ge b_a1Gf.
     System.Console.Terminfo.Base.Capability a_a1Ge
     -> System.Console.Terminfo.Base.Capability b_a1Gf
     -> System.Console.Terminfo.Base.Capability b_a1Gf
[LclId,
 Str=DmdType,
 Unf=Unf{Src=InlineStable, TopLvl=True, Arity=2, Value=True,
         ConLike=True, WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)
         Tmpl= GHC.Base.$dm>>
                 @ System.Console.Terminfo.Base.Capability
                 System.Console.Terminfo.Base.$fMonadCapability}]
$c>>_a1NM =
  \ (@ a_a1Ge)
    (@ b_a1Gf)
    (eta_B2 :: System.Console.Terminfo.Base.Capability a_a1Ge)
    (eta_B1 :: System.Console.Terminfo.Base.Capability b_a1Gf) ->
    GHC.Base.$dm>>
      @ System.Console.Terminfo.Base.Capability
      System.Console.Terminfo.Base.$fMonadCapability
      @ a_a1Ge
      @ b_a1Gf
      eta_B2
      eta_B1

$cfail_a1Og [Occ=LoopBreaker]
  :: forall a_a1HM.
     GHC.Base.String -> System.Console.Terminfo.Base.Capability a_a1HM
[LclId, Str=DmdType]
$cfail_a1Og =
  GHC.Base.$dmfail
    @ System.Console.Terminfo.Base.Capability
    System.Console.Terminfo.Base.$fMonadCapability
end Rec }

System.Console.Terminfo.Base.$fMonadPlusCapability [InlPrag=[ALWAYS] CONLIKE]
  :: Control.Monad.MonadPlus System.Console.Terminfo.Base.Capability
[LclIdX[DFunId],
 Str=DmdType,
 Unf=DFun: \ ->
       Control.Monad.D:MonadPlus TYPE System.Console.Terminfo.Base.Capability
                                 System.Console.Terminfo.Base.$fMonadCapability
                                 $cmzero_a1MI
                                 $cmplus_a1MY]
System.Console.Terminfo.Base.$fMonadPlusCapability =
  Control.Monad.D:MonadPlus
    @ System.Console.Terminfo.Base.Capability
    System.Console.Terminfo.Base.$fMonadCapability
    $cmzero_a1MI
    $cmplus_a1MY

System.Console.Terminfo.Base.tiGuardFlag
  :: GHC.Base.String -> System.Console.Terminfo.Base.Capability ()
[LclIdX, Str=DmdType]
System.Console.Terminfo.Base.tiGuardFlag =
  \ (cap_a1sh :: GHC.Base.String) ->
    GHC.Base.>>=
      @ System.Console.Terminfo.Base.Capability
      System.Console.Terminfo.Base.$fMonadCapability
      @ GHC.Types.Bool
      @ ()
      (System.Console.Terminfo.Base.tiGetFlag cap_a1sh)
      (Control.Monad.guard
         @ System.Console.Terminfo.Base.Capability
         System.Console.Terminfo.Base.$fMonadPlusCapability)

System.Console.Terminfo.Base.withCurTerm
  :: forall a_a17T.
     System.Console.Terminfo.Base.Terminal
     -> GHC.Types.IO a_a17T -> GHC.Types.IO a_a17T
[LclId, Str=DmdType]
System.Console.Terminfo.Base.withCurTerm =
  \ (@ a_a1Ah)
    (ds_d1QM :: System.Console.Terminfo.Base.Terminal)
    (f_a1lG :: GHC.Types.IO a_a1Ah) ->
    GHC.Base.$
      @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL
         -> GHC.Types.IO a_a1Ah)
      @ (GHC.Types.IO a_a1Ah)
      (Foreign.ForeignPtr.Imp.withForeignPtr
         @ System.Console.Terminfo.Base.TERMINAL
         @ a_a1Ah
         (ds_d1QM
          `cast` (System.Console.Terminfo.Base.NTCo:Terminal[0]
                  :: System.Console.Terminfo.Base.Terminal
                       ~#
                     GHC.ForeignPtr.ForeignPtr System.Console.Terminfo.Base.TERMINAL)))
      (\ (cterm_a1lH
            :: GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL) ->
         GHC.Base.>>=
           @ GHC.Types.IO
           GHC.Base.$fMonadIO
           @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
           @ a_a1Ah
           (Foreign.Storable.peek
              @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
              (Foreign.Storable.$fStorablePtr
                 @ System.Console.Terminfo.Base.TERMINAL)
              System.Console.Terminfo.Base.cur_term)
           (\ (old_term_a1lI
                 :: GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL) ->
              case GHC.Classes./=
                     @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
                     (GHC.Ptr.$fEqPtr @ System.Console.Terminfo.Base.TERMINAL)
                     old_term_a1lI
                     cterm_a1lH
              of _ {
                GHC.Types.False -> f_a1lG;
                GHC.Types.True ->
                  GHC.Base.>>=
                    @ GHC.Types.IO
                    GHC.Base.$fMonadIO
                    @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
                    @ a_a1Ah
                    (System.Console.Terminfo.Base.set_curterm cterm_a1lH)
                    (\ _ ->
                       GHC.Base.>>=
                         @ GHC.Types.IO
                         GHC.Base.$fMonadIO
                         @ a_a1Ah
                         @ a_a1Ah
                         f_a1lG
                         (\ (x_a1lJ :: a_a1Ah) ->
                            GHC.Base.>>=
                              @ GHC.Types.IO
                              GHC.Base.$fMonadIO
                              @ (GHC.Ptr.Ptr System.Console.Terminfo.Base.TERMINAL)
                              @ a_a1Ah
                              (System.Console.Terminfo.Base.set_curterm old_term_a1lI)
                              (\ _ ->
                                 GHC.Base.return
                                   @ GHC.Types.IO GHC.Base.$fMonadIO @ a_a1Ah x_a1lJ)))
              }))

System.Console.Terminfo.Base.getCapability
  :: forall a_a144.
     System.Console.Terminfo.Base.Terminal
     -> System.Console.Terminfo.Base.Capability a_a144
     -> Data.Maybe.Maybe a_a144
[LclIdX, Str=DmdType]
System.Console.Terminfo.Base.getCapability =
  \ (@ a_a1zL)
    (term_a1sc :: System.Console.Terminfo.Base.Terminal)
    (ds_d1QO :: System.Console.Terminfo.Base.Capability a_a1zL) ->
    GHC.Base.$
      @ (GHC.Types.IO (Data.Maybe.Maybe a_a1zL))
      @ (Data.Maybe.Maybe a_a1zL)
      (GHC.IO.unsafePerformIO @ (Data.Maybe.Maybe a_a1zL))
      (System.Console.Terminfo.Base.withCurTerm
         @ (Data.Maybe.Maybe a_a1zL)
         term_a1sc
         ((ds_d1QO
           `cast` (System.Console.Terminfo.Base.NTCo:Capability[0] <a_a1zL>_R
                   :: System.Console.Terminfo.Base.Capability a_a1zL
                        ~#
                      (System.Console.Terminfo.Base.Terminal
                       -> GHC.Types.IO (Data.Maybe.Maybe a_a1zL))))
            term_a1sc))

System.Console.Terminfo.Base.tParm
  :: GHC.Base.String
     -> System.Console.Terminfo.Base.Capability
          ([GHC.Types.Int] -> GHC.Base.String)
[LclId, Str=DmdType]
System.Console.Terminfo.Base.tParm =
  \ (cap_a1sl :: GHC.Base.String) ->
    let {
      tparm'_a1sm
        :: [Foreign.C.Types.CLong] -> GHC.Types.IO [GHC.Types.Char]
      [LclId, Str=DmdType]
      tparm'_a1sm =
        \ (ds_d1QP :: [Foreign.C.Types.CLong]) ->
          let {
            fail_d1QZ
              :: GHC.Prim.State# GHC.Prim.RealWorld
                 -> GHC.Types.IO [GHC.Types.Char]
            [LclId, Str=DmdType]
            fail_d1QZ =
              \ _ ->
                GHC.Base.fail
                  @ GHC.Types.IO
                  GHC.Base.$fMonadIO
                  @ [GHC.Types.Char]
                  (GHC.CString.unpackCString# "tParm: List too short"#) } in
          case ds_d1QP of _ {
            __DEFAULT -> fail_d1QZ GHC.Prim.realWorld#;
            : p1_a1sn ds_d1QQ ->
              case ds_d1QQ of _ {
                __DEFAULT -> fail_d1QZ GHC.Prim.realWorld#;
                : p2_a1so ds_d1QR ->
                  case ds_d1QR of _ {
                    __DEFAULT -> fail_d1QZ GHC.Prim.realWorld#;
                    : p3_a1sp ds_d1QS ->
                      case ds_d1QS of _ {
                        __DEFAULT -> fail_d1QZ GHC.Prim.realWorld#;
                        : p4_a1sq ds_d1QT ->
                          case ds_d1QT of _ {
                            __DEFAULT -> fail_d1QZ GHC.Prim.realWorld#;
                            : p5_a1sr ds_d1QU ->
                              case ds_d1QU of _ {
                                __DEFAULT -> fail_d1QZ GHC.Prim.realWorld#;
                                : p6_a1ss ds_d1QV ->
                                  case ds_d1QV of _ {
                                    __DEFAULT -> fail_d1QZ GHC.Prim.realWorld#;
                                    : p7_a1st ds_d1QW ->
                                      case ds_d1QW of _ {
                                        __DEFAULT -> fail_d1QZ GHC.Prim.realWorld#;
                                        : p8_a1su ds_d1QX ->
                                          case ds_d1QX of _ {
                                            __DEFAULT -> fail_d1QZ GHC.Prim.realWorld#;
                                            : p9_a1sv _ ->
                                              GHC.Base.$
                                                @ (Foreign.C.String.CString
                                                   -> GHC.Types.IO [GHC.Types.Char])
                                                @ (GHC.Types.IO [GHC.Types.Char])
                                                (Foreign.C.String.withCString
                                                   @ [GHC.Types.Char] cap_a1sl)
                                                (\ (c_cap_a1sw :: Foreign.C.String.CString) ->
                                                   GHC.Base.>>=
                                                     @ GHC.Types.IO
                                                     GHC.Base.$fMonadIO
                                                     @ Foreign.C.String.CString
                                                     @ [GHC.Types.Char]
                                                     (System.Console.Terminfo.Base.tparm
                                                        c_cap_a1sw
                                                        p1_a1sn
                                                        p2_a1so
                                                        p3_a1sp
                                                        p4_a1sq
                                                        p5_a1sr
                                                        p6_a1ss
                                                        p7_a1st
                                                        p8_a1su
                                                        p9_a1sv)
                                                     (\ (result_a1sx :: Foreign.C.String.CString) ->
                                                        case GHC.Classes.==
                                                               @ Foreign.C.String.CString
                                                               (GHC.Ptr.$fEqPtr
                                                                  @ Foreign.C.Types.CChar)
                                                               result_a1sx
                                                               (GHC.Ptr.nullPtr
                                                                  @ Foreign.C.Types.CChar)
                                                        of _ {
                                                          GHC.Types.False ->
                                                            Foreign.C.String.peekCString
                                                              result_a1sx;
                                                          GHC.Types.True ->
                                                            GHC.Base.return
                                                              @ GHC.Types.IO
                                                              GHC.Base.$fMonadIO
                                                              @ [GHC.Types.Char]
                                                              (GHC.Types.[] @ GHC.Types.Char)
                                                        }))
                                          }
                                      }
                                  }
                              }
                          }
                      }
                  }
              }
          } } in
    GHC.Base.$
      @ (System.Console.Terminfo.Base.Terminal
         -> GHC.Types.IO
              (Data.Maybe.Maybe ([GHC.Types.Int] -> [GHC.Types.Char])))
      @ (System.Console.Terminfo.Base.Capability
           ([GHC.Types.Int] -> GHC.Base.String))
      (System.Console.Terminfo.Base.Capability
         @ ([GHC.Types.Int] -> [GHC.Types.Char]))
      (\ (t_a1sy :: System.Console.Terminfo.Base.Terminal) ->
         GHC.Base.$
           @ (Data.Maybe.Maybe ([GHC.Types.Int] -> [GHC.Types.Char]))
           @ (GHC.Types.IO
                (Data.Maybe.Maybe ([GHC.Types.Int] -> [GHC.Types.Char])))
           (GHC.Base.return
              @ GHC.Types.IO
              GHC.Base.$fMonadIO
              @ (Data.Maybe.Maybe ([GHC.Types.Int] -> [GHC.Types.Char])))
           (GHC.Base.$
              @ ([GHC.Types.Int] -> [GHC.Types.Char])
              @ (Data.Maybe.Maybe ([GHC.Types.Int] -> [GHC.Types.Char]))
              (Data.Maybe.Just @ ([GHC.Types.Int] -> [GHC.Types.Char]))
              (\ (ps_a1sz :: [GHC.Types.Int]) ->
                 GHC.Base.$
                   @ (GHC.Types.IO [GHC.Types.Char])
                   @ [GHC.Types.Char]
                   (GHC.IO.unsafePerformIO @ [GHC.Types.Char])
                   (GHC.Base.$
                      @ (GHC.Types.IO [GHC.Types.Char])
                      @ (GHC.Types.IO [GHC.Types.Char])
                      (System.Console.Terminfo.Base.withCurTerm
                         @ [GHC.Types.Char] t_a1sy)
                      (tparm'_a1sm
                         (GHC.Base.++
                            @ Foreign.C.Types.CLong
                            (GHC.Base.map
                               @ GHC.Types.Int
                               @ Foreign.C.Types.CLong
                               (GHC.Enum.toEnum
                                  @ Foreign.C.Types.CLong Foreign.C.Types.$fEnumCLong)
                               ps_a1sz)
                            (GHC.List.repeat
                               @ Foreign.C.Types.CLong
                               (GHC.Num.fromInteger
                                  @ Foreign.C.Types.CLong
                                  Foreign.C.Types.$fNumCLong
                                  (__integer 0)))))))))

System.Console.Terminfo.Base.tiGetStr
  :: GHC.Base.String
     -> System.Console.Terminfo.Base.Capability GHC.Base.String
[LclIdX, Str=DmdType]
System.Console.Terminfo.Base.tiGetStr =
  \ (cap_a1si :: GHC.Base.String) ->
    let {
      neg1Ptr_a1sj :: forall b_a1AZ. GHC.Ptr.Ptr b_a1AZ
      [LclId, Str=DmdType]
      neg1Ptr_a1sj =
        \ (@ b_a1B1) ->
          GHC.Ptr.plusPtr
            @ (GHC.Prim.Any *)
            @ b_a1B1
            (GHC.Ptr.nullPtr @ (GHC.Prim.Any *))
            (GHC.Num.negate
               @ GHC.Types.Int GHC.Num.$fNumInt (GHC.Types.I# 1)) } in
    GHC.Base.$
      @ (System.Console.Terminfo.Base.Terminal
         -> GHC.Types.IO (Data.Maybe.Maybe GHC.Base.String))
      @ (System.Console.Terminfo.Base.Capability GHC.Base.String)
      (System.Console.Terminfo.Base.Capability @ GHC.Base.String)
      (GHC.Base.$
         @ (GHC.Types.IO (Data.Maybe.Maybe GHC.Base.String))
         @ (System.Console.Terminfo.Base.Terminal
            -> GHC.Types.IO (Data.Maybe.Maybe GHC.Base.String))
         (GHC.Base.const
            @ (GHC.Types.IO (Data.Maybe.Maybe GHC.Base.String))
            @ System.Console.Terminfo.Base.Terminal)
         (GHC.Base.>>=
            @ GHC.Types.IO
            GHC.Base.$fMonadIO
            @ Foreign.C.String.CString
            @ (Data.Maybe.Maybe GHC.Base.String)
            (Foreign.C.String.withCString
               @ Foreign.C.String.CString
               cap_a1si
               System.Console.Terminfo.Base.tigetstr)
            (\ (result_a1sk :: Foreign.C.String.CString) ->
               case GHC.Classes.||
                      (GHC.Classes.==
                         @ Foreign.C.String.CString
                         (GHC.Ptr.$fEqPtr @ Foreign.C.Types.CChar)
                         result_a1sk
                         (GHC.Ptr.nullPtr @ Foreign.C.Types.CChar))
                      (GHC.Classes.==
                         @ Foreign.C.String.CString
                         (GHC.Ptr.$fEqPtr @ Foreign.C.Types.CChar)
                         result_a1sk
                         (neg1Ptr_a1sj @ Foreign.C.Types.CChar))
               of _ {
                 GHC.Types.False ->
                   GHC.Base.fmap
                     @ GHC.Types.IO
                     GHC.Base.$fFunctorIO
                     @ GHC.Base.String
                     @ (Data.Maybe.Maybe GHC.Base.String)
                     (Data.Maybe.Just @ GHC.Base.String)
                     (Foreign.C.String.peekCString result_a1sk);
                 GHC.Types.True ->
                   GHC.Base.return
                     @ GHC.Types.IO
                     GHC.Base.$fMonadIO
                     @ (Data.Maybe.Maybe GHC.Base.String)
                     (Data.Maybe.Nothing @ GHC.Base.String)
               })))

System.Console.Terminfo.Base.tiGetOutput
  :: GHC.Base.String
     -> System.Console.Terminfo.Base.Capability
          ([GHC.Types.Int]
           -> System.Console.Terminfo.Base.LinesAffected
           -> System.Console.Terminfo.Base.TermOutput)
[LclIdX, Str=DmdType]
System.Console.Terminfo.Base.tiGetOutput =
  \ (cap_a1sA :: GHC.Base.String) ->
    GHC.Base.>>=
      @ System.Console.Terminfo.Base.Capability
      System.Console.Terminfo.Base.$fMonadCapability
      @ GHC.Base.String
      @ ([GHC.Types.Int]
         -> System.Console.Terminfo.Base.LinesAffected
         -> System.Console.Terminfo.Base.TermOutput)
      (System.Console.Terminfo.Base.tiGetStr cap_a1sA)
      (\ (str_a1sB :: GHC.Base.String) ->
         GHC.Base.>>=
           @ System.Console.Terminfo.Base.Capability
           System.Console.Terminfo.Base.$fMonadCapability
           @ ([GHC.Types.Int] -> GHC.Base.String)
           @ ([GHC.Types.Int]
              -> System.Console.Terminfo.Base.LinesAffected
              -> System.Console.Terminfo.Base.TermOutput)
           (System.Console.Terminfo.Base.tParm str_a1sB)
           (\ (f_a1sC :: [GHC.Types.Int] -> GHC.Base.String) ->
              GHC.Base.$
                @ ([GHC.Types.Int]
                   -> System.Console.Terminfo.Base.LinesAffected
                   -> System.Console.Terminfo.Base.TermOutput)
                @ (System.Console.Terminfo.Base.Capability
                     ([GHC.Types.Int]
                      -> System.Console.Terminfo.Base.LinesAffected
                      -> System.Console.Terminfo.Base.TermOutput))
                (GHC.Base.return
                   @ System.Console.Terminfo.Base.Capability
                   System.Console.Terminfo.Base.$fMonadCapability
                   @ ([GHC.Types.Int]
                      -> System.Console.Terminfo.Base.LinesAffected
                      -> System.Console.Terminfo.Base.TermOutput))
                (\ (ps_a1sD :: [GHC.Types.Int])
                   (la_a1sE :: System.Console.Terminfo.Base.LinesAffected) ->
                   GHC.Base.$
                     @ GHC.Base.String
                     @ System.Console.Terminfo.Base.TermOutput
                     (System.Console.Terminfo.Base.fromStr la_a1sE)
                     (f_a1sC ps_a1sD))))

System.Console.Terminfo.Base.tiGetOutput1
  :: forall f_a13B.
     System.Console.Terminfo.Base.OutputCap f_a13B =>
     GHC.Base.String -> System.Console.Terminfo.Base.Capability f_a13B
[LclIdX, Str=DmdType]
System.Console.Terminfo.Base.tiGetOutput1 =
  \ (@ f_a1zt)
    ($dOutputCap_a1IV :: System.Console.Terminfo.Base.OutputCap f_a1zt)
    (str_a1sL :: GHC.Base.String) ->
    GHC.Base.>>=
      @ System.Console.Terminfo.Base.Capability
      System.Console.Terminfo.Base.$fMonadCapability
      @ GHC.Base.String
      @ f_a1zt
      (System.Console.Terminfo.Base.tiGetStr str_a1sL)
      (\ (cap_a1sM :: GHC.Base.String) ->
         GHC.Base.>>
           @ System.Console.Terminfo.Base.Capability
           System.Console.Terminfo.Base.$fMonadCapability
           @ ()
           @ f_a1zt
           (Control.Monad.guard
              @ System.Console.Terminfo.Base.Capability
              System.Console.Terminfo.Base.$fMonadPlusCapability
              (System.Console.Terminfo.Base.hasOkPadding
                 @ f_a1zt $dOutputCap_a1IV (GHC.Err.undefined @ f_a1zt) cap_a1sM))
           (GHC.Base.>>=
              @ System.Console.Terminfo.Base.Capability
              System.Console.Terminfo.Base.$fMonadCapability
              @ ([GHC.Types.Int] -> GHC.Base.String)
              @ f_a1zt
              (System.Console.Terminfo.Base.tParm cap_a1sM)
              (\ (f_a1sN :: [GHC.Types.Int] -> GHC.Base.String) ->
                 GHC.Base.$
                   @ f_a1zt
                   @ (System.Console.Terminfo.Base.Capability f_a1zt)
                   (GHC.Base.return
                      @ System.Console.Terminfo.Base.Capability
                      System.Console.Terminfo.Base.$fMonadCapability
                      @ f_a1zt)
                   (System.Console.Terminfo.Base.outputCap
                      @ f_a1zt $dOutputCap_a1IV f_a1sN (GHC.Types.[] @ GHC.Types.Int)))))

System.Console.Terminfo.Base.tiGetNum
  :: GHC.Base.String
     -> System.Console.Terminfo.Base.Capability GHC.Types.Int
[LclIdX, Str=DmdType]
System.Console.Terminfo.Base.tiGetNum =
  \ (cap_a1se :: GHC.Base.String) ->
    GHC.Base.$
      @ (System.Console.Terminfo.Base.Terminal
         -> GHC.Types.IO (Data.Maybe.Maybe GHC.Types.Int))
      @ (System.Console.Terminfo.Base.Capability GHC.Types.Int)
      (System.Console.Terminfo.Base.Capability @ GHC.Types.Int)
      (GHC.Base.$
         @ (GHC.Types.IO (Data.Maybe.Maybe GHC.Types.Int))
         @ (System.Console.Terminfo.Base.Terminal
            -> GHC.Types.IO (Data.Maybe.Maybe GHC.Types.Int))
         (GHC.Base.const
            @ (GHC.Types.IO (Data.Maybe.Maybe GHC.Types.Int))
            @ System.Console.Terminfo.Base.Terminal)
         (GHC.Base.>>=
            @ GHC.Types.IO
            GHC.Base.$fMonadIO
            @ GHC.Types.Int
            @ (Data.Maybe.Maybe GHC.Types.Int)
            (GHC.Base.fmap
               @ GHC.Types.IO
               GHC.Base.$fFunctorIO
               @ Foreign.C.Types.CInt
               @ GHC.Types.Int
               (GHC.Enum.fromEnum
                  @ Foreign.C.Types.CInt Foreign.C.Types.$fEnumCInt)
               (Foreign.C.String.withCString
                  @ Foreign.C.Types.CInt
                  cap_a1se
                  System.Console.Terminfo.Base.tigetnum))
            (\ (n_a1sf :: GHC.Types.Int) ->
               case GHC.Classes.>=
                      @ GHC.Types.Int GHC.Classes.$fOrdInt n_a1sf (GHC.Types.I# 0)
               of _ {
                 GHC.Types.False ->
                   GHC.Base.return
                     @ GHC.Types.IO
                     GHC.Base.$fMonadIO
                     @ (Data.Maybe.Maybe GHC.Types.Int)
                     (Data.Maybe.Nothing @ GHC.Types.Int);
                 GHC.Types.True ->
                   GHC.Base.return
                     @ GHC.Types.IO
                     GHC.Base.$fMonadIO
                     @ (Data.Maybe.Maybe GHC.Types.Int)
                     (Data.Maybe.Just @ GHC.Types.Int n_a1sf)
               })))

System.Console.Terminfo.Base.tPuts
  :: GHC.Base.String
     -> System.Console.Terminfo.Base.LinesAffected
     -> GHC.Ptr.FunPtr System.Console.Terminfo.Base.CharOutput
     -> GHC.Types.IO ()
[LclId, Str=DmdType]
System.Console.Terminfo.Base.tPuts =
  \ (s_a1sH :: GHC.Base.String)
    (n_a1sI :: System.Console.Terminfo.Base.LinesAffected)
    (putc_a1sJ
       :: GHC.Ptr.FunPtr System.Console.Terminfo.Base.CharOutput) ->
    GHC.Base.$
      @ (Foreign.C.String.CString -> GHC.Types.IO ())
      @ (GHC.Types.IO ())
      (Foreign.C.String.withCString @ () s_a1sH)
      (\ (c_str_a1sK :: Foreign.C.String.CString) ->
         System.Console.Terminfo.Base.tputs
           c_str_a1sK
           (GHC.Enum.toEnum
              @ Foreign.C.Types.CInt Foreign.C.Types.$fEnumCInt n_a1sI)
           putc_a1sJ)

System.Console.Terminfo.Base.writeToTerm
  :: GHC.Ptr.FunPtr System.Console.Terminfo.Base.CharOutput
     -> GHC.IO.Handle.Types.Handle
     -> System.Console.Terminfo.Base.TermOutputType
     -> GHC.Types.IO ()
[LclId, Str=DmdType]
System.Console.Terminfo.Base.writeToTerm =
  \ (putc_a1s6
       :: GHC.Ptr.FunPtr System.Console.Terminfo.Base.CharOutput)
    (h_a1s7 :: GHC.IO.Handle.Types.Handle)
    (ds_d1QH :: System.Console.Terminfo.Base.TermOutputType) ->
    case ds_d1QH of _ {
      System.Console.Terminfo.Base.TOCmd numLines_a1s8 s_a1s9 ->
        case System.Console.Terminfo.Base.strHasPadding s_a1s9 of _ {
          GHC.Types.False ->
            (\ _ -> GHC.IO.Handle.Text.hPutStr h_a1s7 s_a1s9)
              GHC.Prim.realWorld#;
          GHC.Types.True ->
            System.Console.Terminfo.Base.tPuts s_a1s9 numLines_a1s8 putc_a1s6
        };
      System.Console.Terminfo.Base.TOStr s_a1sb ->
        GHC.IO.Handle.Text.hPutStr h_a1s7 s_a1sb
    }

System.Console.Terminfo.Base.hRunTermOutput
  :: GHC.IO.Handle.Types.Handle
     -> System.Console.Terminfo.Base.Terminal
     -> System.Console.Terminfo.Base.TermOutput
     -> GHC.Types.IO ()
[LclIdX, Str=DmdType]
System.Console.Terminfo.Base.hRunTermOutput =
  \ (h_a1mx :: GHC.IO.Handle.Types.Handle)
    (term_a1my :: System.Console.Terminfo.Base.Terminal)
    (ds_d1QN :: System.Console.Terminfo.Base.TermOutput) ->
    GHC.Base.>>=
      @ GHC.Types.IO
      GHC.Base.$fMonadIO
      @ (GHC.Ptr.FunPtr System.Console.Terminfo.Base.CharOutput)
      @ ()
      (System.Console.Terminfo.Base.mkCallback
         ((\ (@ b_a1Gz)
             ($dEnum_a1GA :: GHC.Enum.Enum b_a1Gz)
             (c_a1mB :: b_a1Gz) ->
             GHC.Base.>>
               @ GHC.Types.IO
               GHC.Base.$fMonadIO
               @ ()
               @ b_a1Gz
               (GHC.Base.>>
                  @ GHC.Types.IO
                  GHC.Base.$fMonadIO
                  @ ()
                  @ ()
                  (GHC.IO.Handle.Text.hPutChar
                     h_a1mx
                     (GHC.Base.$
                        @ GHC.Types.Int
                        @ GHC.Types.Char
                        (GHC.Enum.toEnum @ GHC.Types.Char GHC.Enum.$fEnumChar)
                        (GHC.Enum.fromEnum @ b_a1Gz $dEnum_a1GA c_a1mB)))
                  (GHC.IO.Handle.hFlush h_a1mx))
               (GHC.Base.return
                  @ GHC.Types.IO GHC.Base.$fMonadIO @ b_a1Gz c_a1mB))
            @ Foreign.C.Types.CInt Foreign.C.Types.$fEnumCInt))
      (\ (putc_ptr_a1s5
            :: GHC.Ptr.FunPtr System.Console.Terminfo.Base.CharOutput) ->
         GHC.Base.>>
           @ GHC.Types.IO
           GHC.Base.$fMonadIO
           @ ()
           @ ()
           (GHC.Base.$
              @ (GHC.Types.IO ())
              @ (GHC.Types.IO ())
              (System.Console.Terminfo.Base.withCurTerm @ () term_a1my)
              (Control.Monad.mapM_
                 @ System.Console.Terminfo.Base.TermOutputType
                 @ GHC.Types.IO
                 @ ()
                 GHC.Base.$fMonadIO
                 (System.Console.Terminfo.Base.writeToTerm putc_ptr_a1s5 h_a1mx)
                 ((ds_d1QN
                   `cast` (System.Console.Terminfo.Base.NTCo:TermOutput[0]
                           :: System.Console.Terminfo.Base.TermOutput
                                ~#
                              ([System.Console.Terminfo.Base.TermOutputType]
                               -> [System.Console.Terminfo.Base.TermOutputType])))
                    (GHC.Types.[] @ System.Console.Terminfo.Base.TermOutputType))))
           (GHC.Base.>>
              @ GHC.Types.IO
              GHC.Base.$fMonadIO
              @ ()
              @ ()
              (Foreign.Ptr.freeHaskellFunPtr
                 @ System.Console.Terminfo.Base.CharOutput putc_ptr_a1s5)
              (GHC.IO.Handle.hFlush h_a1mx)))

System.Console.Terminfo.Base.runTermOutput
  :: System.Console.Terminfo.Base.Terminal
     -> System.Console.Terminfo.Base.TermOutput -> GHC.Types.IO ()
[LclIdX, Str=DmdType]
System.Console.Terminfo.Base.runTermOutput =
  System.Console.Terminfo.Base.hRunTermOutput GHC.IO.Handle.FD.stdout

*** End of Offense ***


Reply | Threaded
Open this post in threaded view
|

Cannot compile phase 2 after recent Roles patch

Richard Eisenberg-2
It looks to me that the problem is caused by an outdated libraries/base repo. Have you run ./sync-all pull? In particular, your libraries/base repo needs to be at ab9e8e3? or later.

Let me know if this was indeed the problem!

Thanks,
Richard

On Aug 11, 2013, at 2:21 AM, Dr. ERDI Gergo wrote:

> Hi,
>
> I cannot compile GHC starting from e8aa8ccb 'Implement "roles" into GHC'. The error message I get is:
>
>>>>>>>>>>>>>>>>>>>>>>>>>>
> *** Core Lint errors : in result of Desugar (after optimization) ***
> {-# LINE 290 "libraries/terminfo/System/Console/Terminfo/Base.hs #-}: Warning:
>    [RHS of System.Console.Terminfo.Base.mkCallback ::
>    System.Console.Terminfo.Base.CharOutput ->
>        GHC.Types.IO (GHC.Ptr.FunPtr System.Console.Terminfo.Base.CharOutput)]
>
>    Role incompatibility: expected P, got R
>    in Sym Foreign.C.Types.NTCo:CInt[0]
>       -> (GHC.Types.IO (Sym Foreign.C.Types.NTCo:CInt[0]))_R
> <<<<<<<<<<<<<<<<<<<<<<<<
>
> followed by a dump of Core (see attached).
>
> --
>
>  .--= ULLA! =-----------------.
>   \     http://gergo.erdi.hu   \
>    `---= gergo at erdi.hu =-------'
> chown -R us.us yourbase (#gnome)<ghclog.txt>_______________________________________________
> ghc-devs mailing list
> ghc-devs at haskell.org
> http://www.haskell.org/mailman/listinfo/ghc-devs




Reply | Threaded
Open this post in threaded view
|

Cannot compile phase 2 after recent Roles patch

Dr. ERDI Gergo
On Sun, 11 Aug 2013, Richard Eisenberg wrote:

> It looks to me that the problem is caused by an outdated libraries/base
> repo. Have you run ./sync-all pull? In particular, your libraries/base
> repo needs to be at ab9e8e3? or later.
>
> Let me know if this was indeed the problem!

Yes, thanks! I only knew about 'sync-all get', I thought something like
'git submodule update' would take care of all the other stuff. Sorry for
the noise!

--

   .--= ULLA! =-----------------.
    \     http://gergo.erdi.hu   \
     `---= gergo at erdi.hu =-------'
Gendo : Rei, you're a nude girl in a test tube. I like that.