T54.ghc710.template

Singletons/T54.hs:(0,0)-(0,0): Splicing declarations
    singletons
      [d| g :: Bool -> Bool
          g e = (case [not] of { [_] -> not }) e |]
  ======>
    g :: Bool -> Bool
    g e = case [not] of { [_] -> not } e
    type Let0123456789Scrutinee_0123456789Sym1 t =
        Let0123456789Scrutinee_0123456789 t
    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where
      suppressUnusedWarnings _
        = snd
            (GHC.Tuple.(,)
               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())
    data Let0123456789Scrutinee_0123456789Sym0 l
      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>
        Let0123456789Scrutinee_0123456789Sym0KindInference
    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l
    type family Let0123456789Scrutinee_0123456789 e where
      Let0123456789Scrutinee_0123456789 e = Apply (Apply (:$) NotSym0) '[]
    type family Case_0123456789 e t where
      Case_0123456789 e '[_z_0123456789] = NotSym0
    type GSym1 (t :: Bool) = G t
    instance SuppressUnusedWarnings GSym0 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) GSym0KindInference GHC.Tuple.())
    data GSym0 (l :: TyFun Bool Bool)
      = forall arg. KindOf (Apply GSym0 arg) ~ KindOf (GSym1 arg) =>
        GSym0KindInference
    type instance Apply GSym0 l = GSym1 l
    type family G (a :: Bool) :: Bool where
      G e = Apply (Case_0123456789 e (Let0123456789Scrutinee_0123456789Sym1 e)) e
    sG :: forall (t :: Bool). Sing t -> Sing (Apply GSym0 t :: Bool)
    sG sE
      = let
          lambda :: forall e. t ~ e => Sing e -> Sing (Apply GSym0 t :: Bool)
          lambda e
            = applySing
                (let
                   sScrutinee_0123456789 ::
                     Sing (Let0123456789Scrutinee_0123456789Sym1 e)
                   sScrutinee_0123456789
                     = applySing
                         (applySing
                            (singFun2 (Proxy :: Proxy (:$)) SCons)
                            (singFun1 (Proxy :: Proxy NotSym0) sNot))
                         SNil
                 in  case sScrutinee_0123456789 of {
                       SCons _s_z_0123456789 SNil
                         -> let
                              lambda ::
                                forall _z_0123456789. Apply (Apply (:$) _z_0123456789) '[] ~ Let0123456789Scrutinee_0123456789Sym1 e =>
                                Sing _z_0123456789
                                -> Sing (Case_0123456789 e (Apply (Apply (:$) _z_0123456789) '[]))
                              lambda _z_0123456789 = singFun1 (Proxy :: Proxy NotSym0) sNot
                            in lambda _s_z_0123456789 } ::
                       Sing (Case_0123456789 e (Let0123456789Scrutinee_0123456789Sym1 e)))
                e
        in lambda sE