singletons-2.0: tests/compile-and-dump/Singletons/T29.ghc710.template

Singletons/T29.hs:(0,0)-(0,0): Splicing declarations
    singletons
      [d| foo :: Bool -> Bool
          foo x = not $ x
          bar :: Bool -> Bool
          bar x = not . not . not $ x
          baz :: Bool -> Bool
          baz x = not $! x
          ban :: Bool -> Bool
          ban x = not . not . not $! x |]
  ======>
    foo :: Bool -> Bool
    foo x = (not $ x)
    bar :: Bool -> Bool
    bar x = ((not . (not . not)) $ x)
    baz :: Bool -> Bool
    baz x = (not $! x)
    ban :: Bool -> Bool
    ban x = ((not . (not . not)) $! x)
    type BanSym1 (t :: Bool) = Ban t
    instance SuppressUnusedWarnings BanSym0 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) BanSym0KindInference GHC.Tuple.())
    data BanSym0 (l :: TyFun Bool Bool)
      = forall arg. KindOf (Apply BanSym0 arg) ~ KindOf (BanSym1 arg) =>
        BanSym0KindInference
    type instance Apply BanSym0 l = BanSym1 l
    type BazSym1 (t :: Bool) = Baz t
    instance SuppressUnusedWarnings BazSym0 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) BazSym0KindInference GHC.Tuple.())
    data BazSym0 (l :: TyFun Bool Bool)
      = forall arg. KindOf (Apply BazSym0 arg) ~ KindOf (BazSym1 arg) =>
        BazSym0KindInference
    type instance Apply BazSym0 l = BazSym1 l
    type BarSym1 (t :: Bool) = Bar t
    instance SuppressUnusedWarnings BarSym0 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.())
    data BarSym0 (l :: TyFun Bool Bool)
      = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) =>
        BarSym0KindInference
    type instance Apply BarSym0 l = BarSym1 l
    type FooSym1 (t :: Bool) = Foo t
    instance SuppressUnusedWarnings FooSym0 where
      suppressUnusedWarnings _
        = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.())
    data FooSym0 (l :: TyFun Bool Bool)
      = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) =>
        FooSym0KindInference
    type instance Apply FooSym0 l = FooSym1 l
    type family Ban (a :: Bool) :: Bool where
      Ban x = Apply (Apply ($!$) (Apply (Apply (:.$) NotSym0) (Apply (Apply (:.$) NotSym0) NotSym0))) x
    type family Baz (a :: Bool) :: Bool where
      Baz x = Apply (Apply ($!$) NotSym0) x
    type family Bar (a :: Bool) :: Bool where
      Bar x = Apply (Apply ($$) (Apply (Apply (:.$) NotSym0) (Apply (Apply (:.$) NotSym0) NotSym0))) x
    type family Foo (a :: Bool) :: Bool where
      Foo x = Apply (Apply ($$) NotSym0) x
    sBan ::
      forall (t :: Bool). Sing t -> Sing (Apply BanSym0 t :: Bool)
    sBaz ::
      forall (t :: Bool). Sing t -> Sing (Apply BazSym0 t :: Bool)
    sBar ::
      forall (t :: Bool). Sing t -> Sing (Apply BarSym0 t :: Bool)
    sFoo ::
      forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: Bool)
    sBan sX
      = let
          lambda ::
            forall x. t ~ x => Sing x -> Sing (Apply BanSym0 x :: Bool)
          lambda x
            = applySing
                (applySing
                   (singFun2 (Proxy :: Proxy ($!$)) (%$!))
                   (applySing
                      (applySing
                         (singFun3 (Proxy :: Proxy (:.$)) (%:.))
                         (singFun1 (Proxy :: Proxy NotSym0) sNot))
                      (applySing
                         (applySing
                            (singFun3 (Proxy :: Proxy (:.$)) (%:.))
                            (singFun1 (Proxy :: Proxy NotSym0) sNot))
                         (singFun1 (Proxy :: Proxy NotSym0) sNot))))
                x
        in lambda sX
    sBaz sX
      = let
          lambda ::
            forall x. t ~ x => Sing x -> Sing (Apply BazSym0 x :: Bool)
          lambda x
            = applySing
                (applySing
                   (singFun2 (Proxy :: Proxy ($!$)) (%$!))
                   (singFun1 (Proxy :: Proxy NotSym0) sNot))
                x
        in lambda sX
    sBar sX
      = let
          lambda ::
            forall x. t ~ x => Sing x -> Sing (Apply BarSym0 x :: Bool)
          lambda x
            = applySing
                (applySing
                   (singFun2 (Proxy :: Proxy ($$)) (%$))
                   (applySing
                      (applySing
                         (singFun3 (Proxy :: Proxy (:.$)) (%:.))
                         (singFun1 (Proxy :: Proxy NotSym0) sNot))
                      (applySing
                         (applySing
                            (singFun3 (Proxy :: Proxy (:.$)) (%:.))
                            (singFun1 (Proxy :: Proxy NotSym0) sNot))
                         (singFun1 (Proxy :: Proxy NotSym0) sNot))))
                x
        in lambda sX
    sFoo sX
      = let
          lambda ::
            forall x. t ~ x => Sing x -> Sing (Apply FooSym0 x :: Bool)
          lambda x
            = applySing
                (applySing
                   (singFun2 (Proxy :: Proxy ($$)) (%$))
                   (singFun1 (Proxy :: Proxy NotSym0) sNot))
                x
        in lambda sX