diff --git a/CHANGES.md b/CHANGES.md --- a/CHANGES.md +++ b/CHANGES.md @@ -1,6 +1,48 @@ Changelog for the `singletons-base` project =========================================== +3.1 [2021.10.30] +---------------- +* Require building with GHC 9.2. +* `singletons-base` now supports type-level `Char`s, a feature added in + GHC 9.2. In particular: + + * Promoting and singling character literal expressions (e.g., `f = 'a'`) is + now supported. Promoting (but not singling) character patterns + (e.g., `g 'a' = ()`) is also supported. + * `GHC.TypeLits.Singletons` now offers singled versions of the `ConsSymbol`, + `UnconsSymbol`, `CharToNat`, and `NatToChar` type families that were + introduced to `GHC.TypeLits` in GHC 9.2. + * `Text.Show.Singletons` now makes use of type-level `Char`s, a feature added + in GHC 9.2. As a result, there is no longer any need for the `SChar` type + synonym, so it has been removed. + * The `PShow` and `SShow` instances for `Symbol` now display escape characters + properly rather than returning the input `Symbol` unchanged. + +* In GHC 9.2, `Nat` is now a synonym for `Natural`. As a result, the bogus + `Num`, `Eq`, `Ord`, `Enum`, and `Show` instances for `Nat` in + `GHC.TypeLits.Singletons` have been removed, as they have replaced by the + corresponding instances for `Natural`. +* Add `Data.Functor.{Compose,Product,Sum}.Singletons`. +* The types of various entities in `Data.Functor.Const.Singletons` and + `Data.Proxy.Singletons` have been tweaked slightly such that their + specificities match their term-level counterparts: + + ```diff + -SConst :: forall {k} {a} {b :: k} (x :: a). Sing x -> Sing ('Const @a @b x) + +SConst :: forall {k} a (b :: k) (x :: a). Sing x -> Sing ('Const @a @b x) + + -type ConstSym0 :: forall k a (b :: k). a ~> Const a b + +type ConstSym0 :: forall {k} a (b :: k). a ~> Const a b + + -type ConstSym1 :: forall k a (b :: k). a -> Const a b + +type ConstSym1 :: forall {k} a (b :: k). a -> Const a b + + -type ProxySym0 :: forall k (t :: k). Proxy t + +type ProxySym0 :: forall {k} (t :: k). Proxy t + ``` +* Define instances of `SingI1` and `SingI2` when possible. + 3.0 [2021.03.12] ---------------- * The `singletons` library has been split into three libraries: diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -18,7 +18,7 @@ `singletons-base` uses code that relies on bleeding-edge GHC language extensions. As such, `singletons-base` only supports the latest major version -of GHC (currently GHC 9.0). For more information, +of GHC (currently GHC 9.2). For more information, consult the `singletons` [`README`](https://github.com/goldfirere/singletons/blob/master/README.md). diff --git a/Setup.hs b/Setup.hs --- a/Setup.hs +++ b/Setup.hs @@ -3,7 +3,7 @@ import Control.Monad -import Data.List +import qualified Data.List as List import Data.String import Distribution.PackageDescription @@ -128,8 +128,8 @@ -- -- Note: we `nub`, because it's unclear if that's ok to have duplicate -- modules in the lists. - om' = nub $ mn : om - am' = nub $ mn : am + om' = List.nub $ mn : om + am' = List.nub $ mn : am mn = fromString buildSingletonsBaseModule diff --git a/singletons-base.cabal b/singletons-base.cabal --- a/singletons-base.cabal +++ b/singletons-base.cabal @@ -1,5 +1,5 @@ name: singletons-base -version: 3.0 +version: 3.1 cabal-version: 1.24 synopsis: A promoted and singled version of the base library homepage: http://www.github.com/goldfirere/singletons @@ -8,7 +8,7 @@ maintainer: Ryan Scott bug-reports: https://github.com/goldfirere/singletons/issues stability: experimental -tested-with: GHC == 9.0.1 +tested-with: GHC == 9.2.1 extra-source-files: README.md, CHANGES.md, tests/README.md, tests/compile-and-dump/GradingClient/*.hs, tests/compile-and-dump/InsertionSort/*.hs, @@ -38,7 +38,7 @@ . @singletons-base@ uses code that relies on bleeding-edge GHC language extensions. As such, @singletons-base@ only supports the latest major version - of GHC (currently GHC 9.0). For more information, + of GHC (currently GHC 9.2). For more information, consult the @singletons@ @@. . @@ -55,7 +55,7 @@ type: git location: https://github.com/goldfirere/singletons.git subdir: singletons-base - tag: v3.0 + tag: v3.1 source-repository head type: git @@ -65,20 +65,20 @@ custom-setup setup-depends: - base >= 4.15 && < 4.16, - Cabal >= 3.0 && < 3.5, + base >= 4.16 && < 4.17, + Cabal >= 3.0 && < 3.7, directory >= 1, filepath >= 1.3 library hs-source-dirs: src - build-depends: base >= 4.15 && < 4.16, + build-depends: base >= 4.16 && < 4.17, pretty, - singletons == 3.0.*, - singletons-th == 3.0.*, - template-haskell >= 2.17 && < 2.18, + singletons == 3.0.1, + singletons-th == 3.1.*, + template-haskell >= 2.18 && < 2.19, text >= 1.2, - th-desugar >= 1.12 && < 1.13 + th-desugar >= 1.13 && < 1.14 default-language: Haskell2010 other-extensions: TemplateHaskell exposed-modules: Data.Singletons.Base.CustomStar @@ -97,9 +97,12 @@ Data.Eq.Singletons Data.Foldable.Singletons Data.Function.Singletons + Data.Functor.Compose.Singletons Data.Functor.Const.Singletons Data.Functor.Identity.Singletons + Data.Functor.Product.Singletons Data.Functor.Singletons + Data.Functor.Sum.Singletons Data.List.Singletons Data.List.NonEmpty.Singletons Data.Maybe.Singletons @@ -150,7 +153,7 @@ main-is: SingletonsBaseTestSuite.hs other-modules: SingletonsBaseTestSuiteUtils - build-depends: base >= 4.15 && < 4.16, + build-depends: base >= 4.16 && < 4.17, bytestring >= 0.10.9, deepseq >= 1.4.4, filepath >= 1.3, diff --git a/src/Control/Monad/Singletons.hs b/src/Control/Monad/Singletons.hs --- a/src/Control/Monad/Singletons.hs +++ b/src/Control/Monad/Singletons.hs @@ -212,21 +212,21 @@ -- -| @'replicateM' n act@ performs the action @n@ times, -- gathering the results. - replicateM :: forall m a. (Applicative m) => Nat -> m a -> m [a] + replicateM :: forall m a. (Applicative m) => Natural -> m a -> m [a] replicateM cnt0 f = loop cnt0 where - loop :: Nat -> m [a] + loop :: Natural -> m [a] loop cnt | cnt <= 0 = pure [] | otherwise = liftA2 (:) f (loop (cnt - 1)) -- -| Like 'replicateM', but discards the result. - replicateM_ :: forall m a. (Applicative m) => Nat -> m a -> m () + replicateM_ :: forall m a. (Applicative m) => Natural -> m a -> m () replicateM_ cnt0 f = loop cnt0 where - loop :: Nat -> m () + loop :: Natural -> m () loop cnt | cnt <= 0 = pure () | otherwise = f *> loop (cnt - 1) diff --git a/src/Data/Bool/Singletons.hs b/src/Data/Bool/Singletons.hs --- a/src/Data/Bool/Singletons.hs +++ b/src/Data/Bool/Singletons.hs @@ -104,3 +104,9 @@ sing = singFun2 $ sIf (sing @c) instance (SingI c, SingI t) => SingI (IfSym2 c t) where sing = singFun1 $ sIf (sing @c) (sing @t) +instance SingI1 IfSym1 where + liftSing s = singFun2 $ sIf s +instance SingI c => SingI1 (IfSym2 c) where + liftSing s = singFun1 $ sIf (sing @c) s +instance SingI2 IfSym2 where + liftSing2 s1 s2 = singFun1 $ sIf s1 s2 diff --git a/src/Data/Eq/Singletons.hs b/src/Data/Eq/Singletons.hs --- a/src/Data/Eq/Singletons.hs +++ b/src/Data/Eq/Singletons.hs @@ -87,7 +87,7 @@ -- @ -- -- 'DefaultEq' is most suited for data types that are not inductively defined. --- Three concrete examples of this are 'Lit.Nat', 'Lit.Symbol', and +-- Four concrete examples of this are 'Natural', 'Lit.Symbol', 'Lit.Char', and -- 'Kind.Type'. One cannot implement boolean equality for these types by -- pattern matching alone, so 'DefaultEq' is a good fit instead. -- diff --git a/src/Data/Foldable/Singletons.hs b/src/Data/Foldable/Singletons.hs --- a/src/Data/Foldable/Singletons.hs +++ b/src/Data/Foldable/Singletons.hs @@ -351,7 +351,7 @@ -- -| Returns the size/length of a finite structure as an 'Int'. The -- default implementation is optimized for structures that are similar to -- cons-lists, because there is no general way to do better. - length :: t a -> Nat + length :: t a -> Natural length = foldl' (\c _ -> c+1) 0 -- -| Does the element occur in the structure? @@ -466,7 +466,7 @@ -- kind-polymorphic, but Length is only defined when `a` is of kind -- `Type`! Ugh. To force GHC to come to its senses, we explicitly inform -- it that `a :: Type` through our own instance signature. - length :: forall (a :: Type). Proxy a -> Nat + length :: forall (a :: Type). Proxy a -> Natural length _ = 0 null :: forall (a :: Type). Proxy a -> Bool diff --git a/src/Data/Functor/Compose/Singletons.hs b/src/Data/Functor/Compose/Singletons.hs new file mode 100644 --- /dev/null +++ b/src/Data/Functor/Compose/Singletons.hs @@ -0,0 +1,99 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE PolyKinds #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE StandaloneKindSignatures #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE UndecidableInstances #-} +{-# OPTIONS_GHC -Wno-orphans #-} + +----------------------------------------------------------------------------- +-- | +-- Module : Data.Functor.Compose.Singletons +-- Copyright : (C) 2021 Ryan Scott +-- License : BSD-style (see LICENSE) +-- Maintainer : Richard Eisenberg (rae@cs.brynmawr.edu) +-- Stability : experimental +-- Portability : non-portable +-- +-- Exports the promoted and singled versions of the 'Compose' data type. +-- +----------------------------------------------------------------------------- + +module Data.Functor.Compose.Singletons ( + -- * The 'Compose' singleton + Sing, SCompose(..), GetCompose, sGetCompose, + + -- * Defunctionalization symbols + ComposeSym0, ComposeSym1, + GetComposeSym0, GetComposeSym1 + ) where + +import Control.Applicative +import Control.Applicative.Singletons +import Data.Foldable.Singletons +import Data.Functor.Compose +import Data.Functor.Singletons +import Data.Kind +import Data.Singletons +import Data.Singletons.TH +import Data.Traversable.Singletons + +{- +In order to keep the type arguments to Compose poly-kinded and with inferred +specificities, we define the singleton version of Compose, as well as its +defunctionalization symbols, by hand. This is very much in the spirit of the +code in Data.Functor.Const.Singletons. (See the comments above SConst in that +module for more details on this choice.) +-} +infixr 9 `SCompose` +type SCompose :: Compose f g a -> Type +data SCompose :: Compose f g a -> Type where + SCompose :: forall f g a (x :: f (g a)). + Sing x -> SCompose ('Compose @f @g @a x) +type instance Sing = SCompose +instance SingI x => SingI ('Compose x) where + sing = SCompose sing +instance SingI1 'Compose where + liftSing = SCompose + +infixr 9 `ComposeSym0` +type ComposeSym0 :: f (g a) ~> Compose f g a +data ComposeSym0 z +type instance Apply ComposeSym0 x = 'Compose x +instance SingI ComposeSym0 where + sing = singFun1 SCompose + +infixr 9 `ComposeSym1` +type ComposeSym1 :: f (g a) -> Compose f g a +type family ComposeSym1 x where + ComposeSym1 x = 'Compose x + +$(singletonsOnly [d| + getCompose :: Compose f g a -> f (g a) + getCompose (Compose x) = x + + instance (Functor f, Functor g) => Functor (Compose f g) where + fmap f (Compose x) = Compose (fmap (fmap f) x) + a <$ (Compose x) = Compose (fmap (a <$) x) + + instance (Foldable f, Foldable g) => Foldable (Compose f g) where + foldMap f (Compose t) = foldMap (foldMap f) t + + instance (Traversable f, Traversable g) => Traversable (Compose f g) where + traverse f (Compose t) = Compose <$> traverse (traverse f) t + + instance (Applicative f, Applicative g) => Applicative (Compose f g) where + pure x = Compose (pure (pure x)) + Compose f <*> Compose x = Compose (liftA2 (<*>) f x) + liftA2 f (Compose x) (Compose y) = + Compose (liftA2 (liftA2 f) x y) + + instance (Alternative f, Applicative g) => Alternative (Compose f g) where + empty = Compose empty + Compose x <|> Compose y = Compose (x <|> y) + |]) diff --git a/src/Data/Functor/Const/Singletons.hs b/src/Data/Functor/Const/Singletons.hs --- a/src/Data/Functor/Const/Singletons.hs +++ b/src/Data/Functor/Const/Singletons.hs @@ -68,14 +68,19 @@ Assumes that `b` is of kind Type. Until we get a more reliable story for poly-kinded Sing instances (see #150), we simply write the singleton type by -hand. Note that we cannot use genSingletons to generate this code because we +hand. + +Note that we cannot use genSingletons to generate this code because we would end up with the wrong specificity for the kind of `a` when singling the Const constructor. See Note [Preserve the order of type variables during -singling] in D.S.TH.Single.Type, wrinkle 2. +singling] in D.S.TH.Single.Type, wrinkle 2. Similarly, we must define the +defunctionalization symbols for the Const data constructor by hand to get the +specificities right. -} type SConst :: Const a b -> Type data SConst :: Const a b -> Type where - SConst :: Sing a -> SConst ('Const a) + SConst :: forall {k} a (b :: k) (x :: a). + Sing x -> SConst ('Const @a @b x) type instance Sing = SConst instance SingKind a => SingKind (Const a b) where type Demote (Const a b) = Const (Demote a) b @@ -83,10 +88,18 @@ toSing (Const a) = withSomeSing a $ SomeSing . SConst instance SingI a => SingI ('Const a) where sing = SConst sing +instance SingI1 'Const where + liftSing = SConst -$(genDefunSymbols [''Const]) +type ConstSym0 :: a ~> Const a b +data ConstSym0 z +type instance Apply ConstSym0 x = 'Const x instance SingI ConstSym0 where sing = singFun1 SConst + +type ConstSym1 :: a -> Const a b +type family ConstSym1 x where + ConstSym1 x = 'Const x $(singletonsOnly [d| getConst :: Const a b -> a diff --git a/src/Data/Functor/Product/Singletons.hs b/src/Data/Functor/Product/Singletons.hs new file mode 100644 --- /dev/null +++ b/src/Data/Functor/Product/Singletons.hs @@ -0,0 +1,119 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE PolyKinds #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE StandaloneKindSignatures #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE UndecidableInstances #-} +{-# OPTIONS_GHC -Wno-orphans #-} + +----------------------------------------------------------------------------- +-- | +-- Module : Data.Functor.Product.Singletons +-- Copyright : (C) 2021 Ryan Scott +-- License : BSD-style (see LICENSE) +-- Maintainer : Richard Eisenberg (rae@cs.brynmawr.edu) +-- Stability : experimental +-- Portability : non-portable +-- +-- Exports the promoted and singled versions of the 'Product' data type. +-- +----------------------------------------------------------------------------- + +module Data.Functor.Product.Singletons ( + -- * The 'Product' singleton + Sing, SProduct(..), + + -- * Defunctionalization symbols + PairSym0, PairSym1, PairSym2 + ) where + +import Control.Applicative +import Control.Applicative.Singletons +import Control.Monad +import Control.Monad.Singletons +import Control.Monad.Zip +import Control.Monad.Zip.Singletons +import Data.Foldable.Singletons hiding (Product) +import Data.Function.Singletons +import Data.Functor.Product +import Data.Kind +import Data.Monoid.Singletons hiding (SProduct(..)) +import Data.Singletons +import Data.Singletons.TH +import Data.Traversable.Singletons + +{- +In order to keep the type arguments to Product poly-kinded and with inferred +specificities, we define the singleton version of Product, as well as its +defunctionalization symbols, by hand. This is very much in the spirit of the +code in Data.Functor.Const.Singletons. (See the comments above SConst in that +module for more details on this choice.) +-} +type SProduct :: Product f g a -> Type +data SProduct :: Product f g a -> Type where + SPair :: forall f g a (x :: f a) (y :: g a). + Sing x -> Sing y -> SProduct ('Pair @f @g @a x y) +type instance Sing = SProduct +instance (SingI x, SingI y) => SingI ('Pair x y) where + sing = SPair sing sing +instance SingI x => SingI1 ('Pair x) where + liftSing = SPair sing +instance SingI2 'Pair where + liftSing2 = SPair + +type PairSym0 :: forall f g a. f a ~> g a ~> Product f g a +data PairSym0 z +type instance Apply PairSym0 x = PairSym1 x +instance SingI PairSym0 where + sing = singFun2 SPair + +type PairSym1 :: forall f g a. f a -> g a ~> Product f g a +data PairSym1 fa z +type instance Apply (PairSym1 x) y = 'Pair x y +instance SingI x => SingI (PairSym1 x) where + sing = singFun1 $ SPair (sing @x) +instance SingI1 PairSym1 where + liftSing s = singFun1 $ SPair s + +type PairSym2 :: forall f g a. f a -> g a -> Product f g a +type family PairSym2 x y where + PairSym2 x y = 'Pair x y + +$(singletonsOnly [d| + instance (Functor f, Functor g) => Functor (Product f g) where + fmap f (Pair x y) = Pair (fmap f x) (fmap f y) + a <$ (Pair x y) = Pair (a <$ x) (a <$ y) + + instance (Foldable f, Foldable g) => Foldable (Product f g) where + foldMap f (Pair x y) = foldMap f x `mappend` foldMap f y + + instance (Traversable f, Traversable g) => Traversable (Product f g) where + traverse f (Pair x y) = liftA2 Pair (traverse f x) (traverse f y) + + instance (Applicative f, Applicative g) => Applicative (Product f g) where + pure x = Pair (pure x) (pure x) + Pair f g <*> Pair x y = Pair (f <*> x) (g <*> y) + liftA2 f (Pair a b) (Pair x y) = Pair (liftA2 f a x) (liftA2 f b y) + + instance (Alternative f, Alternative g) => Alternative (Product f g) where + empty = Pair empty empty + Pair x1 y1 <|> Pair x2 y2 = Pair (x1 <|> x2) (y1 <|> y2) + + instance (Monad f, Monad g) => Monad (Product f g) where + Pair m n >>= f = Pair (m >>= fstP . f) (n >>= sndP . f) + where + fstP (Pair a _) = a + sndP (Pair _ b) = b + + instance (MonadPlus f, MonadPlus g) => MonadPlus (Product f g) where + mzero = Pair mzero mzero + Pair x1 y1 `mplus` Pair x2 y2 = Pair (x1 `mplus` x2) (y1 `mplus` y2) + + instance (MonadZip f, MonadZip g) => MonadZip (Product f g) where + mzipWith f (Pair x1 y1) (Pair x2 y2) = Pair (mzipWith f x1 x2) (mzipWith f y1 y2) + |]) diff --git a/src/Data/Functor/Sum/Singletons.hs b/src/Data/Functor/Sum/Singletons.hs new file mode 100644 --- /dev/null +++ b/src/Data/Functor/Sum/Singletons.hs @@ -0,0 +1,102 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE PolyKinds #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE StandaloneKindSignatures #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE UndecidableInstances #-} +{-# OPTIONS_GHC -Wno-orphans #-} + +----------------------------------------------------------------------------- +-- | +-- Module : Data.Functor.Sum.Singletons +-- Copyright : (C) 2021 Ryan Scott +-- License : BSD-style (see LICENSE) +-- Maintainer : Richard Eisenberg (rae@cs.brynmawr.edu) +-- Stability : experimental +-- Portability : non-portable +-- +-- Exports the promoted and singled versions of the 'Sum' data type. +-- +----------------------------------------------------------------------------- + +module Data.Functor.Sum.Singletons ( + -- * The 'Product' singleton + Sing, SSum(..), + + -- * Defunctionalization symbols + InLSym0, InLSym1, + InRSym0, InRSym1, + ) where + +import Data.Foldable.Singletons hiding (Sum) +import Data.Functor.Singletons +import Data.Functor.Sum +import Data.Kind +import Data.Singletons +import Data.Singletons.TH +import Data.Traversable.Singletons + +{- +In order to keep the type arguments to Sum poly-kinded and with inferred +specificities, we define the singleton version of Sum, as well as its +defunctionalization symbols, by hand. This is very much in the spirit of the +code in Data.Functor.Const.Singletons. (See the comments above SConst in that +module for more details on this choice.) +-} +type SSum :: Sum f g a -> Type +data SSum :: Sum f g a -> Type where + SInL :: forall f g a (x :: f a). + Sing x -> SSum ('InL @f @g @a x) + SInR :: forall f g a (y :: g a). + Sing y -> SSum ('InR @f @g @a y) +type instance Sing = SSum +instance SingI x => SingI ('InL x) where + sing = SInL sing +instance SingI1 'InL where + liftSing = SInL +instance SingI y => SingI ('InR y) where + sing = SInR sing +instance SingI1 'InR where + liftSing = SInR + +type InLSym0 :: forall f g a. f a ~> Sum f g a +data InLSym0 z +type instance Apply InLSym0 x = 'InL x +instance SingI InLSym0 where + sing = singFun1 SInL + +type InLSym1 :: forall f g a. f a -> Sum f g a +type family InLSym1 x where + InLSym1 x = 'InL x + +type InRSym0 :: forall f g a. g a ~> Sum f g a +data InRSym0 z +type instance Apply InRSym0 y = 'InR y +instance SingI InRSym0 where + sing = singFun1 SInR + +type InRSym1 :: forall f g a. g a -> Sum f g a +type family InRSym1 x where + InRSym1 y = 'InR y + +$(singletonsOnly [d| + instance (Functor f, Functor g) => Functor (Sum f g) where + fmap f (InL x) = InL (fmap f x) + fmap f (InR y) = InR (fmap f y) + + a <$ (InL x) = InL (a <$ x) + a <$ (InR y) = InR (a <$ y) + + instance (Foldable f, Foldable g) => Foldable (Sum f g) where + foldMap f (InL x) = foldMap f x + foldMap f (InR y) = foldMap f y + + instance (Traversable f, Traversable g) => Traversable (Sum f g) where + traverse f (InL x) = InL <$> traverse f x + traverse f (InR y) = InR <$> traverse f y + |]) diff --git a/src/Data/List/NonEmpty/Singletons.hs b/src/Data/List/NonEmpty/Singletons.hs --- a/src/Data/List/NonEmpty/Singletons.hs +++ b/src/Data/List/NonEmpty/Singletons.hs @@ -179,7 +179,7 @@ fmap f (x :| xs) = f x :| listmap f xs -- -| Number of elements in 'NonEmpty' list. - length :: NonEmpty a -> Nat + length :: NonEmpty a -> Natural length (_ :| xs) = 1 + listlength xs -- -| Compute n-ary logic exclusive OR operation on 'NonEmpty' list. @@ -352,12 +352,12 @@ -} -- -| @'take' n xs@ returns the first @n@ elements of @xs@. - take :: Nat -> NonEmpty a -> [a] + take :: Natural -> NonEmpty a -> [a] take n = listtake n . toList -- -| @'drop' n xs@ drops the first @n@ elements off the front of -- the sequence @xs@. - drop :: Nat -> NonEmpty a -> [a] + drop :: Natural -> NonEmpty a -> [a] drop n = listdrop n . toList -- -| @'splitAt' n xs@ returns a pair consisting of the prefix of @xs@ @@ -365,7 +365,7 @@ -- -- > 'splitAt' n xs == ('take' n xs, 'drop' n xs) -- > xs == ys ++ zs where (ys, zs) = 'splitAt' n xs - splitAt :: Nat -> NonEmpty a -> ([a],[a]) + splitAt :: Natural -> NonEmpty a -> ([a],[a]) splitAt n = listsplitAt n . toList -- -| @'takeWhile' p xs@ returns the longest prefix of the stream @@ -461,7 +461,7 @@ -- @n@. Note that the head of the stream has index 0. -- -- /Beware/: a negative or out-of-bounds index will cause an error. - (!!) :: NonEmpty a -> Nat -> a + (!!) :: NonEmpty a -> Natural -> a (!!) (x :| xs) n | n == 0 = x | n > 0 = xs `listindex` (n - 1) diff --git a/src/Data/List/Singletons/Internal.hs b/src/Data/List/Singletons/Internal.hs --- a/src/Data/List/Singletons/Internal.hs +++ b/src/Data/List/Singletons/Internal.hs @@ -361,23 +361,23 @@ -- These three rely on findIndices, which does not promote. -- Since we have our own implementation of findIndices these are perfectly valid - elemIndex :: Eq a => a -> [a] -> Maybe Nat + elemIndex :: Eq a => a -> [a] -> Maybe Natural elemIndex x = findIndex (x==) - elemIndices :: Eq a => a -> [a] -> [Nat] + elemIndices :: Eq a => a -> [a] -> [Natural] elemIndices x = findIndices (x==) - findIndex :: (a -> Bool) -> [a] -> Maybe Nat + findIndex :: (a -> Bool) -> [a] -> Maybe Natural findIndex p = listToMaybe . findIndices p -- Uses infinite lists and and Ints -- findIndices :: (a -> Bool) -> [a] -> [Int] -- findIndices p xs = [ i | (x,i) <- zip xs [0..], p x] - findIndices :: (a -> Bool) -> [a] -> [Nat] + findIndices :: (a -> Bool) -> [a] -> [Natural] findIndices p xs = map snd (filter (\(x,_) -> p x) (zip xs (buildList 0 xs))) - where buildList :: Nat -> [b] -> [Nat] + where buildList :: Natural -> [b] -> [Natural] buildList _ [] = [] buildList a (_:rest) = a : buildList (a+1) rest @@ -426,15 +426,15 @@ -- splitAt :: Int -> [a] -> ([a],[a]) -- splitAt n xs = (take n xs, drop n xs) - take :: Nat -> [a] -> [a] + take :: Natural -> [a] -> [a] take _ [] = [] take n (x:xs) = if n == 0 then [] else x : take (n-1) xs - drop :: Nat -> [a] -> [a] + drop :: Natural -> [a] -> [a] drop _ [] = [] drop n (x:xs) = if n == 0 then x:xs else drop (n-1) xs - splitAt :: Nat -> [a] -> ([a],[a]) + splitAt :: Natural -> [a] -> ([a],[a]) splitAt n xs = (take n xs, drop n xs) group :: Eq a => [a] -> [[a]] @@ -511,7 +511,7 @@ -- incLen :: a -> (Int# -> Int) -> Int# -> Int -- incLen _ g x = g (x +# 1#) - length :: [a] -> Nat + length :: [a] -> Natural length [] = 0 length (_:xs) = 1 + length xs @@ -530,7 +530,7 @@ -- cycle [] = error "Data.Singletons.List.cycle: empty list" -- cycle xs = xs' where xs' = xs ++ xs' - replicate :: Nat -> a -> [a] + replicate :: Natural -> a -> [a] replicate n x = if n == 0 then [] else x : replicate (n-1) x -- Uses partial pattern-matching in a list comprehension @@ -553,7 +553,7 @@ -- (x:_) !! 0 = x -- (_:xs) !! n = xs !! (n-1) - (!!) :: [a] -> Nat -> a + (!!) :: [a] -> Natural -> a [] !! _ = error "Data.Singletons.List.!!: index too large" (x:xs) !! n = if n == 0 then x else xs !! (n-1) infixl 9 !! diff --git a/src/Data/List/Singletons/Internal/Disambiguation.hs b/src/Data/List/Singletons/Internal/Disambiguation.hs --- a/src/Data/List/Singletons/Internal/Disambiguation.hs +++ b/src/Data/List/Singletons/Internal/Disambiguation.hs @@ -138,32 +138,32 @@ |]) $(singletonsOnly [d| - listtake :: Nat -> [a] -> [a] + listtake :: Natural -> [a] -> [a] listtake = take - listdrop :: Nat -> [a] -> [a] + listdrop :: Natural -> [a] -> [a] listdrop = drop - listsplitAt :: Nat -> [a] -> ([a], [a]) + listsplitAt :: Natural -> [a] -> ([a], [a]) listsplitAt = splitAt - listindex :: [a] -> Nat -> a + listindex :: [a] -> Natural -> a listindex = (!!) listlength :: [a] -> Nat listlength = length |]) -listtake :: Nat -> [a] -> [a] +listtake :: Natural -> [a] -> [a] listtake = undefined -listdrop :: Nat -> [a] -> [a] +listdrop :: Natural -> [a] -> [a] listdrop = undefined -listsplitAt :: Nat -> [a] -> ([a], [a]) +listsplitAt :: Natural -> [a] -> ([a], [a]) listsplitAt = undefined -listindex :: [a] -> Nat -> a +listindex :: [a] -> Natural -> a listindex = undefined listlength :: [a] -> Nat diff --git a/src/Data/Proxy/Singletons.hs b/src/Data/Proxy/Singletons.hs --- a/src/Data/Proxy/Singletons.hs +++ b/src/Data/Proxy/Singletons.hs @@ -57,8 +57,9 @@ import Text.Show.Singletons {- -In order to keep the type argument to Proxy poly-kinded, we define the -singleton version of Proxy by hand. This is very much in the spirit of the +In order to keep the type argument to Proxy poly-kinded and with an inferred +specificity, we define the singleton version of Proxy, as well as its +defunctionalization symbols, by hand. This is very much in the spirit of the code in Data.Functor.Const.Singletons. (See the comments above SConst in that module for more details on this choice.) -} @@ -73,7 +74,9 @@ instance SingI 'Proxy where sing = SProxy -$(genDefunSymbols [''Proxy]) +type ProxySym0 :: Proxy t +type family ProxySym0 where + ProxySym0 = 'Proxy instance SDecide (Proxy t) where SProxy %~ SProxy = Proved Refl diff --git a/src/Data/Singletons/Base/Enum.hs b/src/Data/Singletons/Base/Enum.hs --- a/src/Data/Singletons/Base/Enum.hs +++ b/src/Data/Singletons/Base/Enum.hs @@ -52,6 +52,10 @@ $(singletonsOnly [d| class Bounded a where minBound, maxBound :: a + + instance Bounded Char where + minBound = '\0' + maxBound = '\x10FFFF' |]) $(singBoundedInstances boundedBasicTypes) @@ -62,10 +66,10 @@ succ :: a -> a -- | the predecessor of a value. For numeric types, 'pred' subtracts 1. pred :: a -> a - -- | Convert from a 'Nat'. - toEnum :: Nat -> a - -- | Convert to a 'Nat'. - fromEnum :: a -> Nat + -- | Convert from a 'Natural'. + toEnum :: Natural -> a + -- | Convert to a 'Natural'. + fromEnum :: a -> Natural -- The following use infinite lists, and are not promotable: -- -- | Used in Haskell's translation of @[n..]@. @@ -85,22 +89,22 @@ enumFromTo x y = map toEnum [fromEnum x .. fromEnum y] enumFromThenTo x1 x2 y = map toEnum [fromEnum x1, fromEnum x2 .. fromEnum y] - -- Nat instance for Enum - eftNat :: Nat -> Nat -> [Nat] + -- Natural instance for Enum + eftNat :: Natural -> Natural -> [Natural] -- [x1..x2] eftNat x0 y | (x0 > y) = [] | otherwise = go x0 where go x = x : if (x == y) then [] else go (x + 1) - efdtNat :: Nat -> Nat -> Nat -> [Nat] + efdtNat :: Natural -> Natural -> Natural -> [Natural] -- [x1,x2..y] efdtNat x1 x2 y | x2 >= x1 = efdtNatUp x1 x2 y | otherwise = efdtNatDn x1 x2 y -- Requires x2 >= x1 - efdtNatUp :: Nat -> Nat -> Nat -> [Nat] + efdtNatUp :: Natural -> Natural -> Natural -> [Natural] efdtNatUp x1 x2 y -- Be careful about overflow! | y < x2 = if y < x1 then [] else [x1] | otherwise = -- Common case: x1 <= x2 <= y @@ -115,7 +119,7 @@ in x1 : go_up x2 -- Requires x2 <= x1 - efdtNatDn :: Nat -> Nat -> Nat -> [Nat] + efdtNatDn :: Natural -> Natural -> Natural -> [Natural] efdtNatDn x1 x2 y -- Be careful about underflow! | y > x2 = if y > x1 then [] else [x1] | otherwise = -- Common case: x1 >= x2 >= y @@ -129,7 +133,7 @@ | otherwise = x : go_dn (x + delta) in x1 : go_dn x2 - instance Enum Nat where + instance Enum Natural where succ x = x + 1 pred x = x - 1 @@ -138,6 +142,10 @@ enumFromTo = eftNat enumFromThenTo = efdtNat + + instance Enum Char where + toEnum = natToChar + fromEnum = charToNat |]) $(singEnumInstances enumBasicTypes) diff --git a/src/Data/Singletons/Base/TypeError.hs b/src/Data/Singletons/Base/TypeError.hs --- a/src/Data/Singletons/Base/TypeError.hs +++ b/src/Data/Singletons/Base/TypeError.hs @@ -107,15 +107,27 @@ instance SingI t => SingI ('Text t :: PErrorMessage) where sing = SText sing +instance SingI1 ('Text :: Symbol -> PErrorMessage) where + liftSing = SText instance SingI ty => SingI ('ShowType ty :: PErrorMessage) where sing = SShowType sing +instance SingI1 ('ShowType :: t -> PErrorMessage) where + liftSing = SShowType instance (SingI e1, SingI e2) => SingI (e1 ':<>: e2 :: PErrorMessage) where sing = sing :%<>: sing +instance SingI e1 => SingI1 ('(:<>:) e1 :: PErrorMessage -> PErrorMessage) where + liftSing s = sing :%<>: s +instance SingI2 ('(:<>:) :: PErrorMessage -> PErrorMessage -> PErrorMessage) where + liftSing2 s1 s2 = s1 :%<>: s2 instance (SingI e1, SingI e2) => SingI (e1 ':$$: e2 :: PErrorMessage) where sing = sing :%$$: sing +instance SingI e1 => SingI1 ('(:$$:) e1 :: PErrorMessage -> PErrorMessage) where + liftSing s = sing :%$$: s +instance SingI2 ('(:$$:) :: PErrorMessage -> PErrorMessage -> PErrorMessage) where + liftSing2 s1 s2 = s1 :%$$: s2 -- | Convert an 'ErrorMessage' into a human-readable 'String'. showErrorMessage :: ErrorMessage -> String @@ -169,11 +181,15 @@ sing = singFun2 (:%<>:) instance SingI x => SingI ((:<>:@#@$$) x :: PErrorMessage ~> PErrorMessage) where sing = singFun1 (sing @x :%<>:) +instance SingI1 ((:<>:@#@$$) :: PErrorMessage -> PErrorMessage ~> PErrorMessage) where + liftSing s = singFun1 (s :%<>:) instance SingI ((:$$:@#@$) :: PErrorMessage ~> PErrorMessage ~> PErrorMessage) where sing = singFun2 (:%$$:) instance SingI x => SingI ((:$$:@#@$$) x :: PErrorMessage ~> PErrorMessage) where sing = singFun1 (sing @x :%$$:) +instance SingI1 ((:$$:@#@$$) :: PErrorMessage -> PErrorMessage ~> PErrorMessage) where + liftSing s = singFun1 (s :%$$:) instance SingI TypeErrorSym0 where sing = singFun1 sTypeError diff --git a/src/GHC/Num/Singletons.hs b/src/GHC/Num/Singletons.hs --- a/src/GHC/Num/Singletons.hs +++ b/src/GHC/Num/Singletons.hs @@ -17,7 +17,7 @@ -- "GHC.Num". -- -- Be warned that some of the associated type families in the 'PNum' class --- (@(+)@, @(-)@, and @(*)@) clash with their counterparts for 'Nat' in the +-- (@(+)@, @(-)@, and @(*)@) clash with their counterparts for 'Natural' in the -- "GHC.TypeLits" module. ---------------------------------------------------------------------------- @@ -66,8 +66,8 @@ -- For real numbers, the 'signum' is either @-1@ (negative), @0@ (zero) -- or @1@ (positive). signum :: a -> a - -- Conversion from a 'Nat'. - fromInteger :: Nat -> a + -- Conversion from a 'Natural'. + fromInteger :: Natural -> a x - y = x + negate y @@ -88,22 +88,22 @@ |]) -- PNum instance -type SignumNat :: Nat -> Nat +type SignumNat :: Natural -> Natural type family SignumNat a where SignumNat 0 = 0 SignumNat x = 1 -instance PNum Nat where +instance PNum Natural where type a + b = a TN.+ b type a - b = a TN.- b type a * b = a TN.* b - type Negate (a :: Nat) = Error "Cannot negate a natural number" - type Abs (a :: Nat) = a + type Negate (a :: Natural) = Error "Cannot negate a natural number" + type Abs (a :: Natural) = a type Signum a = SignumNat a type FromInteger a = a -- SNum instance -instance SNum Nat where +instance SNum Natural where sa %+ sb = let a = fromSing sa b = fromSing sb diff --git a/src/GHC/TypeLits/Singletons.hs b/src/GHC/TypeLits/Singletons.hs --- a/src/GHC/TypeLits/Singletons.hs +++ b/src/GHC/TypeLits/Singletons.hs @@ -11,20 +11,23 @@ -- Stability : experimental -- Portability : non-portable -- --- Defines and exports singletons useful for the Nat and Symbol kinds. +-- Defines and exports singletons useful for the Natural, Symbol, and Char +-- kinds. -- ---------------------------------------------------------------------------- {-# OPTIONS_GHC -Wno-orphans #-} module GHC.TypeLits.Singletons ( - Nat, Symbol, - Sing, SNat(..), SSymbol(..), withKnownNat, withKnownSymbol, + Natural, Symbol, Char, + Sing, SNat(..), SSymbol(..), SChar(..), + withKnownNat, withKnownSymbol, withKnownChar, Error, sError, ErrorWithoutStackTrace, sErrorWithoutStackTrace, Undefined, sUndefined, KnownNat, natVal, KnownSymbol, symbolVal, + KnownChar, charVal, type (^), (%^), type (<=?), (%<=?), @@ -33,12 +36,18 @@ Div, sDiv, Mod, sMod, DivMod, sDivMod, Quot, sQuot, Rem, sRem, QuotRem, sQuotRem, + consSymbol, ConsSymbol, sConsSymbol, + unconsSymbol, UnconsSymbol, sUnconsSymbol, + charToNat, CharToNat, sCharToNat, + natToChar, NatToChar, sNatToChar, + -- * Defunctionalization symbols ErrorSym0, ErrorSym1, ErrorWithoutStackTraceSym0, ErrorWithoutStackTraceSym1, UndefinedSym0, KnownNatSym0, KnownNatSym1, KnownSymbolSym0, KnownSymbolSym1, + KnownCharSym0, KnownCharSym1, type (^@#@$), type (^@#@$$), type (^@#@$$$), type (<=?@#@$), type (<=?@#@$$), type (<=?@#@$$$), Log2Sym0, Log2Sym1, @@ -47,46 +56,27 @@ DivModSym0, DivModSym1, DivModSym2, QuotSym0, QuotSym1, QuotSym2, RemSym0, RemSym1, RemSym2, - QuotRemSym0, QuotRemSym1, QuotRemSym2 + QuotRemSym0, QuotRemSym1, QuotRemSym2, + ConsSymbolSym0, ConsSymbolSym1, ConsSymbolSym2, + UnconsSymbolSym0, UnconsSymbolSym1, + CharToNatSym0, CharToNatSym1, + NatToCharSym0, NatToCharSym1 ) where +import Data.Char (chr, ord) +import qualified Data.List as L (uncons) import Data.Singletons import Data.Singletons.TH import Data.String (IsString(..)) +import qualified Data.Text as T import Data.Tuple.Singletons +import GHC.TypeLits ( CharToNat, ConsSymbol, NatToChar, SomeChar(..) + , SomeSymbol(..), UnconsSymbol, someCharVal, someSymbolVal ) import GHC.TypeLits.Singletons.Internal import qualified GHC.TypeNats as TN import GHC.TypeNats (Div, Mod, SomeNat(..)) -import Numeric.Natural (Natural) import Unsafe.Coerce --- | This bogus 'Num' instance is helpful for people who want to define --- functions over Nats that will only be used at the type level or --- as singletons. A correct SNum instance for Nat singletons exists. -instance Num Nat where - (+) = no_term_level_nats - (-) = no_term_level_nats - (*) = no_term_level_nats - negate = no_term_level_nats - abs = no_term_level_nats - signum = no_term_level_nats - fromInteger = no_term_level_nats - -instance Eq Nat where - (==) = no_term_level_nats - -instance Ord Nat where - compare = no_term_level_nats - -instance Enum Nat where - toEnum = no_term_level_nats - fromEnum = no_term_level_nats - enumFromTo = no_term_level_nats - enumFromThenTo = no_term_level_nats - -instance Show Nat where - showsPrec = no_term_level_nats - -- | This bogus instance is helpful for people who want to define -- functions over Symbols that will only be used at the type level or -- as singletons. @@ -108,14 +98,11 @@ instance Show Symbol where showsPrec = no_term_level_syms -no_term_level_nats :: a -no_term_level_nats = error "The kind `Nat` may not be used at the term level." - no_term_level_syms :: a no_term_level_syms = error "The kind `Symbol` may not be used at the term level." -- These are often useful in TypeLits-heavy code -$(genDefunSymbols [''KnownNat, ''KnownSymbol]) +$(genDefunSymbols [''KnownNat, ''KnownSymbol, ''KnownChar]) ------------------------------------------------------------ -- Log2, Div, Mod, DivMod, and friends @@ -167,6 +154,8 @@ sing = singFun2 sDiv instance SingI x => SingI (DivSym1 x) where sing = singFun1 $ sDiv (sing @x) +instance SingI1 DivSym1 where + liftSing s = singFun1 $ sDiv s sMod :: Sing x -> Sing y -> Sing (Mod x y) sMod sx sy = @@ -181,19 +170,21 @@ sing = singFun2 sMod instance SingI x => SingI (ModSym1 x) where sing = singFun1 $ sMod $ sing @x +instance SingI1 ModSym1 where + liftSing s = singFun1 $ sMod s $(promoteOnly [d| - divMod :: Nat -> Nat -> (Nat, Nat) + divMod :: Natural -> Natural -> (Natural, Natural) divMod x y = (div x y, mod x y) - quotRem :: Nat -> Nat -> (Nat, Nat) + quotRem :: Natural -> Natural -> (Natural, Natural) quotRem = divMod - quot :: Nat -> Nat -> Nat + quot :: Natural -> Natural -> Natural quot = div infixl 7 `quot` - rem :: Nat -> Nat -> Nat + rem :: Natural -> Natural -> Natural rem = mod infixl 7 `rem` |]) @@ -219,3 +210,60 @@ sRem :: Sing x -> Sing y -> Sing (Rem x y) sRem = sMod infixl 7 `sRem` + +consSymbol :: Char -> String -> String +consSymbol = (:) + +sConsSymbol :: Sing x -> Sing y -> Sing (ConsSymbol x y) +sConsSymbol sx sy = + let x = fromSing sx + y = T.unpack (fromSing sy) + res = someSymbolVal (consSymbol x y) + in case res of + SomeSymbol (_ :: Proxy res) -> unsafeCoerce (SSym :: Sing res) +$(genDefunSymbols [''ConsSymbol]) +instance SingI ConsSymbolSym0 where + sing = singFun2 sConsSymbol +instance SingI x => SingI (ConsSymbolSym1 x) where + sing = singFun1 $ sConsSymbol $ sing @x +instance SingI1 ConsSymbolSym1 where + liftSing s = singFun1 $ sConsSymbol s + +unconsSymbol :: String -> Maybe (Char, String) +unconsSymbol = L.uncons + +sUnconsSymbol :: Sing x -> Sing (UnconsSymbol x) +sUnconsSymbol sx = + let x = T.unpack (fromSing sx) + res = toSing (unconsSymbol x) + in case res of + SomeSing s -> unsafeCoerce s +$(genDefunSymbols [''UnconsSymbol]) +instance SingI UnconsSymbolSym0 where + sing = singFun1 sUnconsSymbol + +charToNat :: Char -> Natural +charToNat = fromIntegral . ord + +sCharToNat :: Sing x -> Sing (CharToNat x) +sCharToNat sx = + let x = fromSing sx + res = TN.someNatVal (charToNat x) + in case res of + SomeNat (_ :: Proxy res) -> unsafeCoerce (SNat :: Sing res) +$(genDefunSymbols [''CharToNat]) +instance SingI CharToNatSym0 where + sing = singFun1 sCharToNat + +natToChar :: Natural -> Char +natToChar = chr . fromIntegral + +sNatToChar :: Sing x -> Sing (NatToChar x) +sNatToChar sx = + let x = fromSing sx + res = someCharVal (natToChar x) + in case res of + SomeChar (_ :: Proxy res) -> unsafeCoerce (SChar :: Sing res) +$(genDefunSymbols [''NatToChar]) +instance SingI NatToCharSym0 where + sing = singFun1 sNatToChar diff --git a/src/GHC/TypeLits/Singletons/Internal.hs b/src/GHC/TypeLits/Singletons/Internal.hs --- a/src/GHC/TypeLits/Singletons/Internal.hs +++ b/src/GHC/TypeLits/Singletons/Internal.hs @@ -7,8 +7,8 @@ -- Stability : experimental -- Portability : non-portable -- --- Defines and exports singletons useful for the 'Nat' and 'Symbol' kinds. --- This exports the internal, unsafe constructors. Use import +-- Defines and exports singletons useful for the 'Natural', 'Symbol', and +-- 'Char' kinds. This exports the internal, unsafe constructors. Use import -- "GHC.TypeLits.Singletons" for a safe interface. -- ---------------------------------------------------------------------------- @@ -22,12 +22,13 @@ module GHC.TypeLits.Singletons.Internal ( Sing, - Nat, Symbol, - SNat(..), SSymbol(..), withKnownNat, withKnownSymbol, + Natural, Symbol, Char, + SNat(..), SSymbol(..), SChar(..), + withKnownNat, withKnownSymbol, withKnownChar, Error, sError, ErrorWithoutStackTrace, sErrorWithoutStackTrace, Undefined, sUndefined, - KnownNat, TN.natVal, KnownSymbol, symbolVal, + KnownNat, TN.natVal, KnownSymbol, symbolVal, KnownChar, charVal, type (^), (%^), type (<=?), (%<=?), @@ -50,7 +51,6 @@ import GHC.Stack (HasCallStack) import GHC.TypeLits as TL import qualified GHC.TypeNats as TN -import Numeric.Natural (Natural) import Unsafe.Coerce import qualified Data.Text as T @@ -60,15 +60,15 @@ ---- TypeLits singletons --------------------------------------------- ---------------------------------------------------------------------- -type SNat :: Nat -> Type -data SNat (n :: Nat) = KnownNat n => SNat +type SNat :: Natural -> Type +data SNat (n :: Natural) = KnownNat n => SNat type instance Sing = SNat instance KnownNat n => SingI n where sing = SNat -instance SingKind Nat where - type Demote Nat = Natural +instance SingKind Natural where + type Demote Natural = Natural fromSing (SNat :: Sing n) = TN.natVal (Proxy :: Proxy n) toSing n = case TN.someNatVal n of SomeNat (_ :: Proxy n) -> SomeSing (SNat :: Sing n) @@ -86,14 +86,27 @@ toSing s = case someSymbolVal (T.unpack s) of SomeSymbol (_ :: Proxy n) -> SomeSing (SSym :: Sing n) +type SChar :: Char -> Type +data SChar (c :: Char) = KnownChar c => SChar +type instance Sing = SChar + +instance KnownChar c => SingI c where + sing = SChar + +instance SingKind Char where + type Demote Char = Char + fromSing (SChar :: Sing c) = charVal (Proxy :: Proxy c) + toSing sc = case someCharVal sc of + SomeChar (_ :: Proxy c) -> SomeSing (SChar :: Sing c) + -- SDecide instances: -instance SDecide Nat where +instance SDecide Natural where (SNat :: Sing n) %~ (SNat :: Sing m) | Just r <- TN.sameNat (Proxy :: Proxy n) (Proxy :: Proxy m) = Proved r | otherwise = Disproved (\Refl -> error errStr) - where errStr = "Broken Nat singletons" + where errStr = "Broken Natural singletons" instance SDecide Symbol where (SSym :: Sing n) %~ (SSym :: Sing m) @@ -103,14 +116,24 @@ = Disproved (\Refl -> error errStr) where errStr = "Broken Symbol singletons" +instance SDecide Char where + (SChar :: Sing n) %~ (SChar :: Sing m) + | Just r <- sameChar (Proxy :: Proxy n) (Proxy :: Proxy m) + = Proved r + | otherwise + = Disproved (\Refl -> error errStr) + where errStr = "Broken Char singletons" + -- PEq instances -instance PEq Nat where +instance PEq Natural where type x == y = DefaultEq x y instance PEq Symbol where type x == y = DefaultEq x y +instance PEq Char where + type x == y = DefaultEq x y -- need SEq instances for TypeLits kinds -instance SEq Nat where +instance SEq Natural where (SNat :: Sing n) %== (SNat :: Sing m) = case sameNat (Proxy :: Proxy n) (Proxy :: Proxy m) of Just Refl -> STrue @@ -122,15 +145,24 @@ Just Refl -> STrue Nothing -> unsafeCoerce SFalse +instance SEq Char where + (SChar :: Sing n) %== (SChar :: Sing m) + = case sameChar (Proxy :: Proxy n) (Proxy :: Proxy m) of + Just Refl -> STrue + Nothing -> unsafeCoerce SFalse + -- POrd instances -instance POrd Nat where - type (a :: Nat) `Compare` (b :: Nat) = a `TN.CmpNat` b +instance POrd Natural where + type (a :: Natural) `Compare` (b :: Natural) = a `TN.CmpNat` b instance POrd Symbol where type (a :: Symbol) `Compare` (b :: Symbol) = a `TL.CmpSymbol` b +instance POrd Char where + type (a :: Char) `Compare` (b :: Char) = a `TL.CmpChar` b + -- SOrd instances -instance SOrd Nat where +instance SOrd Natural where a `sCompare` b = case fromSing a `compare` fromSing b of LT -> unsafeCoerce SLT EQ -> unsafeCoerce SEQ @@ -142,10 +174,16 @@ EQ -> unsafeCoerce SEQ GT -> unsafeCoerce SGT +instance SOrd Char where + a `sCompare` b = case fromSing a `compare` fromSing b of + LT -> unsafeCoerce SLT + EQ -> unsafeCoerce SEQ + GT -> unsafeCoerce SGT + -- Show instances -- These are a bit special because the singleton constructor does not uniquely --- determine the type being used in the constructor's return type (e.g., all Nats +-- determine the type being used in the constructor's return type (e.g., all Naturals -- have the same singleton constructor, SNat). To compensate for this, we display -- the type being used using visible type application. (Thanks to @cumber on #179 -- for suggesting this implementation.) @@ -164,6 +202,13 @@ . showsPrec appPrec1 (symbolVal s) ) +instance Show (SChar c) where + showsPrec p s@SChar + = showParen (p > appPrec) + ( showString "SChar @" + . showsPrec appPrec1 (charVal s) + ) + -- Convenience functions -- | Given a singleton for @Nat@, call something requiring a @@ -176,6 +221,11 @@ withKnownSymbol :: Sing n -> (KnownSymbol n => r) -> r withKnownSymbol SSym f = f +-- | Given a singleton for @Char@, call something requiring +-- a @KnownChar@ instance. +withKnownChar :: Sing n -> (KnownChar n => r) -> r +withKnownChar SChar f = f + -- | The promotion of 'error'. This version is more poly-kinded for -- easier use. type Error :: k0 -> k @@ -209,7 +259,7 @@ sUndefined :: HasCallStack => a sUndefined = undefined --- | The singleton analogue of '(TN.^)' for 'Nat's. +-- | The singleton analogue of '(TN.^)' for 'Natural's. (%^) :: Sing a -> Sing b -> Sing (a ^ b) sa %^ sb = let a = fromSing sa @@ -226,12 +276,14 @@ sing = singFun2 (%^) instance SingI x => SingI ((^@#@$$) x) where sing = singFun1 (sing @x %^) +instance SingI1 (^@#@$$) where + liftSing s = singFun1 (s %^) -- | The singleton analogue of 'TN.<=?' -- --- Note that, because of historical reasons in GHC's 'TN.Nat' API, 'TN.<=?' +-- Note that, because of historical reasons in GHC's 'Natural' API, 'TN.<=?' -- is incompatible (unification-wise) with 'O.<=' and the 'PEq', 'SEq', --- 'POrd', and 'SOrd' instances for 'Nat'. @(a '<=?' b) ~ 'True@ does not +-- 'POrd', and 'SOrd' instances for 'Natural'. @(a '<=?' b) ~ 'True@ does not -- imply anything about @a 'O.<=' b@ or any other 'PEq' / 'POrd' -- relationships. -- @@ -243,14 +295,16 @@ -- This is provided here for the sake of completeness and for compatibility -- with libraries with APIs built around '<=?'. New code should use -- 'CmpNat', exposed through this library through the 'POrd' and 'SOrd' --- instances for 'Nat'. -(%<=?) :: Sing a -> Sing b -> Sing (a <=? b) +-- instances for 'Natural'. +(%<=?) :: forall (a :: Natural) (b :: Natural). Sing a -> Sing b -> Sing (a <=? b) sa %<=? sb = unsafeCoerce (sa %<= sb) infix 4 %<=? -- Defunctionalization symbols for (<=?) $(genDefunSymbols [''(<=?)]) -instance SingI (<=?@#@$) where +instance SingI ((<=?@#@$) @Natural) where sing = singFun2 (%<=?) -instance SingI x => SingI ((<=?@#@$$) x) where +instance SingI x => SingI ((<=?@#@$$) @Natural x) where sing = singFun1 (sing @x %<=?) +instance SingI1 ((<=?@#@$$) @Natural) where + liftSing s = singFun1 (s %<=?) diff --git a/src/Text/Show/Singletons.hs b/src/Text/Show/Singletons.hs --- a/src/Text/Show/Singletons.hs +++ b/src/Text/Show/Singletons.hs @@ -28,7 +28,7 @@ ----------------------------------------------------------------------------- module Text.Show.Singletons ( - PShow(..), SShow(..), SymbolS, SChar, show_, + PShow(..), SShow(..), SymbolS, show_, Shows, sShows, ShowListWith, sShowListWith, ShowChar, sShowChar, @@ -53,6 +53,8 @@ AppPrecSym0, AppPrec1Sym0 ) where +import Data.Bool.Singletons +import Data.Eq.Singletons import Data.Kind import Data.List.NonEmpty (NonEmpty) import Data.List.Singletons.Internal @@ -78,14 +80,9 @@ type SymbolS :: Type type SymbolS = Symbol -> Symbol --- | GHC currently has no notion of type-level 'Char's, so we fake them with --- single-character 'Symbol's. -type SChar :: Type -type SChar = Symbol - $(singletonsOnly [d| class Show a where - showsPrec :: Nat -> a -> SymbolS + showsPrec :: Natural -> a -> SymbolS show_ :: a -> Symbol showList :: [a] -> SymbolS @@ -103,14 +100,14 @@ showl [] = "]" <> s showl (y:ys) = "," <> showx y (showl ys) - showChar :: SChar -> SymbolS - showChar = (<>) + showChar :: Char -> SymbolS + showChar = consSymbol showString :: Symbol -> SymbolS showString = (<>) showParen :: Bool -> SymbolS -> SymbolS - showParen b p = if b then showChar "(" . p . showChar ")" else p + showParen b p = if b then showChar '(' . p . showChar ')' else p showSpace :: SymbolS showSpace = \xs -> " " <> xs @@ -125,17 +122,10 @@ instance Show a => Show [a] where showsPrec _ = showList - -- -| This is not an ideal Show instance for Symbol, since the Show instance - -- for String escapes special characters. Unfortunately, GHC lacks the ability - -- to case on individual characters in a Symbol (at least, not without GHC - -- plugins), so this is the best we can do for the time being. - instance Show Symbol where - showsPrec _ = showString - show_tuple :: [SymbolS] -> SymbolS - show_tuple ss = showChar "(" - . foldr1 (\s r -> s . showChar "," . r) ss - . showChar ")" + show_tuple ss = showChar '(' + . foldr1 (\s r -> s . showChar ',' . r) ss + . showChar ')' instance (Show a, Show b) => Show (a,b) where showsPrec _ (a,b) s = show_tuple [shows a, shows b] s @@ -161,28 +151,138 @@ |]) $(promoteOnly [d| - showsNat :: Nat -> SymbolS - showsNat 0 = showChar "0" - showsNat 1 = showChar "1" - showsNat 2 = showChar "2" - showsNat 3 = showChar "3" - showsNat 4 = showChar "4" - showsNat 5 = showChar "5" - showsNat 6 = showChar "6" - showsNat 7 = showChar "7" - showsNat 8 = showChar "8" - showsNat 9 = showChar "9" + showsNat :: Natural -> SymbolS + showsNat 0 = showChar '0' + showsNat 1 = showChar '1' + showsNat 2 = showChar '2' + showsNat 3 = showChar '3' + showsNat 4 = showChar '4' + showsNat 5 = showChar '5' + showsNat 6 = showChar '6' + showsNat 7 = showChar '7' + showsNat 8 = showChar '8' + showsNat 9 = showChar '9' showsNat n = showsNat (n `div` 10) . showsNat (n `mod` 10) |]) -instance PShow Nat where +instance PShow Natural where type ShowsPrec _ n x = ShowsNat n x -instance SShow Nat where +instance SShow Natural where sShowsPrec _ sn sx = let n = fromSing sn x = fromSing sx ex = someSymbolVal (P.show n ++ T.unpack x) + in + case ex of + SomeSymbol (_ :: Proxy s) -> unsafeCoerce (SSym :: Sing s) + +$(promoteOnly [d| + showsCharPrec :: Natural -> Char -> SymbolS + showsCharPrec _ '\'' = showString "'\\''" + showsCharPrec _ c = showChar '\'' . showLitChar c . showChar '\'' + + showCharList :: [Char] -> SymbolS + showCharList cs = showChar '"' . showLitString cs . showChar '"' + + -- -| Like 'showCharList', but for 'Symbol's. + showSymbol :: Symbol -> SymbolS + showSymbol sym = showChar '"' . showLitSymbol sym . showChar '"' + + -- -| Convert a character to a string using only printable characters, + -- using Haskell source-language escape conventions. For example: + -- + -- > showLitChar '\n' s = "\\n" ++ s + -- + showLitChar :: Char -> SymbolS + showLitChar c s | c > '\DEL' = showChar '\\' (protectEsc isDec (shows (charToNat c)) s) + showLitChar '\DEL' s = showString "\\DEL" s + showLitChar '\\' s = showString "\\\\" s + showLitChar c s | c >= ' ' = showChar c s + showLitChar '\a' s = showString "\\a" s + showLitChar '\b' s = showString "\\b" s + showLitChar '\f' s = showString "\\f" s + showLitChar '\n' s = showString "\\n" s + showLitChar '\r' s = showString "\\r" s + showLitChar '\t' s = showString "\\t" s + showLitChar '\v' s = showString "\\v" s + showLitChar '\SO' s = protectEsc (== 'H') (showString "\\SO") s + showLitChar c s = showString ('\\' `consSymbol` (asciiTab!!charToNat c)) s + -- I've done manual eta-expansion here, because otherwise it's + -- impossible to stop (asciiTab!!charToNat) getting floated out as an MFE + + showLitString :: String -> SymbolS + -- -| Same as 'showLitChar', but for strings + -- It converts the string to a string using Haskell escape conventions + -- for non-printable characters. Does not add double-quotes around the + -- whole thing; the caller should do that. + -- The main difference from showLitChar (apart from the fact that the + -- argument is a string not a list) is that we must escape double-quotes + showLitString [] s = s + showLitString ('"' : cs) s = showString "\\\"" (showLitString cs s) + showLitString (c : cs) s = showLitChar c (showLitString cs s) + -- Making 's' an explicit parameter makes it clear to GHC that + -- showLitString has arity 2, which avoids it allocating an extra lambda + -- The sticking point is the recursive call to (showLitString cs), which + -- it can't figure out would be ok with arity 2. + + -- -| Like 'showLitString', but for 'Symbol's. + showLitSymbol :: Symbol -> SymbolS + showLitSymbol sym s = case unconsSymbol sym of + Nothing -> s + Just ('"', cs) -> showString "\\\"" (showLitSymbol cs s) + Just (c, cs) -> showLitChar c (showLitSymbol cs s) + + isDec :: Char -> Bool + isDec c = c >= '0' && c <= '9' + + protectEsc :: (Char -> Bool) -> SymbolS -> SymbolS + protectEsc p f = f . cont + -- where cont s@(c:_) | p c = "\\&" ++ s + -- cont s = s + where cont s = case unconsSymbol s of + Just (c, _) | p c -> "\\&" <> s + Nothing -> s + + asciiTab :: [Symbol] + asciiTab = -- Using an array drags in the array module. listArray ('\NUL', ' ') + ["NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL", + "BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI", + "DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB", + "CAN", "EM", "SUB", "ESC", "FS", "GS", "RS", "US", + "SP"] + |]) + +instance PShow Char where + type ShowsPrec p c x = ShowsCharPrec p c x + type ShowList cs x = ShowCharList cs x + +instance SShow Char where + sShowsPrec sp sc sx = + let p = fromSing sp + c = fromSing sc + x = fromSing sx + ex = someSymbolVal (P.showsPrec (fromIntegral p) c (T.unpack x)) + in + case ex of + SomeSymbol (_ :: Proxy s) -> unsafeCoerce (SSym :: Sing s) + + sShowList scs sx = + let cs = fromSing scs + x = fromSing sx + ex = someSymbolVal (P.showList cs (T.unpack x)) + in + case ex of + SomeSymbol (_ :: Proxy s) -> unsafeCoerce (SSym :: Sing s) + +instance PShow Symbol where + type ShowsPrec _ s x = ShowSymbol s x + +instance SShow Symbol where + sShowsPrec _ ss sx = + let s = fromSing ss + x = fromSing sx + ex = someSymbolVal (P.show s ++ T.unpack x) in case ex of SomeSymbol (_ :: Proxy s) -> unsafeCoerce (SSym :: Sing s) diff --git a/tests/SingletonsBaseTestSuite.hs b/tests/SingletonsBaseTestSuite.hs --- a/tests/SingletonsBaseTestSuite.hs +++ b/tests/SingletonsBaseTestSuite.hs @@ -138,6 +138,11 @@ , compileAndDumpStdTest "T453" , compileAndDumpStdTest "NegativeLiterals" , compileAndDumpStdTest "T470" + , compileAndDumpStdTest "T480" + , compileAndDumpStdTest "T487" + , compileAndDumpStdTest "T489" + , compileAndDumpStdTest "T492" + , compileAndDumpStdTest "Natural" ], testCompileAndDumpGroup "Promote" [ compileAndDumpStdTest "Constructors" diff --git a/tests/SingletonsBaseTestSuiteUtils.hs b/tests/SingletonsBaseTestSuiteUtils.hs --- a/tests/SingletonsBaseTestSuiteUtils.hs +++ b/tests/SingletonsBaseTestSuiteUtils.hs @@ -71,6 +71,7 @@ , "-XNoStarIsType" , "-XStandaloneKindSignatures" , "-XConstraintKinds" + , "-XNoNamedWildCards" ] -- Compile a test using specified GHC options. Save output to file, normalize diff --git a/tests/compile-and-dump/GradingClient/Database.golden b/tests/compile-and-dump/GradingClient/Database.golden --- a/tests/compile-and-dump/GradingClient/Database.golden +++ b/tests/compile-and-dump/GradingClient/Database.golden @@ -90,3352 +90,3382 @@ fromSing (SSucc b) = Succ (fromSing b) toSing Zero = SomeSing SZero toSing (Succ (b :: Demote Nat)) - = case toSing b :: SomeSing Nat of { - SomeSing c -> SomeSing (SSucc c) } - instance SEq Nat => SEq Nat where - (%==) :: - forall (t1 :: Nat) (t2 :: Nat). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun Nat ((~>) Nat Bool) - -> Type) t1) t2) - (%==) SZero SZero = STrue - (%==) SZero (SSucc _) = SFalse - (%==) (SSucc _) SZero = SFalse - (%==) - (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210)) - (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210)) - = (applySing - ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210)) - sB_0123456789876543210 - instance SOrd Nat => SOrd Nat where - sCompare :: - forall (t1 :: Nat) (t2 :: Nat). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat ((~>) Nat Ordering) - -> Type) t1) t2) - sCompare SZero SZero - = (applySing - ((applySing - ((applySing ((singFun3 @FoldlSym0) sFoldl)) - ((singFun2 @ThenCmpSym0) sThenCmp))) - SEQ)) - SNil - sCompare - (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210)) - (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210)) - = (applySing - ((applySing - ((applySing ((singFun3 @FoldlSym0) sFoldl)) - ((singFun2 @ThenCmpSym0) sThenCmp))) - SEQ)) - ((applySing - ((applySing ((singFun2 @(:@#@$)) SCons)) - ((applySing - ((applySing ((singFun2 @CompareSym0) sCompare)) - sA_0123456789876543210)) - sB_0123456789876543210))) - SNil) - sCompare SZero (SSucc _) = SLT - sCompare (SSucc _) SZero = SGT - instance SDecide Nat => SDecide Nat where - (%~) SZero SZero = Proved Refl - (%~) SZero (SSucc _) = Disproved (\ x -> case x of) - (%~) (SSucc _) SZero = Disproved (\ x -> case x of) - (%~) (SSucc a) (SSucc b) - = case ((%~) a) b of - Proved Refl -> Proved Refl - Disproved contra - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - instance SDecide Nat => - Data.Type.Equality.TestEquality (SNat :: Nat -> Type) where - Data.Type.Equality.testEquality - = Data.Singletons.Decide.decideEquality - instance SDecide Nat => - Data.Type.Coercion.TestCoercion (SNat :: Nat -> Type) where - Data.Type.Coercion.testCoercion - = Data.Singletons.Decide.decideCoercion - instance SingI Zero where - sing = SZero - instance SingI n => SingI (Succ (n :: Nat)) where - sing = SSucc sing - instance SingI (SuccSym0 :: (~>) Nat Nat) where - sing = (singFun1 @SuccSym0) SSucc -GradingClient/Database.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| append :: Schema -> Schema -> Schema - append (Sch s1) (Sch s2) = Sch (s1 ++ s2) - attrNotIn :: Attribute -> Schema -> Bool - attrNotIn _ (Sch []) = True - attrNotIn (Attr name u) (Sch ((Attr name' _) : t)) - = (name /= name') && (attrNotIn (Attr name u) (Sch t)) - disjoint :: Schema -> Schema -> Bool - disjoint (Sch []) _ = True - disjoint (Sch (h : t)) s = (attrNotIn h s) && (disjoint (Sch t) s) - occurs :: [AChar] -> Schema -> Bool - occurs _ (Sch []) = False - occurs name (Sch ((Attr name' _) : attrs)) - = name == name' || occurs name (Sch attrs) - lookup :: [AChar] -> Schema -> U - lookup _ (Sch []) = undefined - lookup name (Sch ((Attr name' u) : attrs)) - = if name == name' then u else lookup name (Sch attrs) - - data U - = BOOL | STRING | NAT | VEC U Nat - deriving (Read, Eq, Show) - data AChar - = CA | - CB | - CC | - CD | - CE | - CF | - CG | - CH | - CI | - CJ | - CK | - CL | - CM | - CN | - CO | - CP | - CQ | - CR | - CS | - CT | - CU | - CV | - CW | - CX | - CY | - CZ - deriving (Read, Show, Eq) - data Attribute = Attr [AChar] U - data Schema = Sch [Attribute] |] - ======> - data U - = BOOL | STRING | NAT | VEC U Nat - deriving (Read, Eq, Show) - data AChar - = CA | - CB | - CC | - CD | - CE | - CF | - CG | - CH | - CI | - CJ | - CK | - CL | - CM | - CN | - CO | - CP | - CQ | - CR | - CS | - CT | - CU | - CV | - CW | - CX | - CY | - CZ - deriving (Read, Show, Eq) - data Attribute = Attr [AChar] U - data Schema = Sch [Attribute] - append :: Schema -> Schema -> Schema - append (Sch s1) (Sch s2) = Sch (s1 ++ s2) - attrNotIn :: Attribute -> Schema -> Bool - attrNotIn _ (Sch []) = True - attrNotIn (Attr name u) (Sch (Attr name' _ : t)) - = ((name /= name') && (attrNotIn ((Attr name) u)) (Sch t)) - disjoint :: Schema -> Schema -> Bool - disjoint (Sch []) _ = True - disjoint (Sch (h : t)) s - = ((attrNotIn h) s && (disjoint (Sch t)) s) - occurs :: [AChar] -> Schema -> Bool - occurs _ (Sch []) = False - occurs name (Sch (Attr name' _ : attrs)) - = ((name == name') || (occurs name) (Sch attrs)) - lookup :: [AChar] -> Schema -> U - lookup _ (Sch []) = undefined - lookup name (Sch (Attr name' u : attrs)) - = if (name == name') then u else (lookup name) (Sch attrs) - type BOOLSym0 :: U - type family BOOLSym0 :: U where - BOOLSym0 = BOOL - type STRINGSym0 :: U - type family STRINGSym0 :: U where - STRINGSym0 = STRING - type NATSym0 :: U - type family NATSym0 :: U where - NATSym0 = NAT - type VECSym0 :: (~>) U ((~>) Nat U) - data VECSym0 :: (~>) U ((~>) Nat U) - where - VECSym0KindInference :: SameKind (Apply VECSym0 arg) (VECSym1 arg) => - VECSym0 a0123456789876543210 - type instance Apply VECSym0 a0123456789876543210 = VECSym1 a0123456789876543210 - instance SuppressUnusedWarnings VECSym0 where - suppressUnusedWarnings = snd (((,) VECSym0KindInference) ()) - type VECSym1 :: U -> (~>) Nat U - data VECSym1 (a0123456789876543210 :: U) :: (~>) Nat U - where - VECSym1KindInference :: SameKind (Apply (VECSym1 a0123456789876543210) arg) (VECSym2 a0123456789876543210 arg) => - VECSym1 a0123456789876543210 a0123456789876543210 - type instance Apply (VECSym1 a0123456789876543210) a0123456789876543210 = VEC a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (VECSym1 a0123456789876543210) where - suppressUnusedWarnings = snd (((,) VECSym1KindInference) ()) - type VECSym2 :: U -> Nat -> U - type family VECSym2 (a0123456789876543210 :: U) (a0123456789876543210 :: Nat) :: U where - VECSym2 a0123456789876543210 a0123456789876543210 = VEC a0123456789876543210 a0123456789876543210 - type CASym0 :: AChar - type family CASym0 :: AChar where - CASym0 = CA - type CBSym0 :: AChar - type family CBSym0 :: AChar where - CBSym0 = CB - type CCSym0 :: AChar - type family CCSym0 :: AChar where - CCSym0 = CC - type CDSym0 :: AChar - type family CDSym0 :: AChar where - CDSym0 = CD - type CESym0 :: AChar - type family CESym0 :: AChar where - CESym0 = CE - type CFSym0 :: AChar - type family CFSym0 :: AChar where - CFSym0 = CF - type CGSym0 :: AChar - type family CGSym0 :: AChar where - CGSym0 = CG - type CHSym0 :: AChar - type family CHSym0 :: AChar where - CHSym0 = CH - type CISym0 :: AChar - type family CISym0 :: AChar where - CISym0 = CI - type CJSym0 :: AChar - type family CJSym0 :: AChar where - CJSym0 = CJ - type CKSym0 :: AChar - type family CKSym0 :: AChar where - CKSym0 = CK - type CLSym0 :: AChar - type family CLSym0 :: AChar where - CLSym0 = CL - type CMSym0 :: AChar - type family CMSym0 :: AChar where - CMSym0 = CM - type CNSym0 :: AChar - type family CNSym0 :: AChar where - CNSym0 = CN - type COSym0 :: AChar - type family COSym0 :: AChar where - COSym0 = CO - type CPSym0 :: AChar - type family CPSym0 :: AChar where - CPSym0 = CP - type CQSym0 :: AChar - type family CQSym0 :: AChar where - CQSym0 = CQ - type CRSym0 :: AChar - type family CRSym0 :: AChar where - CRSym0 = CR - type CSSym0 :: AChar - type family CSSym0 :: AChar where - CSSym0 = CS - type CTSym0 :: AChar - type family CTSym0 :: AChar where - CTSym0 = CT - type CUSym0 :: AChar - type family CUSym0 :: AChar where - CUSym0 = CU - type CVSym0 :: AChar - type family CVSym0 :: AChar where - CVSym0 = CV - type CWSym0 :: AChar - type family CWSym0 :: AChar where - CWSym0 = CW - type CXSym0 :: AChar - type family CXSym0 :: AChar where - CXSym0 = CX - type CYSym0 :: AChar - type family CYSym0 :: AChar where - CYSym0 = CY - type CZSym0 :: AChar - type family CZSym0 :: AChar where - CZSym0 = CZ - type AttrSym0 :: (~>) [AChar] ((~>) U Attribute) - data AttrSym0 :: (~>) [AChar] ((~>) U Attribute) - where - AttrSym0KindInference :: SameKind (Apply AttrSym0 arg) (AttrSym1 arg) => - AttrSym0 a0123456789876543210 - type instance Apply AttrSym0 a0123456789876543210 = AttrSym1 a0123456789876543210 - instance SuppressUnusedWarnings AttrSym0 where - suppressUnusedWarnings = snd (((,) AttrSym0KindInference) ()) - type AttrSym1 :: [AChar] -> (~>) U Attribute - data AttrSym1 (a0123456789876543210 :: [AChar]) :: (~>) U Attribute - where - AttrSym1KindInference :: SameKind (Apply (AttrSym1 a0123456789876543210) arg) (AttrSym2 a0123456789876543210 arg) => - AttrSym1 a0123456789876543210 a0123456789876543210 - type instance Apply (AttrSym1 a0123456789876543210) a0123456789876543210 = Attr a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (AttrSym1 a0123456789876543210) where - suppressUnusedWarnings = snd (((,) AttrSym1KindInference) ()) - type AttrSym2 :: [AChar] -> U -> Attribute - type family AttrSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: U) :: Attribute where - AttrSym2 a0123456789876543210 a0123456789876543210 = Attr a0123456789876543210 a0123456789876543210 - type SchSym0 :: (~>) [Attribute] Schema - data SchSym0 :: (~>) [Attribute] Schema - where - SchSym0KindInference :: SameKind (Apply SchSym0 arg) (SchSym1 arg) => - SchSym0 a0123456789876543210 - type instance Apply SchSym0 a0123456789876543210 = Sch a0123456789876543210 - instance SuppressUnusedWarnings SchSym0 where - suppressUnusedWarnings = snd (((,) SchSym0KindInference) ()) - type SchSym1 :: [Attribute] -> Schema - type family SchSym1 (a0123456789876543210 :: [Attribute]) :: Schema where - SchSym1 a0123456789876543210 = Sch a0123456789876543210 - data Let0123456789876543210Scrutinee_0123456789876543210Sym0 name0123456789876543210 - where - Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) => - Let0123456789876543210Scrutinee_0123456789876543210Sym0 name0123456789876543210 - type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 name0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210 - instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd - (((,) - Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference) - ()) - data Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210 name'0123456789876543210 - where - Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference :: SameKind (Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210) arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 arg) => - Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210 name'0123456789876543210 - type instance Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210) name'0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210 - instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210) where - suppressUnusedWarnings - = snd - (((,) - Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference) - ()) - data Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210 u0123456789876543210 - where - Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference :: SameKind (Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210) arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 arg) => - Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210 u0123456789876543210 - type instance Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210) u0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210 - instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210) where - suppressUnusedWarnings - = snd - (((,) - Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference) - ()) - data Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 - where - Let0123456789876543210Scrutinee_0123456789876543210Sym3KindInference :: SameKind (Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210) arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name0123456789876543210 name'0123456789876543210 u0123456789876543210 arg) => - Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 - type instance Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210) attrs0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 - instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210) where - suppressUnusedWarnings - = snd - (((,) - Let0123456789876543210Scrutinee_0123456789876543210Sym3KindInference) - ()) - type family Let0123456789876543210Scrutinee_0123456789876543210Sym4 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 where - Let0123456789876543210Scrutinee_0123456789876543210Sym4 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 - type family Let0123456789876543210Scrutinee_0123456789876543210 name name' u attrs where - Let0123456789876543210Scrutinee_0123456789876543210 name name' u attrs = Apply (Apply (==@#@$) name) name' - type family Case_0123456789876543210 name name' u attrs t where - Case_0123456789876543210 name name' u attrs 'True = u - Case_0123456789876543210 name name' u attrs 'False = Apply (Apply LookupSym0 name) (Apply SchSym0 attrs) - type LookupSym0 :: (~>) [AChar] ((~>) Schema U) - data LookupSym0 :: (~>) [AChar] ((~>) Schema U) - where - LookupSym0KindInference :: SameKind (Apply LookupSym0 arg) (LookupSym1 arg) => - LookupSym0 a0123456789876543210 - type instance Apply LookupSym0 a0123456789876543210 = LookupSym1 a0123456789876543210 - instance SuppressUnusedWarnings LookupSym0 where - suppressUnusedWarnings = snd (((,) LookupSym0KindInference) ()) - type LookupSym1 :: [AChar] -> (~>) Schema U - data LookupSym1 (a0123456789876543210 :: [AChar]) :: (~>) Schema U - where - LookupSym1KindInference :: SameKind (Apply (LookupSym1 a0123456789876543210) arg) (LookupSym2 a0123456789876543210 arg) => - LookupSym1 a0123456789876543210 a0123456789876543210 - type instance Apply (LookupSym1 a0123456789876543210) a0123456789876543210 = Lookup a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (LookupSym1 a0123456789876543210) where - suppressUnusedWarnings = snd (((,) LookupSym1KindInference) ()) - type LookupSym2 :: [AChar] -> Schema -> U - type family LookupSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: Schema) :: U where - LookupSym2 a0123456789876543210 a0123456789876543210 = Lookup a0123456789876543210 a0123456789876543210 - type OccursSym0 :: (~>) [AChar] ((~>) Schema Bool) - data OccursSym0 :: (~>) [AChar] ((~>) Schema Bool) - where - OccursSym0KindInference :: SameKind (Apply OccursSym0 arg) (OccursSym1 arg) => - OccursSym0 a0123456789876543210 - type instance Apply OccursSym0 a0123456789876543210 = OccursSym1 a0123456789876543210 - instance SuppressUnusedWarnings OccursSym0 where - suppressUnusedWarnings = snd (((,) OccursSym0KindInference) ()) - type OccursSym1 :: [AChar] -> (~>) Schema Bool - data OccursSym1 (a0123456789876543210 :: [AChar]) :: (~>) Schema Bool - where - OccursSym1KindInference :: SameKind (Apply (OccursSym1 a0123456789876543210) arg) (OccursSym2 a0123456789876543210 arg) => - OccursSym1 a0123456789876543210 a0123456789876543210 - type instance Apply (OccursSym1 a0123456789876543210) a0123456789876543210 = Occurs a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (OccursSym1 a0123456789876543210) where - suppressUnusedWarnings = snd (((,) OccursSym1KindInference) ()) - type OccursSym2 :: [AChar] -> Schema -> Bool - type family OccursSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: Schema) :: Bool where - OccursSym2 a0123456789876543210 a0123456789876543210 = Occurs a0123456789876543210 a0123456789876543210 - type DisjointSym0 :: (~>) Schema ((~>) Schema Bool) - data DisjointSym0 :: (~>) Schema ((~>) Schema Bool) - where - DisjointSym0KindInference :: SameKind (Apply DisjointSym0 arg) (DisjointSym1 arg) => - DisjointSym0 a0123456789876543210 - type instance Apply DisjointSym0 a0123456789876543210 = DisjointSym1 a0123456789876543210 - instance SuppressUnusedWarnings DisjointSym0 where - suppressUnusedWarnings = snd (((,) DisjointSym0KindInference) ()) - type DisjointSym1 :: Schema -> (~>) Schema Bool - data DisjointSym1 (a0123456789876543210 :: Schema) :: (~>) Schema Bool - where - DisjointSym1KindInference :: SameKind (Apply (DisjointSym1 a0123456789876543210) arg) (DisjointSym2 a0123456789876543210 arg) => - DisjointSym1 a0123456789876543210 a0123456789876543210 - type instance Apply (DisjointSym1 a0123456789876543210) a0123456789876543210 = Disjoint a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (DisjointSym1 a0123456789876543210) where - suppressUnusedWarnings = snd (((,) DisjointSym1KindInference) ()) - type DisjointSym2 :: Schema -> Schema -> Bool - type family DisjointSym2 (a0123456789876543210 :: Schema) (a0123456789876543210 :: Schema) :: Bool where - DisjointSym2 a0123456789876543210 a0123456789876543210 = Disjoint a0123456789876543210 a0123456789876543210 - type AttrNotInSym0 :: (~>) Attribute ((~>) Schema Bool) - data AttrNotInSym0 :: (~>) Attribute ((~>) Schema Bool) - where - AttrNotInSym0KindInference :: SameKind (Apply AttrNotInSym0 arg) (AttrNotInSym1 arg) => - AttrNotInSym0 a0123456789876543210 - type instance Apply AttrNotInSym0 a0123456789876543210 = AttrNotInSym1 a0123456789876543210 - instance SuppressUnusedWarnings AttrNotInSym0 where - suppressUnusedWarnings = snd (((,) AttrNotInSym0KindInference) ()) - type AttrNotInSym1 :: Attribute -> (~>) Schema Bool - data AttrNotInSym1 (a0123456789876543210 :: Attribute) :: (~>) Schema Bool - where - AttrNotInSym1KindInference :: SameKind (Apply (AttrNotInSym1 a0123456789876543210) arg) (AttrNotInSym2 a0123456789876543210 arg) => - AttrNotInSym1 a0123456789876543210 a0123456789876543210 - type instance Apply (AttrNotInSym1 a0123456789876543210) a0123456789876543210 = AttrNotIn a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (AttrNotInSym1 a0123456789876543210) where - suppressUnusedWarnings = snd (((,) AttrNotInSym1KindInference) ()) - type AttrNotInSym2 :: Attribute -> Schema -> Bool - type family AttrNotInSym2 (a0123456789876543210 :: Attribute) (a0123456789876543210 :: Schema) :: Bool where - AttrNotInSym2 a0123456789876543210 a0123456789876543210 = AttrNotIn a0123456789876543210 a0123456789876543210 - type AppendSym0 :: (~>) Schema ((~>) Schema Schema) - data AppendSym0 :: (~>) Schema ((~>) Schema Schema) - where - AppendSym0KindInference :: SameKind (Apply AppendSym0 arg) (AppendSym1 arg) => - AppendSym0 a0123456789876543210 - type instance Apply AppendSym0 a0123456789876543210 = AppendSym1 a0123456789876543210 - instance SuppressUnusedWarnings AppendSym0 where - suppressUnusedWarnings = snd (((,) AppendSym0KindInference) ()) - type AppendSym1 :: Schema -> (~>) Schema Schema - data AppendSym1 (a0123456789876543210 :: Schema) :: (~>) Schema Schema - where - AppendSym1KindInference :: SameKind (Apply (AppendSym1 a0123456789876543210) arg) (AppendSym2 a0123456789876543210 arg) => - AppendSym1 a0123456789876543210 a0123456789876543210 - type instance Apply (AppendSym1 a0123456789876543210) a0123456789876543210 = Append a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (AppendSym1 a0123456789876543210) where - suppressUnusedWarnings = snd (((,) AppendSym1KindInference) ()) - type AppendSym2 :: Schema -> Schema -> Schema - type family AppendSym2 (a0123456789876543210 :: Schema) (a0123456789876543210 :: Schema) :: Schema where - AppendSym2 a0123456789876543210 a0123456789876543210 = Append a0123456789876543210 a0123456789876543210 - type Lookup :: [AChar] -> Schema -> U - type family Lookup (a :: [AChar]) (a :: Schema) :: U where - Lookup _ (Sch '[]) = UndefinedSym0 - Lookup name (Sch ('(:) (Attr name' u) attrs)) = Case_0123456789876543210 name name' u attrs (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name name' u attrs) - type Occurs :: [AChar] -> Schema -> Bool - type family Occurs (a :: [AChar]) (a :: Schema) :: Bool where - Occurs _ (Sch '[]) = FalseSym0 - Occurs name (Sch ('(:) (Attr name' _) attrs)) = Apply (Apply (||@#@$) (Apply (Apply (==@#@$) name) name')) (Apply (Apply OccursSym0 name) (Apply SchSym0 attrs)) - type Disjoint :: Schema -> Schema -> Bool - type family Disjoint (a :: Schema) (a :: Schema) :: Bool where - Disjoint (Sch '[]) _ = TrueSym0 - Disjoint (Sch ('(:) h t)) s = Apply (Apply (&&@#@$) (Apply (Apply AttrNotInSym0 h) s)) (Apply (Apply DisjointSym0 (Apply SchSym0 t)) s) - type AttrNotIn :: Attribute -> Schema -> Bool - type family AttrNotIn (a :: Attribute) (a :: Schema) :: Bool where - AttrNotIn _ (Sch '[]) = TrueSym0 - AttrNotIn (Attr name u) (Sch ('(:) (Attr name' _) t)) = Apply (Apply (&&@#@$) (Apply (Apply (/=@#@$) name) name')) (Apply (Apply AttrNotInSym0 (Apply (Apply AttrSym0 name) u)) (Apply SchSym0 t)) - type Append :: Schema -> Schema -> Schema - type family Append (a :: Schema) (a :: Schema) :: Schema where - Append (Sch s1) (Sch s2) = Apply SchSym0 (Apply (Apply (++@#@$) s1) s2) - type TFHelper_0123456789876543210 :: U -> U -> Bool - type family TFHelper_0123456789876543210 (a :: U) (a :: U) :: Bool where - TFHelper_0123456789876543210 BOOL BOOL = TrueSym0 - TFHelper_0123456789876543210 BOOL STRING = FalseSym0 - TFHelper_0123456789876543210 BOOL NAT = FalseSym0 - TFHelper_0123456789876543210 BOOL (VEC _ _) = FalseSym0 - TFHelper_0123456789876543210 STRING BOOL = FalseSym0 - TFHelper_0123456789876543210 STRING STRING = TrueSym0 - TFHelper_0123456789876543210 STRING NAT = FalseSym0 - TFHelper_0123456789876543210 STRING (VEC _ _) = FalseSym0 - TFHelper_0123456789876543210 NAT BOOL = FalseSym0 - TFHelper_0123456789876543210 NAT STRING = FalseSym0 - TFHelper_0123456789876543210 NAT NAT = TrueSym0 - TFHelper_0123456789876543210 NAT (VEC _ _) = FalseSym0 - TFHelper_0123456789876543210 (VEC _ _) BOOL = FalseSym0 - TFHelper_0123456789876543210 (VEC _ _) STRING = FalseSym0 - TFHelper_0123456789876543210 (VEC _ _) NAT = FalseSym0 - TFHelper_0123456789876543210 (VEC a_0123456789876543210 a_0123456789876543210) (VEC b_0123456789876543210 b_0123456789876543210) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210) - type TFHelper_0123456789876543210Sym0 :: (~>) U ((~>) U Bool) - data TFHelper_0123456789876543210Sym0 :: (~>) U ((~>) U Bool) - where - TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) => - TFHelper_0123456789876543210Sym0 a0123456789876543210 - type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ()) - type TFHelper_0123456789876543210Sym1 :: U -> (~>) U Bool - data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: U) :: (~>) U Bool - where - TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) => - TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ()) - type TFHelper_0123456789876543210Sym2 :: U -> U -> Bool - type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: U) (a0123456789876543210 :: U) :: Bool where - TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 - instance PEq U where - type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat - -> U -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: U) (a :: Symbol) :: Symbol where - ShowsPrec_0123456789876543210 _ BOOL a_0123456789876543210 = Apply (Apply ShowStringSym0 "BOOL") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ STRING a_0123456789876543210 = Apply (Apply ShowStringSym0 "STRING") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ NAT a_0123456789876543210 = Apply (Apply ShowStringSym0 "NAT") a_0123456789876543210 - ShowsPrec_0123456789876543210 p_0123456789876543210 (VEC arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "VEC ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) U ((~>) Symbol Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) U ((~>) Symbol Symbol)) - where - ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => - ShowsPrec_0123456789876543210Sym0 a0123456789876543210 - type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat - -> (~>) U ((~>) Symbol Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) U ((~>) Symbol Symbol) - where - ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat - -> U -> (~>) Symbol Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: U) :: (~>) Symbol Symbol - where - ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where - suppressUnusedWarnings - = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat - -> U -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: U) (a0123456789876543210 :: Symbol) :: Symbol where - ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - instance PShow U where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat - -> AChar -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: AChar) (a :: Symbol) :: Symbol where - ShowsPrec_0123456789876543210 _ CA a_0123456789876543210 = Apply (Apply ShowStringSym0 "CA") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CB a_0123456789876543210 = Apply (Apply ShowStringSym0 "CB") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CC a_0123456789876543210 = Apply (Apply ShowStringSym0 "CC") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CD a_0123456789876543210 = Apply (Apply ShowStringSym0 "CD") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CE a_0123456789876543210 = Apply (Apply ShowStringSym0 "CE") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CF a_0123456789876543210 = Apply (Apply ShowStringSym0 "CF") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CG a_0123456789876543210 = Apply (Apply ShowStringSym0 "CG") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CH a_0123456789876543210 = Apply (Apply ShowStringSym0 "CH") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CI a_0123456789876543210 = Apply (Apply ShowStringSym0 "CI") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CJ a_0123456789876543210 = Apply (Apply ShowStringSym0 "CJ") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CK a_0123456789876543210 = Apply (Apply ShowStringSym0 "CK") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CL a_0123456789876543210 = Apply (Apply ShowStringSym0 "CL") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CM a_0123456789876543210 = Apply (Apply ShowStringSym0 "CM") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CN a_0123456789876543210 = Apply (Apply ShowStringSym0 "CN") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CO a_0123456789876543210 = Apply (Apply ShowStringSym0 "CO") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CP a_0123456789876543210 = Apply (Apply ShowStringSym0 "CP") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CQ a_0123456789876543210 = Apply (Apply ShowStringSym0 "CQ") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CR a_0123456789876543210 = Apply (Apply ShowStringSym0 "CR") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CS a_0123456789876543210 = Apply (Apply ShowStringSym0 "CS") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CT a_0123456789876543210 = Apply (Apply ShowStringSym0 "CT") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CU a_0123456789876543210 = Apply (Apply ShowStringSym0 "CU") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CV a_0123456789876543210 = Apply (Apply ShowStringSym0 "CV") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CW a_0123456789876543210 = Apply (Apply ShowStringSym0 "CW") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CX a_0123456789876543210 = Apply (Apply ShowStringSym0 "CX") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CY a_0123456789876543210 = Apply (Apply ShowStringSym0 "CY") a_0123456789876543210 - ShowsPrec_0123456789876543210 _ CZ a_0123456789876543210 = Apply (Apply ShowStringSym0 "CZ") a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) AChar ((~>) Symbol Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) AChar ((~>) Symbol Symbol)) - where - ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => - ShowsPrec_0123456789876543210Sym0 a0123456789876543210 - type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat - -> (~>) AChar ((~>) Symbol Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) AChar ((~>) Symbol Symbol) - where - ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat - -> AChar -> (~>) Symbol Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: AChar) :: (~>) Symbol Symbol - where - ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => - ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 - type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where - suppressUnusedWarnings - = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat - -> AChar -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: AChar) (a0123456789876543210 :: Symbol) :: Symbol where - ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - instance PShow AChar where - type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a - type TFHelper_0123456789876543210 :: AChar -> AChar -> Bool - type family TFHelper_0123456789876543210 (a :: AChar) (a :: AChar) :: Bool where - TFHelper_0123456789876543210 CA CA = TrueSym0 - TFHelper_0123456789876543210 CA CB = FalseSym0 - TFHelper_0123456789876543210 CA CC = FalseSym0 - TFHelper_0123456789876543210 CA CD = FalseSym0 - TFHelper_0123456789876543210 CA CE = FalseSym0 - TFHelper_0123456789876543210 CA CF = FalseSym0 - TFHelper_0123456789876543210 CA CG = FalseSym0 - TFHelper_0123456789876543210 CA CH = FalseSym0 - TFHelper_0123456789876543210 CA CI = FalseSym0 - TFHelper_0123456789876543210 CA CJ = FalseSym0 - TFHelper_0123456789876543210 CA CK = FalseSym0 - TFHelper_0123456789876543210 CA CL = FalseSym0 - TFHelper_0123456789876543210 CA CM = FalseSym0 - TFHelper_0123456789876543210 CA CN = FalseSym0 - TFHelper_0123456789876543210 CA CO = FalseSym0 - TFHelper_0123456789876543210 CA CP = FalseSym0 - TFHelper_0123456789876543210 CA CQ = FalseSym0 - TFHelper_0123456789876543210 CA CR = FalseSym0 - TFHelper_0123456789876543210 CA CS = FalseSym0 - TFHelper_0123456789876543210 CA CT = FalseSym0 - TFHelper_0123456789876543210 CA CU = FalseSym0 - TFHelper_0123456789876543210 CA CV = FalseSym0 - TFHelper_0123456789876543210 CA CW = FalseSym0 - TFHelper_0123456789876543210 CA CX = FalseSym0 - TFHelper_0123456789876543210 CA CY = FalseSym0 - TFHelper_0123456789876543210 CA CZ = FalseSym0 - TFHelper_0123456789876543210 CB CA = FalseSym0 - TFHelper_0123456789876543210 CB CB = TrueSym0 - TFHelper_0123456789876543210 CB CC = FalseSym0 - TFHelper_0123456789876543210 CB CD = FalseSym0 - TFHelper_0123456789876543210 CB CE = FalseSym0 - TFHelper_0123456789876543210 CB CF = FalseSym0 - TFHelper_0123456789876543210 CB CG = FalseSym0 - TFHelper_0123456789876543210 CB CH = FalseSym0 - TFHelper_0123456789876543210 CB CI = FalseSym0 - TFHelper_0123456789876543210 CB CJ = FalseSym0 - TFHelper_0123456789876543210 CB CK = FalseSym0 - TFHelper_0123456789876543210 CB CL = FalseSym0 - TFHelper_0123456789876543210 CB CM = FalseSym0 - TFHelper_0123456789876543210 CB CN = FalseSym0 - TFHelper_0123456789876543210 CB CO = FalseSym0 - TFHelper_0123456789876543210 CB CP = FalseSym0 - TFHelper_0123456789876543210 CB CQ = FalseSym0 - TFHelper_0123456789876543210 CB CR = FalseSym0 - TFHelper_0123456789876543210 CB CS = FalseSym0 - TFHelper_0123456789876543210 CB CT = FalseSym0 - TFHelper_0123456789876543210 CB CU = FalseSym0 - TFHelper_0123456789876543210 CB CV = FalseSym0 - TFHelper_0123456789876543210 CB CW = FalseSym0 - TFHelper_0123456789876543210 CB CX = FalseSym0 - TFHelper_0123456789876543210 CB CY = FalseSym0 - TFHelper_0123456789876543210 CB CZ = FalseSym0 - TFHelper_0123456789876543210 CC CA = FalseSym0 - TFHelper_0123456789876543210 CC CB = FalseSym0 - TFHelper_0123456789876543210 CC CC = TrueSym0 - TFHelper_0123456789876543210 CC CD = FalseSym0 - TFHelper_0123456789876543210 CC CE = FalseSym0 - TFHelper_0123456789876543210 CC CF = FalseSym0 - TFHelper_0123456789876543210 CC CG = FalseSym0 - TFHelper_0123456789876543210 CC CH = FalseSym0 - TFHelper_0123456789876543210 CC CI = FalseSym0 - TFHelper_0123456789876543210 CC CJ = FalseSym0 - TFHelper_0123456789876543210 CC CK = FalseSym0 - TFHelper_0123456789876543210 CC CL = FalseSym0 - TFHelper_0123456789876543210 CC CM = FalseSym0 - TFHelper_0123456789876543210 CC CN = FalseSym0 - TFHelper_0123456789876543210 CC CO = FalseSym0 - TFHelper_0123456789876543210 CC CP = FalseSym0 - TFHelper_0123456789876543210 CC CQ = FalseSym0 - TFHelper_0123456789876543210 CC CR = FalseSym0 - TFHelper_0123456789876543210 CC CS = FalseSym0 - TFHelper_0123456789876543210 CC CT = FalseSym0 - TFHelper_0123456789876543210 CC CU = FalseSym0 - TFHelper_0123456789876543210 CC CV = FalseSym0 - TFHelper_0123456789876543210 CC CW = FalseSym0 - TFHelper_0123456789876543210 CC CX = FalseSym0 - TFHelper_0123456789876543210 CC CY = FalseSym0 - TFHelper_0123456789876543210 CC CZ = FalseSym0 - TFHelper_0123456789876543210 CD CA = FalseSym0 - TFHelper_0123456789876543210 CD CB = FalseSym0 - TFHelper_0123456789876543210 CD CC = FalseSym0 - TFHelper_0123456789876543210 CD CD = TrueSym0 - TFHelper_0123456789876543210 CD CE = FalseSym0 - TFHelper_0123456789876543210 CD CF = FalseSym0 - TFHelper_0123456789876543210 CD CG = FalseSym0 - TFHelper_0123456789876543210 CD CH = FalseSym0 - TFHelper_0123456789876543210 CD CI = FalseSym0 - TFHelper_0123456789876543210 CD CJ = FalseSym0 - TFHelper_0123456789876543210 CD CK = FalseSym0 - TFHelper_0123456789876543210 CD CL = FalseSym0 - TFHelper_0123456789876543210 CD CM = FalseSym0 - TFHelper_0123456789876543210 CD CN = FalseSym0 - TFHelper_0123456789876543210 CD CO = FalseSym0 - TFHelper_0123456789876543210 CD CP = FalseSym0 - TFHelper_0123456789876543210 CD CQ = FalseSym0 - TFHelper_0123456789876543210 CD CR = FalseSym0 - TFHelper_0123456789876543210 CD CS = FalseSym0 - TFHelper_0123456789876543210 CD CT = FalseSym0 - TFHelper_0123456789876543210 CD CU = FalseSym0 - TFHelper_0123456789876543210 CD CV = FalseSym0 - TFHelper_0123456789876543210 CD CW = FalseSym0 - TFHelper_0123456789876543210 CD CX = FalseSym0 - TFHelper_0123456789876543210 CD CY = FalseSym0 - TFHelper_0123456789876543210 CD CZ = FalseSym0 - TFHelper_0123456789876543210 CE CA = FalseSym0 - TFHelper_0123456789876543210 CE CB = FalseSym0 - TFHelper_0123456789876543210 CE CC = FalseSym0 - TFHelper_0123456789876543210 CE CD = FalseSym0 - TFHelper_0123456789876543210 CE CE = TrueSym0 - TFHelper_0123456789876543210 CE CF = FalseSym0 - TFHelper_0123456789876543210 CE CG = FalseSym0 - TFHelper_0123456789876543210 CE CH = FalseSym0 - TFHelper_0123456789876543210 CE CI = FalseSym0 - TFHelper_0123456789876543210 CE CJ = FalseSym0 - TFHelper_0123456789876543210 CE CK = FalseSym0 - TFHelper_0123456789876543210 CE CL = FalseSym0 - TFHelper_0123456789876543210 CE CM = FalseSym0 - TFHelper_0123456789876543210 CE CN = FalseSym0 - TFHelper_0123456789876543210 CE CO = FalseSym0 - TFHelper_0123456789876543210 CE CP = FalseSym0 - TFHelper_0123456789876543210 CE CQ = FalseSym0 - TFHelper_0123456789876543210 CE CR = FalseSym0 - TFHelper_0123456789876543210 CE CS = FalseSym0 - TFHelper_0123456789876543210 CE CT = FalseSym0 - TFHelper_0123456789876543210 CE CU = FalseSym0 - TFHelper_0123456789876543210 CE CV = FalseSym0 - TFHelper_0123456789876543210 CE CW = FalseSym0 - TFHelper_0123456789876543210 CE CX = FalseSym0 - TFHelper_0123456789876543210 CE CY = FalseSym0 - TFHelper_0123456789876543210 CE CZ = FalseSym0 - TFHelper_0123456789876543210 CF CA = FalseSym0 - TFHelper_0123456789876543210 CF CB = FalseSym0 - TFHelper_0123456789876543210 CF CC = FalseSym0 - TFHelper_0123456789876543210 CF CD = FalseSym0 - TFHelper_0123456789876543210 CF CE = FalseSym0 - TFHelper_0123456789876543210 CF CF = TrueSym0 - TFHelper_0123456789876543210 CF CG = FalseSym0 - TFHelper_0123456789876543210 CF CH = FalseSym0 - TFHelper_0123456789876543210 CF CI = FalseSym0 - TFHelper_0123456789876543210 CF CJ = FalseSym0 - TFHelper_0123456789876543210 CF CK = FalseSym0 - TFHelper_0123456789876543210 CF CL = FalseSym0 - TFHelper_0123456789876543210 CF CM = FalseSym0 - TFHelper_0123456789876543210 CF CN = FalseSym0 - TFHelper_0123456789876543210 CF CO = FalseSym0 - TFHelper_0123456789876543210 CF CP = FalseSym0 - TFHelper_0123456789876543210 CF CQ = FalseSym0 - TFHelper_0123456789876543210 CF CR = FalseSym0 - TFHelper_0123456789876543210 CF CS = FalseSym0 - TFHelper_0123456789876543210 CF CT = FalseSym0 - TFHelper_0123456789876543210 CF CU = FalseSym0 - TFHelper_0123456789876543210 CF CV = FalseSym0 - TFHelper_0123456789876543210 CF CW = FalseSym0 - TFHelper_0123456789876543210 CF CX = FalseSym0 - TFHelper_0123456789876543210 CF CY = FalseSym0 - TFHelper_0123456789876543210 CF CZ = FalseSym0 - TFHelper_0123456789876543210 CG CA = FalseSym0 - TFHelper_0123456789876543210 CG CB = FalseSym0 - TFHelper_0123456789876543210 CG CC = FalseSym0 - TFHelper_0123456789876543210 CG CD = FalseSym0 - TFHelper_0123456789876543210 CG CE = FalseSym0 - TFHelper_0123456789876543210 CG CF = FalseSym0 - TFHelper_0123456789876543210 CG CG = TrueSym0 - TFHelper_0123456789876543210 CG CH = FalseSym0 - TFHelper_0123456789876543210 CG CI = FalseSym0 - TFHelper_0123456789876543210 CG CJ = FalseSym0 - TFHelper_0123456789876543210 CG CK = FalseSym0 - TFHelper_0123456789876543210 CG CL = FalseSym0 - TFHelper_0123456789876543210 CG CM = FalseSym0 - TFHelper_0123456789876543210 CG CN = FalseSym0 - TFHelper_0123456789876543210 CG CO = FalseSym0 - TFHelper_0123456789876543210 CG CP = FalseSym0 - TFHelper_0123456789876543210 CG CQ = FalseSym0 - TFHelper_0123456789876543210 CG CR = FalseSym0 - TFHelper_0123456789876543210 CG CS = FalseSym0 - TFHelper_0123456789876543210 CG CT = FalseSym0 - TFHelper_0123456789876543210 CG CU = FalseSym0 - TFHelper_0123456789876543210 CG CV = FalseSym0 - TFHelper_0123456789876543210 CG CW = FalseSym0 - TFHelper_0123456789876543210 CG CX = FalseSym0 - TFHelper_0123456789876543210 CG CY = FalseSym0 - TFHelper_0123456789876543210 CG CZ = FalseSym0 - TFHelper_0123456789876543210 CH CA = FalseSym0 - TFHelper_0123456789876543210 CH CB = FalseSym0 - TFHelper_0123456789876543210 CH CC = FalseSym0 - TFHelper_0123456789876543210 CH CD = FalseSym0 - TFHelper_0123456789876543210 CH CE = FalseSym0 - TFHelper_0123456789876543210 CH CF = FalseSym0 - TFHelper_0123456789876543210 CH CG = FalseSym0 - TFHelper_0123456789876543210 CH CH = TrueSym0 - TFHelper_0123456789876543210 CH CI = FalseSym0 - TFHelper_0123456789876543210 CH CJ = FalseSym0 - TFHelper_0123456789876543210 CH CK = FalseSym0 - TFHelper_0123456789876543210 CH CL = FalseSym0 - TFHelper_0123456789876543210 CH CM = FalseSym0 - TFHelper_0123456789876543210 CH CN = FalseSym0 - TFHelper_0123456789876543210 CH CO = FalseSym0 - TFHelper_0123456789876543210 CH CP = FalseSym0 - TFHelper_0123456789876543210 CH CQ = FalseSym0 - TFHelper_0123456789876543210 CH CR = FalseSym0 - TFHelper_0123456789876543210 CH CS = FalseSym0 - TFHelper_0123456789876543210 CH CT = FalseSym0 - TFHelper_0123456789876543210 CH CU = FalseSym0 - TFHelper_0123456789876543210 CH CV = FalseSym0 - TFHelper_0123456789876543210 CH CW = FalseSym0 - TFHelper_0123456789876543210 CH CX = FalseSym0 - TFHelper_0123456789876543210 CH CY = FalseSym0 - TFHelper_0123456789876543210 CH CZ = FalseSym0 - TFHelper_0123456789876543210 CI CA = FalseSym0 - TFHelper_0123456789876543210 CI CB = FalseSym0 - TFHelper_0123456789876543210 CI CC = FalseSym0 - TFHelper_0123456789876543210 CI CD = FalseSym0 - TFHelper_0123456789876543210 CI CE = FalseSym0 - TFHelper_0123456789876543210 CI CF = FalseSym0 - TFHelper_0123456789876543210 CI CG = FalseSym0 - TFHelper_0123456789876543210 CI CH = FalseSym0 - TFHelper_0123456789876543210 CI CI = TrueSym0 - TFHelper_0123456789876543210 CI CJ = FalseSym0 - TFHelper_0123456789876543210 CI CK = FalseSym0 - TFHelper_0123456789876543210 CI CL = FalseSym0 - TFHelper_0123456789876543210 CI CM = FalseSym0 - TFHelper_0123456789876543210 CI CN = FalseSym0 - TFHelper_0123456789876543210 CI CO = FalseSym0 - TFHelper_0123456789876543210 CI CP = FalseSym0 - TFHelper_0123456789876543210 CI CQ = FalseSym0 - TFHelper_0123456789876543210 CI CR = FalseSym0 - TFHelper_0123456789876543210 CI CS = FalseSym0 - TFHelper_0123456789876543210 CI CT = FalseSym0 - TFHelper_0123456789876543210 CI CU = FalseSym0 - TFHelper_0123456789876543210 CI CV = FalseSym0 - TFHelper_0123456789876543210 CI CW = FalseSym0 - TFHelper_0123456789876543210 CI CX = FalseSym0 - TFHelper_0123456789876543210 CI CY = FalseSym0 - TFHelper_0123456789876543210 CI CZ = FalseSym0 - TFHelper_0123456789876543210 CJ CA = FalseSym0 - TFHelper_0123456789876543210 CJ CB = FalseSym0 - TFHelper_0123456789876543210 CJ CC = FalseSym0 - TFHelper_0123456789876543210 CJ CD = FalseSym0 - TFHelper_0123456789876543210 CJ CE = FalseSym0 - TFHelper_0123456789876543210 CJ CF = FalseSym0 - TFHelper_0123456789876543210 CJ CG = FalseSym0 - TFHelper_0123456789876543210 CJ CH = FalseSym0 - TFHelper_0123456789876543210 CJ CI = FalseSym0 - TFHelper_0123456789876543210 CJ CJ = TrueSym0 - TFHelper_0123456789876543210 CJ CK = FalseSym0 - TFHelper_0123456789876543210 CJ CL = FalseSym0 - TFHelper_0123456789876543210 CJ CM = FalseSym0 - TFHelper_0123456789876543210 CJ CN = FalseSym0 - TFHelper_0123456789876543210 CJ CO = FalseSym0 - TFHelper_0123456789876543210 CJ CP = FalseSym0 - TFHelper_0123456789876543210 CJ CQ = FalseSym0 - TFHelper_0123456789876543210 CJ CR = FalseSym0 - TFHelper_0123456789876543210 CJ CS = FalseSym0 - TFHelper_0123456789876543210 CJ CT = FalseSym0 - TFHelper_0123456789876543210 CJ CU = FalseSym0 - TFHelper_0123456789876543210 CJ CV = FalseSym0 - TFHelper_0123456789876543210 CJ CW = FalseSym0 - TFHelper_0123456789876543210 CJ CX = FalseSym0 - TFHelper_0123456789876543210 CJ CY = FalseSym0 - TFHelper_0123456789876543210 CJ CZ = FalseSym0 - TFHelper_0123456789876543210 CK CA = FalseSym0 - TFHelper_0123456789876543210 CK CB = FalseSym0 - TFHelper_0123456789876543210 CK CC = FalseSym0 - TFHelper_0123456789876543210 CK CD = FalseSym0 - TFHelper_0123456789876543210 CK CE = FalseSym0 - TFHelper_0123456789876543210 CK CF = FalseSym0 - TFHelper_0123456789876543210 CK CG = FalseSym0 - TFHelper_0123456789876543210 CK CH = FalseSym0 - TFHelper_0123456789876543210 CK CI = FalseSym0 - TFHelper_0123456789876543210 CK CJ = FalseSym0 - TFHelper_0123456789876543210 CK CK = TrueSym0 - TFHelper_0123456789876543210 CK CL = FalseSym0 - TFHelper_0123456789876543210 CK CM = FalseSym0 - TFHelper_0123456789876543210 CK CN = FalseSym0 - TFHelper_0123456789876543210 CK CO = FalseSym0 - TFHelper_0123456789876543210 CK CP = FalseSym0 - TFHelper_0123456789876543210 CK CQ = FalseSym0 - TFHelper_0123456789876543210 CK CR = FalseSym0 - TFHelper_0123456789876543210 CK CS = FalseSym0 - TFHelper_0123456789876543210 CK CT = FalseSym0 - TFHelper_0123456789876543210 CK CU = FalseSym0 - TFHelper_0123456789876543210 CK CV = FalseSym0 - TFHelper_0123456789876543210 CK CW = FalseSym0 - TFHelper_0123456789876543210 CK CX = FalseSym0 - TFHelper_0123456789876543210 CK CY = FalseSym0 - TFHelper_0123456789876543210 CK CZ = FalseSym0 - TFHelper_0123456789876543210 CL CA = FalseSym0 - TFHelper_0123456789876543210 CL CB = FalseSym0 - TFHelper_0123456789876543210 CL CC = FalseSym0 - TFHelper_0123456789876543210 CL CD = FalseSym0 - TFHelper_0123456789876543210 CL CE = FalseSym0 - TFHelper_0123456789876543210 CL CF = FalseSym0 - TFHelper_0123456789876543210 CL CG = FalseSym0 - TFHelper_0123456789876543210 CL CH = FalseSym0 - TFHelper_0123456789876543210 CL CI = FalseSym0 - TFHelper_0123456789876543210 CL CJ = FalseSym0 - TFHelper_0123456789876543210 CL CK = FalseSym0 - TFHelper_0123456789876543210 CL CL = TrueSym0 - TFHelper_0123456789876543210 CL CM = FalseSym0 - TFHelper_0123456789876543210 CL CN = FalseSym0 - TFHelper_0123456789876543210 CL CO = FalseSym0 - TFHelper_0123456789876543210 CL CP = FalseSym0 - TFHelper_0123456789876543210 CL CQ = FalseSym0 - TFHelper_0123456789876543210 CL CR = FalseSym0 - TFHelper_0123456789876543210 CL CS = FalseSym0 - TFHelper_0123456789876543210 CL CT = FalseSym0 - TFHelper_0123456789876543210 CL CU = FalseSym0 - TFHelper_0123456789876543210 CL CV = FalseSym0 - TFHelper_0123456789876543210 CL CW = FalseSym0 - TFHelper_0123456789876543210 CL CX = FalseSym0 - TFHelper_0123456789876543210 CL CY = FalseSym0 - TFHelper_0123456789876543210 CL CZ = FalseSym0 - TFHelper_0123456789876543210 CM CA = FalseSym0 - TFHelper_0123456789876543210 CM CB = FalseSym0 - TFHelper_0123456789876543210 CM CC = FalseSym0 - TFHelper_0123456789876543210 CM CD = FalseSym0 - TFHelper_0123456789876543210 CM CE = FalseSym0 - TFHelper_0123456789876543210 CM CF = FalseSym0 - TFHelper_0123456789876543210 CM CG = FalseSym0 - TFHelper_0123456789876543210 CM CH = FalseSym0 - TFHelper_0123456789876543210 CM CI = FalseSym0 - TFHelper_0123456789876543210 CM CJ = FalseSym0 - TFHelper_0123456789876543210 CM CK = FalseSym0 - TFHelper_0123456789876543210 CM CL = FalseSym0 - TFHelper_0123456789876543210 CM CM = TrueSym0 - TFHelper_0123456789876543210 CM CN = FalseSym0 - TFHelper_0123456789876543210 CM CO = FalseSym0 - TFHelper_0123456789876543210 CM CP = FalseSym0 - TFHelper_0123456789876543210 CM CQ = FalseSym0 - TFHelper_0123456789876543210 CM CR = FalseSym0 - TFHelper_0123456789876543210 CM CS = FalseSym0 - TFHelper_0123456789876543210 CM CT = FalseSym0 - TFHelper_0123456789876543210 CM CU = FalseSym0 - TFHelper_0123456789876543210 CM CV = FalseSym0 - TFHelper_0123456789876543210 CM CW = FalseSym0 - TFHelper_0123456789876543210 CM CX = FalseSym0 - TFHelper_0123456789876543210 CM CY = FalseSym0 - TFHelper_0123456789876543210 CM CZ = FalseSym0 - TFHelper_0123456789876543210 CN CA = FalseSym0 - TFHelper_0123456789876543210 CN CB = FalseSym0 - TFHelper_0123456789876543210 CN CC = FalseSym0 - TFHelper_0123456789876543210 CN CD = FalseSym0 - TFHelper_0123456789876543210 CN CE = FalseSym0 - TFHelper_0123456789876543210 CN CF = FalseSym0 - TFHelper_0123456789876543210 CN CG = FalseSym0 - TFHelper_0123456789876543210 CN CH = FalseSym0 - TFHelper_0123456789876543210 CN CI = FalseSym0 - TFHelper_0123456789876543210 CN CJ = FalseSym0 - TFHelper_0123456789876543210 CN CK = FalseSym0 - TFHelper_0123456789876543210 CN CL = FalseSym0 - TFHelper_0123456789876543210 CN CM = FalseSym0 - TFHelper_0123456789876543210 CN CN = TrueSym0 - TFHelper_0123456789876543210 CN CO = FalseSym0 - TFHelper_0123456789876543210 CN CP = FalseSym0 - TFHelper_0123456789876543210 CN CQ = FalseSym0 - TFHelper_0123456789876543210 CN CR = FalseSym0 - TFHelper_0123456789876543210 CN CS = FalseSym0 - TFHelper_0123456789876543210 CN CT = FalseSym0 - TFHelper_0123456789876543210 CN CU = FalseSym0 - TFHelper_0123456789876543210 CN CV = FalseSym0 - TFHelper_0123456789876543210 CN CW = FalseSym0 - TFHelper_0123456789876543210 CN CX = FalseSym0 - TFHelper_0123456789876543210 CN CY = FalseSym0 - TFHelper_0123456789876543210 CN CZ = FalseSym0 - TFHelper_0123456789876543210 CO CA = FalseSym0 - TFHelper_0123456789876543210 CO CB = FalseSym0 - TFHelper_0123456789876543210 CO CC = FalseSym0 - TFHelper_0123456789876543210 CO CD = FalseSym0 - TFHelper_0123456789876543210 CO CE = FalseSym0 - TFHelper_0123456789876543210 CO CF = FalseSym0 - TFHelper_0123456789876543210 CO CG = FalseSym0 - TFHelper_0123456789876543210 CO CH = FalseSym0 - TFHelper_0123456789876543210 CO CI = FalseSym0 - TFHelper_0123456789876543210 CO CJ = FalseSym0 - TFHelper_0123456789876543210 CO CK = FalseSym0 - TFHelper_0123456789876543210 CO CL = FalseSym0 - TFHelper_0123456789876543210 CO CM = FalseSym0 - TFHelper_0123456789876543210 CO CN = FalseSym0 - TFHelper_0123456789876543210 CO CO = TrueSym0 - TFHelper_0123456789876543210 CO CP = FalseSym0 - TFHelper_0123456789876543210 CO CQ = FalseSym0 - TFHelper_0123456789876543210 CO CR = FalseSym0 - TFHelper_0123456789876543210 CO CS = FalseSym0 - TFHelper_0123456789876543210 CO CT = FalseSym0 - TFHelper_0123456789876543210 CO CU = FalseSym0 - TFHelper_0123456789876543210 CO CV = FalseSym0 - TFHelper_0123456789876543210 CO CW = FalseSym0 - TFHelper_0123456789876543210 CO CX = FalseSym0 - TFHelper_0123456789876543210 CO CY = FalseSym0 - TFHelper_0123456789876543210 CO CZ = FalseSym0 - TFHelper_0123456789876543210 CP CA = FalseSym0 - TFHelper_0123456789876543210 CP CB = FalseSym0 - TFHelper_0123456789876543210 CP CC = FalseSym0 - TFHelper_0123456789876543210 CP CD = FalseSym0 - TFHelper_0123456789876543210 CP CE = FalseSym0 - TFHelper_0123456789876543210 CP CF = FalseSym0 - TFHelper_0123456789876543210 CP CG = FalseSym0 - TFHelper_0123456789876543210 CP CH = FalseSym0 - TFHelper_0123456789876543210 CP CI = FalseSym0 - TFHelper_0123456789876543210 CP CJ = FalseSym0 - TFHelper_0123456789876543210 CP CK = FalseSym0 - TFHelper_0123456789876543210 CP CL = FalseSym0 - TFHelper_0123456789876543210 CP CM = FalseSym0 - TFHelper_0123456789876543210 CP CN = FalseSym0 - TFHelper_0123456789876543210 CP CO = FalseSym0 - TFHelper_0123456789876543210 CP CP = TrueSym0 - TFHelper_0123456789876543210 CP CQ = FalseSym0 - TFHelper_0123456789876543210 CP CR = FalseSym0 - TFHelper_0123456789876543210 CP CS = FalseSym0 - TFHelper_0123456789876543210 CP CT = FalseSym0 - TFHelper_0123456789876543210 CP CU = FalseSym0 - TFHelper_0123456789876543210 CP CV = FalseSym0 - TFHelper_0123456789876543210 CP CW = FalseSym0 - TFHelper_0123456789876543210 CP CX = FalseSym0 - TFHelper_0123456789876543210 CP CY = FalseSym0 - TFHelper_0123456789876543210 CP CZ = FalseSym0 - TFHelper_0123456789876543210 CQ CA = FalseSym0 - TFHelper_0123456789876543210 CQ CB = FalseSym0 - TFHelper_0123456789876543210 CQ CC = FalseSym0 - TFHelper_0123456789876543210 CQ CD = FalseSym0 - TFHelper_0123456789876543210 CQ CE = FalseSym0 - TFHelper_0123456789876543210 CQ CF = FalseSym0 - TFHelper_0123456789876543210 CQ CG = FalseSym0 - TFHelper_0123456789876543210 CQ CH = FalseSym0 - TFHelper_0123456789876543210 CQ CI = FalseSym0 - TFHelper_0123456789876543210 CQ CJ = FalseSym0 - TFHelper_0123456789876543210 CQ CK = FalseSym0 - TFHelper_0123456789876543210 CQ CL = FalseSym0 - TFHelper_0123456789876543210 CQ CM = FalseSym0 - TFHelper_0123456789876543210 CQ CN = FalseSym0 - TFHelper_0123456789876543210 CQ CO = FalseSym0 - TFHelper_0123456789876543210 CQ CP = FalseSym0 - TFHelper_0123456789876543210 CQ CQ = TrueSym0 - TFHelper_0123456789876543210 CQ CR = FalseSym0 - TFHelper_0123456789876543210 CQ CS = FalseSym0 - TFHelper_0123456789876543210 CQ CT = FalseSym0 - TFHelper_0123456789876543210 CQ CU = FalseSym0 - TFHelper_0123456789876543210 CQ CV = FalseSym0 - TFHelper_0123456789876543210 CQ CW = FalseSym0 - TFHelper_0123456789876543210 CQ CX = FalseSym0 - TFHelper_0123456789876543210 CQ CY = FalseSym0 - TFHelper_0123456789876543210 CQ CZ = FalseSym0 - TFHelper_0123456789876543210 CR CA = FalseSym0 - TFHelper_0123456789876543210 CR CB = FalseSym0 - TFHelper_0123456789876543210 CR CC = FalseSym0 - TFHelper_0123456789876543210 CR CD = FalseSym0 - TFHelper_0123456789876543210 CR CE = FalseSym0 - TFHelper_0123456789876543210 CR CF = FalseSym0 - TFHelper_0123456789876543210 CR CG = FalseSym0 - TFHelper_0123456789876543210 CR CH = FalseSym0 - TFHelper_0123456789876543210 CR CI = FalseSym0 - TFHelper_0123456789876543210 CR CJ = FalseSym0 - TFHelper_0123456789876543210 CR CK = FalseSym0 - TFHelper_0123456789876543210 CR CL = FalseSym0 - TFHelper_0123456789876543210 CR CM = FalseSym0 - TFHelper_0123456789876543210 CR CN = FalseSym0 - TFHelper_0123456789876543210 CR CO = FalseSym0 - TFHelper_0123456789876543210 CR CP = FalseSym0 - TFHelper_0123456789876543210 CR CQ = FalseSym0 - TFHelper_0123456789876543210 CR CR = TrueSym0 - TFHelper_0123456789876543210 CR CS = FalseSym0 - TFHelper_0123456789876543210 CR CT = FalseSym0 - TFHelper_0123456789876543210 CR CU = FalseSym0 - TFHelper_0123456789876543210 CR CV = FalseSym0 - TFHelper_0123456789876543210 CR CW = FalseSym0 - TFHelper_0123456789876543210 CR CX = FalseSym0 - TFHelper_0123456789876543210 CR CY = FalseSym0 - TFHelper_0123456789876543210 CR CZ = FalseSym0 - TFHelper_0123456789876543210 CS CA = FalseSym0 - TFHelper_0123456789876543210 CS CB = FalseSym0 - TFHelper_0123456789876543210 CS CC = FalseSym0 - TFHelper_0123456789876543210 CS CD = FalseSym0 - TFHelper_0123456789876543210 CS CE = FalseSym0 - TFHelper_0123456789876543210 CS CF = FalseSym0 - TFHelper_0123456789876543210 CS CG = FalseSym0 - TFHelper_0123456789876543210 CS CH = FalseSym0 - TFHelper_0123456789876543210 CS CI = FalseSym0 - TFHelper_0123456789876543210 CS CJ = FalseSym0 - TFHelper_0123456789876543210 CS CK = FalseSym0 - TFHelper_0123456789876543210 CS CL = FalseSym0 - TFHelper_0123456789876543210 CS CM = FalseSym0 - TFHelper_0123456789876543210 CS CN = FalseSym0 - TFHelper_0123456789876543210 CS CO = FalseSym0 - TFHelper_0123456789876543210 CS CP = FalseSym0 - TFHelper_0123456789876543210 CS CQ = FalseSym0 - TFHelper_0123456789876543210 CS CR = FalseSym0 - TFHelper_0123456789876543210 CS CS = TrueSym0 - TFHelper_0123456789876543210 CS CT = FalseSym0 - TFHelper_0123456789876543210 CS CU = FalseSym0 - TFHelper_0123456789876543210 CS CV = FalseSym0 - TFHelper_0123456789876543210 CS CW = FalseSym0 - TFHelper_0123456789876543210 CS CX = FalseSym0 - TFHelper_0123456789876543210 CS CY = FalseSym0 - TFHelper_0123456789876543210 CS CZ = FalseSym0 - TFHelper_0123456789876543210 CT CA = FalseSym0 - TFHelper_0123456789876543210 CT CB = FalseSym0 - TFHelper_0123456789876543210 CT CC = FalseSym0 - TFHelper_0123456789876543210 CT CD = FalseSym0 - TFHelper_0123456789876543210 CT CE = FalseSym0 - TFHelper_0123456789876543210 CT CF = FalseSym0 - TFHelper_0123456789876543210 CT CG = FalseSym0 - TFHelper_0123456789876543210 CT CH = FalseSym0 - TFHelper_0123456789876543210 CT CI = FalseSym0 - TFHelper_0123456789876543210 CT CJ = FalseSym0 - TFHelper_0123456789876543210 CT CK = FalseSym0 - TFHelper_0123456789876543210 CT CL = FalseSym0 - TFHelper_0123456789876543210 CT CM = FalseSym0 - TFHelper_0123456789876543210 CT CN = FalseSym0 - TFHelper_0123456789876543210 CT CO = FalseSym0 - TFHelper_0123456789876543210 CT CP = FalseSym0 - TFHelper_0123456789876543210 CT CQ = FalseSym0 - TFHelper_0123456789876543210 CT CR = FalseSym0 - TFHelper_0123456789876543210 CT CS = FalseSym0 - TFHelper_0123456789876543210 CT CT = TrueSym0 - TFHelper_0123456789876543210 CT CU = FalseSym0 - TFHelper_0123456789876543210 CT CV = FalseSym0 - TFHelper_0123456789876543210 CT CW = FalseSym0 - TFHelper_0123456789876543210 CT CX = FalseSym0 - TFHelper_0123456789876543210 CT CY = FalseSym0 - TFHelper_0123456789876543210 CT CZ = FalseSym0 - TFHelper_0123456789876543210 CU CA = FalseSym0 - TFHelper_0123456789876543210 CU CB = FalseSym0 - TFHelper_0123456789876543210 CU CC = FalseSym0 - TFHelper_0123456789876543210 CU CD = FalseSym0 - TFHelper_0123456789876543210 CU CE = FalseSym0 - TFHelper_0123456789876543210 CU CF = FalseSym0 - TFHelper_0123456789876543210 CU CG = FalseSym0 - TFHelper_0123456789876543210 CU CH = FalseSym0 - TFHelper_0123456789876543210 CU CI = FalseSym0 - TFHelper_0123456789876543210 CU CJ = FalseSym0 - TFHelper_0123456789876543210 CU CK = FalseSym0 - TFHelper_0123456789876543210 CU CL = FalseSym0 - TFHelper_0123456789876543210 CU CM = FalseSym0 - TFHelper_0123456789876543210 CU CN = FalseSym0 - TFHelper_0123456789876543210 CU CO = FalseSym0 - TFHelper_0123456789876543210 CU CP = FalseSym0 - TFHelper_0123456789876543210 CU CQ = FalseSym0 - TFHelper_0123456789876543210 CU CR = FalseSym0 - TFHelper_0123456789876543210 CU CS = FalseSym0 - TFHelper_0123456789876543210 CU CT = FalseSym0 - TFHelper_0123456789876543210 CU CU = TrueSym0 - TFHelper_0123456789876543210 CU CV = FalseSym0 - TFHelper_0123456789876543210 CU CW = FalseSym0 - TFHelper_0123456789876543210 CU CX = FalseSym0 - TFHelper_0123456789876543210 CU CY = FalseSym0 - TFHelper_0123456789876543210 CU CZ = FalseSym0 - TFHelper_0123456789876543210 CV CA = FalseSym0 - TFHelper_0123456789876543210 CV CB = FalseSym0 - TFHelper_0123456789876543210 CV CC = FalseSym0 - TFHelper_0123456789876543210 CV CD = FalseSym0 - TFHelper_0123456789876543210 CV CE = FalseSym0 - TFHelper_0123456789876543210 CV CF = FalseSym0 - TFHelper_0123456789876543210 CV CG = FalseSym0 - TFHelper_0123456789876543210 CV CH = FalseSym0 - TFHelper_0123456789876543210 CV CI = FalseSym0 - TFHelper_0123456789876543210 CV CJ = FalseSym0 - TFHelper_0123456789876543210 CV CK = FalseSym0 - TFHelper_0123456789876543210 CV CL = FalseSym0 - TFHelper_0123456789876543210 CV CM = FalseSym0 - TFHelper_0123456789876543210 CV CN = FalseSym0 - TFHelper_0123456789876543210 CV CO = FalseSym0 - TFHelper_0123456789876543210 CV CP = FalseSym0 - TFHelper_0123456789876543210 CV CQ = FalseSym0 - TFHelper_0123456789876543210 CV CR = FalseSym0 - TFHelper_0123456789876543210 CV CS = FalseSym0 - TFHelper_0123456789876543210 CV CT = FalseSym0 - TFHelper_0123456789876543210 CV CU = FalseSym0 - TFHelper_0123456789876543210 CV CV = TrueSym0 - TFHelper_0123456789876543210 CV CW = FalseSym0 - TFHelper_0123456789876543210 CV CX = FalseSym0 - TFHelper_0123456789876543210 CV CY = FalseSym0 - TFHelper_0123456789876543210 CV CZ = FalseSym0 - TFHelper_0123456789876543210 CW CA = FalseSym0 - TFHelper_0123456789876543210 CW CB = FalseSym0 - TFHelper_0123456789876543210 CW CC = FalseSym0 - TFHelper_0123456789876543210 CW CD = FalseSym0 - TFHelper_0123456789876543210 CW CE = FalseSym0 - TFHelper_0123456789876543210 CW CF = FalseSym0 - TFHelper_0123456789876543210 CW CG = FalseSym0 - TFHelper_0123456789876543210 CW CH = FalseSym0 - TFHelper_0123456789876543210 CW CI = FalseSym0 - TFHelper_0123456789876543210 CW CJ = FalseSym0 - TFHelper_0123456789876543210 CW CK = FalseSym0 - TFHelper_0123456789876543210 CW CL = FalseSym0 - TFHelper_0123456789876543210 CW CM = FalseSym0 - TFHelper_0123456789876543210 CW CN = FalseSym0 - TFHelper_0123456789876543210 CW CO = FalseSym0 - TFHelper_0123456789876543210 CW CP = FalseSym0 - TFHelper_0123456789876543210 CW CQ = FalseSym0 - TFHelper_0123456789876543210 CW CR = FalseSym0 - TFHelper_0123456789876543210 CW CS = FalseSym0 - TFHelper_0123456789876543210 CW CT = FalseSym0 - TFHelper_0123456789876543210 CW CU = FalseSym0 - TFHelper_0123456789876543210 CW CV = FalseSym0 - TFHelper_0123456789876543210 CW CW = TrueSym0 - TFHelper_0123456789876543210 CW CX = FalseSym0 - TFHelper_0123456789876543210 CW CY = FalseSym0 - TFHelper_0123456789876543210 CW CZ = FalseSym0 - TFHelper_0123456789876543210 CX CA = FalseSym0 - TFHelper_0123456789876543210 CX CB = FalseSym0 - TFHelper_0123456789876543210 CX CC = FalseSym0 - TFHelper_0123456789876543210 CX CD = FalseSym0 - TFHelper_0123456789876543210 CX CE = FalseSym0 - TFHelper_0123456789876543210 CX CF = FalseSym0 - TFHelper_0123456789876543210 CX CG = FalseSym0 - TFHelper_0123456789876543210 CX CH = FalseSym0 - TFHelper_0123456789876543210 CX CI = FalseSym0 - TFHelper_0123456789876543210 CX CJ = FalseSym0 - TFHelper_0123456789876543210 CX CK = FalseSym0 - TFHelper_0123456789876543210 CX CL = FalseSym0 - TFHelper_0123456789876543210 CX CM = FalseSym0 - TFHelper_0123456789876543210 CX CN = FalseSym0 - TFHelper_0123456789876543210 CX CO = FalseSym0 - TFHelper_0123456789876543210 CX CP = FalseSym0 - TFHelper_0123456789876543210 CX CQ = FalseSym0 - TFHelper_0123456789876543210 CX CR = FalseSym0 - TFHelper_0123456789876543210 CX CS = FalseSym0 - TFHelper_0123456789876543210 CX CT = FalseSym0 - TFHelper_0123456789876543210 CX CU = FalseSym0 - TFHelper_0123456789876543210 CX CV = FalseSym0 - TFHelper_0123456789876543210 CX CW = FalseSym0 - TFHelper_0123456789876543210 CX CX = TrueSym0 - TFHelper_0123456789876543210 CX CY = FalseSym0 - TFHelper_0123456789876543210 CX CZ = FalseSym0 - TFHelper_0123456789876543210 CY CA = FalseSym0 - TFHelper_0123456789876543210 CY CB = FalseSym0 - TFHelper_0123456789876543210 CY CC = FalseSym0 - TFHelper_0123456789876543210 CY CD = FalseSym0 - TFHelper_0123456789876543210 CY CE = FalseSym0 - TFHelper_0123456789876543210 CY CF = FalseSym0 - TFHelper_0123456789876543210 CY CG = FalseSym0 - TFHelper_0123456789876543210 CY CH = FalseSym0 - TFHelper_0123456789876543210 CY CI = FalseSym0 - TFHelper_0123456789876543210 CY CJ = FalseSym0 - TFHelper_0123456789876543210 CY CK = FalseSym0 - TFHelper_0123456789876543210 CY CL = FalseSym0 - TFHelper_0123456789876543210 CY CM = FalseSym0 - TFHelper_0123456789876543210 CY CN = FalseSym0 - TFHelper_0123456789876543210 CY CO = FalseSym0 - TFHelper_0123456789876543210 CY CP = FalseSym0 - TFHelper_0123456789876543210 CY CQ = FalseSym0 - TFHelper_0123456789876543210 CY CR = FalseSym0 - TFHelper_0123456789876543210 CY CS = FalseSym0 - TFHelper_0123456789876543210 CY CT = FalseSym0 - TFHelper_0123456789876543210 CY CU = FalseSym0 - TFHelper_0123456789876543210 CY CV = FalseSym0 - TFHelper_0123456789876543210 CY CW = FalseSym0 - TFHelper_0123456789876543210 CY CX = FalseSym0 - TFHelper_0123456789876543210 CY CY = TrueSym0 - TFHelper_0123456789876543210 CY CZ = FalseSym0 - TFHelper_0123456789876543210 CZ CA = FalseSym0 - TFHelper_0123456789876543210 CZ CB = FalseSym0 - TFHelper_0123456789876543210 CZ CC = FalseSym0 - TFHelper_0123456789876543210 CZ CD = FalseSym0 - TFHelper_0123456789876543210 CZ CE = FalseSym0 - TFHelper_0123456789876543210 CZ CF = FalseSym0 - TFHelper_0123456789876543210 CZ CG = FalseSym0 - TFHelper_0123456789876543210 CZ CH = FalseSym0 - TFHelper_0123456789876543210 CZ CI = FalseSym0 - TFHelper_0123456789876543210 CZ CJ = FalseSym0 - TFHelper_0123456789876543210 CZ CK = FalseSym0 - TFHelper_0123456789876543210 CZ CL = FalseSym0 - TFHelper_0123456789876543210 CZ CM = FalseSym0 - TFHelper_0123456789876543210 CZ CN = FalseSym0 - TFHelper_0123456789876543210 CZ CO = FalseSym0 - TFHelper_0123456789876543210 CZ CP = FalseSym0 - TFHelper_0123456789876543210 CZ CQ = FalseSym0 - TFHelper_0123456789876543210 CZ CR = FalseSym0 - TFHelper_0123456789876543210 CZ CS = FalseSym0 - TFHelper_0123456789876543210 CZ CT = FalseSym0 - TFHelper_0123456789876543210 CZ CU = FalseSym0 - TFHelper_0123456789876543210 CZ CV = FalseSym0 - TFHelper_0123456789876543210 CZ CW = FalseSym0 - TFHelper_0123456789876543210 CZ CX = FalseSym0 - TFHelper_0123456789876543210 CZ CY = FalseSym0 - TFHelper_0123456789876543210 CZ CZ = TrueSym0 - type TFHelper_0123456789876543210Sym0 :: (~>) AChar ((~>) AChar Bool) - data TFHelper_0123456789876543210Sym0 :: (~>) AChar ((~>) AChar Bool) - where - TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) => - TFHelper_0123456789876543210Sym0 a0123456789876543210 - type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210 - instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where - suppressUnusedWarnings - = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ()) - type TFHelper_0123456789876543210Sym1 :: AChar -> (~>) AChar Bool - data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: AChar) :: (~>) AChar Bool - where - TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) => - TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 - type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where - suppressUnusedWarnings - = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ()) - type TFHelper_0123456789876543210Sym2 :: AChar -> AChar -> Bool - type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: AChar) (a0123456789876543210 :: AChar) :: Bool where - TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 - instance PEq AChar where - type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a - sLookup :: - forall (t :: [AChar]) (t :: Schema). - Sing t -> Sing t -> Sing (Apply (Apply LookupSym0 t) t :: U) - sOccurs :: - forall (t :: [AChar]) (t :: Schema). - Sing t -> Sing t -> Sing (Apply (Apply OccursSym0 t) t :: Bool) - sDisjoint :: - forall (t :: Schema) (t :: Schema). - Sing t -> Sing t -> Sing (Apply (Apply DisjointSym0 t) t :: Bool) - sAttrNotIn :: - forall (t :: Attribute) (t :: Schema). - Sing t -> Sing t -> Sing (Apply (Apply AttrNotInSym0 t) t :: Bool) - sAppend :: - forall (t :: Schema) (t :: Schema). - Sing t -> Sing t -> Sing (Apply (Apply AppendSym0 t) t :: Schema) - sLookup _ (SSch SNil) = sUndefined - sLookup - (sName :: Sing name) - (SSch (SCons (SAttr (sName' :: Sing name') (sU :: Sing u)) - (sAttrs :: Sing attrs))) - = let - sScrutinee_0123456789876543210 :: - Sing @_ (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name name' u attrs) - sScrutinee_0123456789876543210 - = (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sName)) - sName' - in - (GHC.Base.id - @(Sing (Case_0123456789876543210 name name' u attrs (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name name' u attrs) :: U))) - (case sScrutinee_0123456789876543210 of - STrue -> sU - SFalse - -> (applySing ((applySing ((singFun2 @LookupSym0) sLookup)) sName)) - ((applySing ((singFun1 @SchSym0) SSch)) sAttrs)) - sOccurs _ (SSch SNil) = SFalse - sOccurs - (sName :: Sing name) - (SSch (SCons (SAttr (sName' :: Sing name') _) - (sAttrs :: Sing attrs))) - = (applySing - ((applySing ((singFun2 @(||@#@$)) (%||))) - ((applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sName)) - sName'))) - ((applySing ((applySing ((singFun2 @OccursSym0) sOccurs)) sName)) - ((applySing ((singFun1 @SchSym0) SSch)) sAttrs)) - sDisjoint (SSch SNil) _ = STrue - sDisjoint - (SSch (SCons (sH :: Sing h) (sT :: Sing t))) - (sS :: Sing s) - = (applySing - ((applySing ((singFun2 @(&&@#@$)) (%&&))) - ((applySing - ((applySing ((singFun2 @AttrNotInSym0) sAttrNotIn)) sH)) - sS))) - ((applySing - ((applySing ((singFun2 @DisjointSym0) sDisjoint)) - ((applySing ((singFun1 @SchSym0) SSch)) sT))) - sS) - sAttrNotIn _ (SSch SNil) = STrue - sAttrNotIn - (SAttr (sName :: Sing name) (sU :: Sing u)) - (SSch (SCons (SAttr (sName' :: Sing name') _) (sT :: Sing t))) - = (applySing - ((applySing ((singFun2 @(&&@#@$)) (%&&))) - ((applySing ((applySing ((singFun2 @(/=@#@$)) (%/=))) sName)) - sName'))) - ((applySing - ((applySing ((singFun2 @AttrNotInSym0) sAttrNotIn)) - ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sName)) sU))) - ((applySing ((singFun1 @SchSym0) SSch)) sT)) - sAppend (SSch (sS1 :: Sing s1)) (SSch (sS2 :: Sing s2)) - = (applySing ((singFun1 @SchSym0) SSch)) - ((applySing ((applySing ((singFun2 @(++@#@$)) (%++))) sS1)) sS2) - instance SingI (LookupSym0 :: (~>) [AChar] ((~>) Schema U)) where - sing = (singFun2 @LookupSym0) sLookup - instance SingI d => - SingI (LookupSym1 (d :: [AChar]) :: (~>) Schema U) where - sing = (singFun1 @(LookupSym1 (d :: [AChar]))) (sLookup (sing @d)) - instance SingI (OccursSym0 :: (~>) [AChar] ((~>) Schema Bool)) where - sing = (singFun2 @OccursSym0) sOccurs - instance SingI d => - SingI (OccursSym1 (d :: [AChar]) :: (~>) Schema Bool) where - sing = (singFun1 @(OccursSym1 (d :: [AChar]))) (sOccurs (sing @d)) - instance SingI (DisjointSym0 :: (~>) Schema ((~>) Schema Bool)) where - sing = (singFun2 @DisjointSym0) sDisjoint - instance SingI d => - SingI (DisjointSym1 (d :: Schema) :: (~>) Schema Bool) where - sing - = (singFun1 @(DisjointSym1 (d :: Schema))) (sDisjoint (sing @d)) - instance SingI (AttrNotInSym0 :: (~>) Attribute ((~>) Schema Bool)) where - sing = (singFun2 @AttrNotInSym0) sAttrNotIn - instance SingI d => - SingI (AttrNotInSym1 (d :: Attribute) :: (~>) Schema Bool) where - sing - = (singFun1 @(AttrNotInSym1 (d :: Attribute))) - (sAttrNotIn (sing @d)) - instance SingI (AppendSym0 :: (~>) Schema ((~>) Schema Schema)) where - sing = (singFun2 @AppendSym0) sAppend - instance SingI d => - SingI (AppendSym1 (d :: Schema) :: (~>) Schema Schema) where - sing = (singFun1 @(AppendSym1 (d :: Schema))) (sAppend (sing @d)) - data SU :: U -> Type - where - SBOOL :: SU (BOOL :: U) - SSTRING :: SU (STRING :: U) - SNAT :: SU (NAT :: U) - SVEC :: forall (n :: U) (n :: Nat). - (Sing n) -> (Sing n) -> SU (VEC n n :: U) - type instance Sing @U = SU - instance SingKind U where - type Demote U = U - fromSing SBOOL = BOOL - fromSing SSTRING = STRING - fromSing SNAT = NAT - fromSing (SVEC b b) = (VEC (fromSing b)) (fromSing b) - toSing BOOL = SomeSing SBOOL - toSing STRING = SomeSing SSTRING - toSing NAT = SomeSing SNAT - toSing (VEC (b :: Demote U) (b :: Demote Nat)) - = case - ((,) (toSing b :: SomeSing U)) (toSing b :: SomeSing Nat) - of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SVEC c) c) } - data SAChar :: AChar -> Type - where - SCA :: SAChar (CA :: AChar) - SCB :: SAChar (CB :: AChar) - SCC :: SAChar (CC :: AChar) - SCD :: SAChar (CD :: AChar) - SCE :: SAChar (CE :: AChar) - SCF :: SAChar (CF :: AChar) - SCG :: SAChar (CG :: AChar) - SCH :: SAChar (CH :: AChar) - SCI :: SAChar (CI :: AChar) - SCJ :: SAChar (CJ :: AChar) - SCK :: SAChar (CK :: AChar) - SCL :: SAChar (CL :: AChar) - SCM :: SAChar (CM :: AChar) - SCN :: SAChar (CN :: AChar) - SCO :: SAChar (CO :: AChar) - SCP :: SAChar (CP :: AChar) - SCQ :: SAChar (CQ :: AChar) - SCR :: SAChar (CR :: AChar) - SCS :: SAChar (CS :: AChar) - SCT :: SAChar (CT :: AChar) - SCU :: SAChar (CU :: AChar) - SCV :: SAChar (CV :: AChar) - SCW :: SAChar (CW :: AChar) - SCX :: SAChar (CX :: AChar) - SCY :: SAChar (CY :: AChar) - SCZ :: SAChar (CZ :: AChar) - type instance Sing @AChar = SAChar - instance SingKind AChar where - type Demote AChar = AChar - fromSing SCA = CA - fromSing SCB = CB - fromSing SCC = CC - fromSing SCD = CD - fromSing SCE = CE - fromSing SCF = CF - fromSing SCG = CG - fromSing SCH = CH - fromSing SCI = CI - fromSing SCJ = CJ - fromSing SCK = CK - fromSing SCL = CL - fromSing SCM = CM - fromSing SCN = CN - fromSing SCO = CO - fromSing SCP = CP - fromSing SCQ = CQ - fromSing SCR = CR - fromSing SCS = CS - fromSing SCT = CT - fromSing SCU = CU - fromSing SCV = CV - fromSing SCW = CW - fromSing SCX = CX - fromSing SCY = CY - fromSing SCZ = CZ - toSing CA = SomeSing SCA - toSing CB = SomeSing SCB - toSing CC = SomeSing SCC - toSing CD = SomeSing SCD - toSing CE = SomeSing SCE - toSing CF = SomeSing SCF - toSing CG = SomeSing SCG - toSing CH = SomeSing SCH - toSing CI = SomeSing SCI - toSing CJ = SomeSing SCJ - toSing CK = SomeSing SCK - toSing CL = SomeSing SCL - toSing CM = SomeSing SCM - toSing CN = SomeSing SCN - toSing CO = SomeSing SCO - toSing CP = SomeSing SCP - toSing CQ = SomeSing SCQ - toSing CR = SomeSing SCR - toSing CS = SomeSing SCS - toSing CT = SomeSing SCT - toSing CU = SomeSing SCU - toSing CV = SomeSing SCV - toSing CW = SomeSing SCW - toSing CX = SomeSing SCX - toSing CY = SomeSing SCY - toSing CZ = SomeSing SCZ - data SAttribute :: Attribute -> Type - where - SAttr :: forall (n :: [AChar]) (n :: U). - (Sing n) -> (Sing n) -> SAttribute (Attr n n :: Attribute) - type instance Sing @Attribute = SAttribute - instance SingKind Attribute where - type Demote Attribute = Attribute - fromSing (SAttr b b) = (Attr (fromSing b)) (fromSing b) - toSing (Attr (b :: Demote [AChar]) (b :: Demote U)) - = case - ((,) (toSing b :: SomeSing [AChar])) (toSing b :: SomeSing U) - of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SAttr c) c) } - data SSchema :: Schema -> Type - where - SSch :: forall (n :: [Attribute]). - (Sing n) -> SSchema (Sch n :: Schema) - type instance Sing @Schema = SSchema - instance SingKind Schema where - type Demote Schema = Schema - fromSing (SSch b) = Sch (fromSing b) - toSing (Sch (b :: Demote [Attribute])) - = case toSing b :: SomeSing [Attribute] of { - SomeSing c -> SomeSing (SSch c) } - instance (SEq U, SEq Nat) => SEq U where - (%==) :: - forall (t1 :: U) (t2 :: U). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun U ((~>) U Bool) - -> Type) t1) t2) - (%==) SBOOL SBOOL = STrue - (%==) SBOOL SSTRING = SFalse - (%==) SBOOL SNAT = SFalse - (%==) SBOOL (SVEC _ _) = SFalse - (%==) SSTRING SBOOL = SFalse - (%==) SSTRING SSTRING = STrue - (%==) SSTRING SNAT = SFalse - (%==) SSTRING (SVEC _ _) = SFalse - (%==) SNAT SBOOL = SFalse - (%==) SNAT SSTRING = SFalse - (%==) SNAT SNAT = STrue - (%==) SNAT (SVEC _ _) = SFalse - (%==) (SVEC _ _) SBOOL = SFalse - (%==) (SVEC _ _) SSTRING = SFalse - (%==) (SVEC _ _) SNAT = SFalse - (%==) - (SVEC (sA_0123456789876543210 :: Sing a_0123456789876543210) - (sA_0123456789876543210 :: Sing a_0123456789876543210)) - (SVEC (sB_0123456789876543210 :: Sing b_0123456789876543210) - (sB_0123456789876543210 :: Sing b_0123456789876543210)) - = (applySing - ((applySing ((singFun2 @(&&@#@$)) (%&&))) - ((applySing - ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210)) - sB_0123456789876543210))) - ((applySing - ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210)) - sB_0123456789876543210) - instance (SShow U, SShow Nat) => SShow U where - sShowsPrec :: - forall (t1 :: GHC.Types.Nat) (t2 :: U) (t3 :: Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) U ((~>) Symbol Symbol)) - -> Type) t1) t2) t3) - sShowsPrec - _ - SBOOL - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "BOOL"))) - sA_0123456789876543210 - sShowsPrec - _ - SSTRING - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "STRING"))) - sA_0123456789876543210 - sShowsPrec - _ - SNAT - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "NAT"))) - sA_0123456789876543210 - sShowsPrec - (sP_0123456789876543210 :: Sing p_0123456789876543210) - (SVEC (sArg_0123456789876543210 :: Sing arg_0123456789876543210) - (sArg_0123456789876543210 :: Sing arg_0123456789876543210)) - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing - ((applySing ((singFun3 @ShowParenSym0) sShowParen)) - ((applySing - ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210)) - (sFromInteger (sing :: Sing 10))))) - ((applySing - ((applySing ((singFun3 @(.@#@$)) (%.))) - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "VEC ")))) - ((applySing - ((applySing ((singFun3 @(.@#@$)) (%.))) - ((applySing - ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec)) - (sFromInteger (sing :: Sing 11)))) - sArg_0123456789876543210))) - ((applySing - ((applySing ((singFun3 @(.@#@$)) (%.))) - ((singFun1 @ShowSpaceSym0) sShowSpace))) - ((applySing - ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec)) - (sFromInteger (sing :: Sing 11)))) - sArg_0123456789876543210)))))) - sA_0123456789876543210 - instance SShow AChar where - sShowsPrec :: - forall (t1 :: GHC.Types.Nat) (t2 :: AChar) (t3 :: Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) AChar ((~>) Symbol Symbol)) - -> Type) t1) t2) t3) - sShowsPrec - _ - SCA - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CA"))) - sA_0123456789876543210 - sShowsPrec - _ - SCB - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CB"))) - sA_0123456789876543210 - sShowsPrec - _ - SCC - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CC"))) - sA_0123456789876543210 - sShowsPrec - _ - SCD - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CD"))) - sA_0123456789876543210 - sShowsPrec - _ - SCE - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CE"))) - sA_0123456789876543210 - sShowsPrec - _ - SCF - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CF"))) - sA_0123456789876543210 - sShowsPrec - _ - SCG - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CG"))) - sA_0123456789876543210 - sShowsPrec - _ - SCH - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CH"))) - sA_0123456789876543210 - sShowsPrec - _ - SCI - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CI"))) - sA_0123456789876543210 - sShowsPrec - _ - SCJ - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CJ"))) - sA_0123456789876543210 - sShowsPrec - _ - SCK - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CK"))) - sA_0123456789876543210 - sShowsPrec - _ - SCL - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CL"))) - sA_0123456789876543210 - sShowsPrec - _ - SCM - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CM"))) - sA_0123456789876543210 - sShowsPrec - _ - SCN - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CN"))) - sA_0123456789876543210 - sShowsPrec - _ - SCO - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CO"))) - sA_0123456789876543210 - sShowsPrec - _ - SCP - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CP"))) - sA_0123456789876543210 - sShowsPrec - _ - SCQ - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CQ"))) - sA_0123456789876543210 - sShowsPrec - _ - SCR - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CR"))) - sA_0123456789876543210 - sShowsPrec - _ - SCS - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CS"))) - sA_0123456789876543210 - sShowsPrec - _ - SCT - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CT"))) - sA_0123456789876543210 - sShowsPrec - _ - SCU - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CU"))) - sA_0123456789876543210 - sShowsPrec - _ - SCV - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CV"))) - sA_0123456789876543210 - sShowsPrec - _ - SCW - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CW"))) - sA_0123456789876543210 - sShowsPrec - _ - SCX - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CX"))) - sA_0123456789876543210 - sShowsPrec - _ - SCY - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CY"))) - sA_0123456789876543210 - sShowsPrec - _ - SCZ - (sA_0123456789876543210 :: Sing a_0123456789876543210) - = (applySing - ((applySing ((singFun2 @ShowStringSym0) sShowString)) - (sing :: Sing "CZ"))) - sA_0123456789876543210 - instance SEq AChar where - (%==) :: - forall (t1 :: AChar) (t2 :: AChar). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun AChar ((~>) AChar Bool) - -> Type) t1) t2) - (%==) SCA SCA = STrue - (%==) SCA SCB = SFalse - (%==) SCA SCC = SFalse - (%==) SCA SCD = SFalse - (%==) SCA SCE = SFalse - (%==) SCA SCF = SFalse - (%==) SCA SCG = SFalse - (%==) SCA SCH = SFalse - (%==) SCA SCI = SFalse - (%==) SCA SCJ = SFalse - (%==) SCA SCK = SFalse - (%==) SCA SCL = SFalse - (%==) SCA SCM = SFalse - (%==) SCA SCN = SFalse - (%==) SCA SCO = SFalse - (%==) SCA SCP = SFalse - (%==) SCA SCQ = SFalse - (%==) SCA SCR = SFalse - (%==) SCA SCS = SFalse - (%==) SCA SCT = SFalse - (%==) SCA SCU = SFalse - (%==) SCA SCV = SFalse - (%==) SCA SCW = SFalse - (%==) SCA SCX = SFalse - (%==) SCA SCY = SFalse - (%==) SCA SCZ = SFalse - (%==) SCB SCA = SFalse - (%==) SCB SCB = STrue - (%==) SCB SCC = SFalse - (%==) SCB SCD = SFalse - (%==) SCB SCE = SFalse - (%==) SCB SCF = SFalse - (%==) SCB SCG = SFalse - (%==) SCB SCH = SFalse - (%==) SCB SCI = SFalse - (%==) SCB SCJ = SFalse - (%==) SCB SCK = SFalse - (%==) SCB SCL = SFalse - (%==) SCB SCM = SFalse - (%==) SCB SCN = SFalse - (%==) SCB SCO = SFalse - (%==) SCB SCP = SFalse - (%==) SCB SCQ = SFalse - (%==) SCB SCR = SFalse - (%==) SCB SCS = SFalse - (%==) SCB SCT = SFalse - (%==) SCB SCU = SFalse - (%==) SCB SCV = SFalse - (%==) SCB SCW = SFalse - (%==) SCB SCX = SFalse - (%==) SCB SCY = SFalse - (%==) SCB SCZ = SFalse - (%==) SCC SCA = SFalse - (%==) SCC SCB = SFalse - (%==) SCC SCC = STrue - (%==) SCC SCD = SFalse - (%==) SCC SCE = SFalse - (%==) SCC SCF = SFalse - (%==) SCC SCG = SFalse - (%==) SCC SCH = SFalse - (%==) SCC SCI = SFalse - (%==) SCC SCJ = SFalse - (%==) SCC SCK = SFalse - (%==) SCC SCL = SFalse - (%==) SCC SCM = SFalse - (%==) SCC SCN = SFalse - (%==) SCC SCO = SFalse - (%==) SCC SCP = SFalse - (%==) SCC SCQ = SFalse - (%==) SCC SCR = SFalse - (%==) SCC SCS = SFalse - (%==) SCC SCT = SFalse - (%==) SCC SCU = SFalse - (%==) SCC SCV = SFalse - (%==) SCC SCW = SFalse - (%==) SCC SCX = SFalse - (%==) SCC SCY = SFalse - (%==) SCC SCZ = SFalse - (%==) SCD SCA = SFalse - (%==) SCD SCB = SFalse - (%==) SCD SCC = SFalse - (%==) SCD SCD = STrue - (%==) SCD SCE = SFalse - (%==) SCD SCF = SFalse - (%==) SCD SCG = SFalse - (%==) SCD SCH = SFalse - (%==) SCD SCI = SFalse - (%==) SCD SCJ = SFalse - (%==) SCD SCK = SFalse - (%==) SCD SCL = SFalse - (%==) SCD SCM = SFalse - (%==) SCD SCN = SFalse - (%==) SCD SCO = SFalse - (%==) SCD SCP = SFalse - (%==) SCD SCQ = SFalse - (%==) SCD SCR = SFalse - (%==) SCD SCS = SFalse - (%==) SCD SCT = SFalse - (%==) SCD SCU = SFalse - (%==) SCD SCV = SFalse - (%==) SCD SCW = SFalse - (%==) SCD SCX = SFalse - (%==) SCD SCY = SFalse - (%==) SCD SCZ = SFalse - (%==) SCE SCA = SFalse - (%==) SCE SCB = SFalse - (%==) SCE SCC = SFalse - (%==) SCE SCD = SFalse - (%==) SCE SCE = STrue - (%==) SCE SCF = SFalse - (%==) SCE SCG = SFalse - (%==) SCE SCH = SFalse - (%==) SCE SCI = SFalse - (%==) SCE SCJ = SFalse - (%==) SCE SCK = SFalse - (%==) SCE SCL = SFalse - (%==) SCE SCM = SFalse - (%==) SCE SCN = SFalse - (%==) SCE SCO = SFalse - (%==) SCE SCP = SFalse - (%==) SCE SCQ = SFalse - (%==) SCE SCR = SFalse - (%==) SCE SCS = SFalse - (%==) SCE SCT = SFalse - (%==) SCE SCU = SFalse - (%==) SCE SCV = SFalse - (%==) SCE SCW = SFalse - (%==) SCE SCX = SFalse - (%==) SCE SCY = SFalse - (%==) SCE SCZ = SFalse - (%==) SCF SCA = SFalse - (%==) SCF SCB = SFalse - (%==) SCF SCC = SFalse - (%==) SCF SCD = SFalse - (%==) SCF SCE = SFalse - (%==) SCF SCF = STrue - (%==) SCF SCG = SFalse - (%==) SCF SCH = SFalse - (%==) SCF SCI = SFalse - (%==) SCF SCJ = SFalse - (%==) SCF SCK = SFalse - (%==) SCF SCL = SFalse - (%==) SCF SCM = SFalse - (%==) SCF SCN = SFalse - (%==) SCF SCO = SFalse - (%==) SCF SCP = SFalse - (%==) SCF SCQ = SFalse - (%==) SCF SCR = SFalse - (%==) SCF SCS = SFalse - (%==) SCF SCT = SFalse - (%==) SCF SCU = SFalse - (%==) SCF SCV = SFalse - (%==) SCF SCW = SFalse - (%==) SCF SCX = SFalse - (%==) SCF SCY = SFalse - (%==) SCF SCZ = SFalse - (%==) SCG SCA = SFalse - (%==) SCG SCB = SFalse - (%==) SCG SCC = SFalse - (%==) SCG SCD = SFalse - (%==) SCG SCE = SFalse - (%==) SCG SCF = SFalse - (%==) SCG SCG = STrue - (%==) SCG SCH = SFalse - (%==) SCG SCI = SFalse - (%==) SCG SCJ = SFalse - (%==) SCG SCK = SFalse - (%==) SCG SCL = SFalse - (%==) SCG SCM = SFalse - (%==) SCG SCN = SFalse - (%==) SCG SCO = SFalse - (%==) SCG SCP = SFalse - (%==) SCG SCQ = SFalse - (%==) SCG SCR = SFalse - (%==) SCG SCS = SFalse - (%==) SCG SCT = SFalse - (%==) SCG SCU = SFalse - (%==) SCG SCV = SFalse - (%==) SCG SCW = SFalse - (%==) SCG SCX = SFalse - (%==) SCG SCY = SFalse - (%==) SCG SCZ = SFalse - (%==) SCH SCA = SFalse - (%==) SCH SCB = SFalse - (%==) SCH SCC = SFalse - (%==) SCH SCD = SFalse - (%==) SCH SCE = SFalse - (%==) SCH SCF = SFalse - (%==) SCH SCG = SFalse - (%==) SCH SCH = STrue - (%==) SCH SCI = SFalse - (%==) SCH SCJ = SFalse - (%==) SCH SCK = SFalse - (%==) SCH SCL = SFalse - (%==) SCH SCM = SFalse - (%==) SCH SCN = SFalse - (%==) SCH SCO = SFalse - (%==) SCH SCP = SFalse - (%==) SCH SCQ = SFalse - (%==) SCH SCR = SFalse - (%==) SCH SCS = SFalse - (%==) SCH SCT = SFalse - (%==) SCH SCU = SFalse - (%==) SCH SCV = SFalse - (%==) SCH SCW = SFalse - (%==) SCH SCX = SFalse - (%==) SCH SCY = SFalse - (%==) SCH SCZ = SFalse - (%==) SCI SCA = SFalse - (%==) SCI SCB = SFalse - (%==) SCI SCC = SFalse - (%==) SCI SCD = SFalse - (%==) SCI SCE = SFalse - (%==) SCI SCF = SFalse - (%==) SCI SCG = SFalse - (%==) SCI SCH = SFalse - (%==) SCI SCI = STrue - (%==) SCI SCJ = SFalse - (%==) SCI SCK = SFalse - (%==) SCI SCL = SFalse - (%==) SCI SCM = SFalse - (%==) SCI SCN = SFalse - (%==) SCI SCO = SFalse - (%==) SCI SCP = SFalse - (%==) SCI SCQ = SFalse - (%==) SCI SCR = SFalse - (%==) SCI SCS = SFalse - (%==) SCI SCT = SFalse - (%==) SCI SCU = SFalse - (%==) SCI SCV = SFalse - (%==) SCI SCW = SFalse - (%==) SCI SCX = SFalse - (%==) SCI SCY = SFalse - (%==) SCI SCZ = SFalse - (%==) SCJ SCA = SFalse - (%==) SCJ SCB = SFalse - (%==) SCJ SCC = SFalse - (%==) SCJ SCD = SFalse - (%==) SCJ SCE = SFalse - (%==) SCJ SCF = SFalse - (%==) SCJ SCG = SFalse - (%==) SCJ SCH = SFalse - (%==) SCJ SCI = SFalse - (%==) SCJ SCJ = STrue - (%==) SCJ SCK = SFalse - (%==) SCJ SCL = SFalse - (%==) SCJ SCM = SFalse - (%==) SCJ SCN = SFalse - (%==) SCJ SCO = SFalse - (%==) SCJ SCP = SFalse - (%==) SCJ SCQ = SFalse - (%==) SCJ SCR = SFalse - (%==) SCJ SCS = SFalse - (%==) SCJ SCT = SFalse - (%==) SCJ SCU = SFalse - (%==) SCJ SCV = SFalse - (%==) SCJ SCW = SFalse - (%==) SCJ SCX = SFalse - (%==) SCJ SCY = SFalse - (%==) SCJ SCZ = SFalse - (%==) SCK SCA = SFalse - (%==) SCK SCB = SFalse - (%==) SCK SCC = SFalse - (%==) SCK SCD = SFalse - (%==) SCK SCE = SFalse - (%==) SCK SCF = SFalse - (%==) SCK SCG = SFalse - (%==) SCK SCH = SFalse - (%==) SCK SCI = SFalse - (%==) SCK SCJ = SFalse - (%==) SCK SCK = STrue - (%==) SCK SCL = SFalse - (%==) SCK SCM = SFalse - (%==) SCK SCN = SFalse - (%==) SCK SCO = SFalse - (%==) SCK SCP = SFalse - (%==) SCK SCQ = SFalse - (%==) SCK SCR = SFalse - (%==) SCK SCS = SFalse - (%==) SCK SCT = SFalse - (%==) SCK SCU = SFalse - (%==) SCK SCV = SFalse - (%==) SCK SCW = SFalse - (%==) SCK SCX = SFalse - (%==) SCK SCY = SFalse - (%==) SCK SCZ = SFalse - (%==) SCL SCA = SFalse - (%==) SCL SCB = SFalse - (%==) SCL SCC = SFalse - (%==) SCL SCD = SFalse - (%==) SCL SCE = SFalse - (%==) SCL SCF = SFalse - (%==) SCL SCG = SFalse - (%==) SCL SCH = SFalse - (%==) SCL SCI = SFalse - (%==) SCL SCJ = SFalse - (%==) SCL SCK = SFalse - (%==) SCL SCL = STrue - (%==) SCL SCM = SFalse - (%==) SCL SCN = SFalse - (%==) SCL SCO = SFalse - (%==) SCL SCP = SFalse - (%==) SCL SCQ = SFalse - (%==) SCL SCR = SFalse - (%==) SCL SCS = SFalse - (%==) SCL SCT = SFalse - (%==) SCL SCU = SFalse - (%==) SCL SCV = SFalse - (%==) SCL SCW = SFalse - (%==) SCL SCX = SFalse - (%==) SCL SCY = SFalse - (%==) SCL SCZ = SFalse - (%==) SCM SCA = SFalse - (%==) SCM SCB = SFalse - (%==) SCM SCC = SFalse - (%==) SCM SCD = SFalse - (%==) SCM SCE = SFalse - (%==) SCM SCF = SFalse - (%==) SCM SCG = SFalse - (%==) SCM SCH = SFalse - (%==) SCM SCI = SFalse - (%==) SCM SCJ = SFalse - (%==) SCM SCK = SFalse - (%==) SCM SCL = SFalse - (%==) SCM SCM = STrue - (%==) SCM SCN = SFalse - (%==) SCM SCO = SFalse - (%==) SCM SCP = SFalse - (%==) SCM SCQ = SFalse - (%==) SCM SCR = SFalse - (%==) SCM SCS = SFalse - (%==) SCM SCT = SFalse - (%==) SCM SCU = SFalse - (%==) SCM SCV = SFalse - (%==) SCM SCW = SFalse - (%==) SCM SCX = SFalse - (%==) SCM SCY = SFalse - (%==) SCM SCZ = SFalse - (%==) SCN SCA = SFalse - (%==) SCN SCB = SFalse - (%==) SCN SCC = SFalse - (%==) SCN SCD = SFalse - (%==) SCN SCE = SFalse - (%==) SCN SCF = SFalse - (%==) SCN SCG = SFalse - (%==) SCN SCH = SFalse - (%==) SCN SCI = SFalse - (%==) SCN SCJ = SFalse - (%==) SCN SCK = SFalse - (%==) SCN SCL = SFalse - (%==) SCN SCM = SFalse - (%==) SCN SCN = STrue - (%==) SCN SCO = SFalse - (%==) SCN SCP = SFalse - (%==) SCN SCQ = SFalse - (%==) SCN SCR = SFalse - (%==) SCN SCS = SFalse - (%==) SCN SCT = SFalse - (%==) SCN SCU = SFalse - (%==) SCN SCV = SFalse - (%==) SCN SCW = SFalse - (%==) SCN SCX = SFalse - (%==) SCN SCY = SFalse - (%==) SCN SCZ = SFalse - (%==) SCO SCA = SFalse - (%==) SCO SCB = SFalse - (%==) SCO SCC = SFalse - (%==) SCO SCD = SFalse - (%==) SCO SCE = SFalse - (%==) SCO SCF = SFalse - (%==) SCO SCG = SFalse - (%==) SCO SCH = SFalse - (%==) SCO SCI = SFalse - (%==) SCO SCJ = SFalse - (%==) SCO SCK = SFalse - (%==) SCO SCL = SFalse - (%==) SCO SCM = SFalse - (%==) SCO SCN = SFalse - (%==) SCO SCO = STrue - (%==) SCO SCP = SFalse - (%==) SCO SCQ = SFalse - (%==) SCO SCR = SFalse - (%==) SCO SCS = SFalse - (%==) SCO SCT = SFalse - (%==) SCO SCU = SFalse - (%==) SCO SCV = SFalse - (%==) SCO SCW = SFalse - (%==) SCO SCX = SFalse - (%==) SCO SCY = SFalse - (%==) SCO SCZ = SFalse - (%==) SCP SCA = SFalse - (%==) SCP SCB = SFalse - (%==) SCP SCC = SFalse - (%==) SCP SCD = SFalse - (%==) SCP SCE = SFalse - (%==) SCP SCF = SFalse - (%==) SCP SCG = SFalse - (%==) SCP SCH = SFalse - (%==) SCP SCI = SFalse - (%==) SCP SCJ = SFalse - (%==) SCP SCK = SFalse - (%==) SCP SCL = SFalse - (%==) SCP SCM = SFalse - (%==) SCP SCN = SFalse - (%==) SCP SCO = SFalse - (%==) SCP SCP = STrue - (%==) SCP SCQ = SFalse - (%==) SCP SCR = SFalse - (%==) SCP SCS = SFalse - (%==) SCP SCT = SFalse - (%==) SCP SCU = SFalse - (%==) SCP SCV = SFalse - (%==) SCP SCW = SFalse - (%==) SCP SCX = SFalse - (%==) SCP SCY = SFalse - (%==) SCP SCZ = SFalse - (%==) SCQ SCA = SFalse - (%==) SCQ SCB = SFalse - (%==) SCQ SCC = SFalse - (%==) SCQ SCD = SFalse - (%==) SCQ SCE = SFalse - (%==) SCQ SCF = SFalse - (%==) SCQ SCG = SFalse - (%==) SCQ SCH = SFalse - (%==) SCQ SCI = SFalse - (%==) SCQ SCJ = SFalse - (%==) SCQ SCK = SFalse - (%==) SCQ SCL = SFalse - (%==) SCQ SCM = SFalse - (%==) SCQ SCN = SFalse - (%==) SCQ SCO = SFalse - (%==) SCQ SCP = SFalse - (%==) SCQ SCQ = STrue - (%==) SCQ SCR = SFalse - (%==) SCQ SCS = SFalse - (%==) SCQ SCT = SFalse - (%==) SCQ SCU = SFalse - (%==) SCQ SCV = SFalse - (%==) SCQ SCW = SFalse - (%==) SCQ SCX = SFalse - (%==) SCQ SCY = SFalse - (%==) SCQ SCZ = SFalse - (%==) SCR SCA = SFalse - (%==) SCR SCB = SFalse - (%==) SCR SCC = SFalse - (%==) SCR SCD = SFalse - (%==) SCR SCE = SFalse - (%==) SCR SCF = SFalse - (%==) SCR SCG = SFalse - (%==) SCR SCH = SFalse - (%==) SCR SCI = SFalse - (%==) SCR SCJ = SFalse - (%==) SCR SCK = SFalse - (%==) SCR SCL = SFalse - (%==) SCR SCM = SFalse - (%==) SCR SCN = SFalse - (%==) SCR SCO = SFalse - (%==) SCR SCP = SFalse - (%==) SCR SCQ = SFalse - (%==) SCR SCR = STrue - (%==) SCR SCS = SFalse - (%==) SCR SCT = SFalse - (%==) SCR SCU = SFalse - (%==) SCR SCV = SFalse - (%==) SCR SCW = SFalse - (%==) SCR SCX = SFalse - (%==) SCR SCY = SFalse - (%==) SCR SCZ = SFalse - (%==) SCS SCA = SFalse - (%==) SCS SCB = SFalse - (%==) SCS SCC = SFalse - (%==) SCS SCD = SFalse - (%==) SCS SCE = SFalse - (%==) SCS SCF = SFalse - (%==) SCS SCG = SFalse - (%==) SCS SCH = SFalse - (%==) SCS SCI = SFalse - (%==) SCS SCJ = SFalse - (%==) SCS SCK = SFalse - (%==) SCS SCL = SFalse - (%==) SCS SCM = SFalse - (%==) SCS SCN = SFalse - (%==) SCS SCO = SFalse - (%==) SCS SCP = SFalse - (%==) SCS SCQ = SFalse - (%==) SCS SCR = SFalse - (%==) SCS SCS = STrue - (%==) SCS SCT = SFalse - (%==) SCS SCU = SFalse - (%==) SCS SCV = SFalse - (%==) SCS SCW = SFalse - (%==) SCS SCX = SFalse - (%==) SCS SCY = SFalse - (%==) SCS SCZ = SFalse - (%==) SCT SCA = SFalse - (%==) SCT SCB = SFalse - (%==) SCT SCC = SFalse - (%==) SCT SCD = SFalse - (%==) SCT SCE = SFalse - (%==) SCT SCF = SFalse - (%==) SCT SCG = SFalse - (%==) SCT SCH = SFalse - (%==) SCT SCI = SFalse - (%==) SCT SCJ = SFalse - (%==) SCT SCK = SFalse - (%==) SCT SCL = SFalse - (%==) SCT SCM = SFalse - (%==) SCT SCN = SFalse - (%==) SCT SCO = SFalse - (%==) SCT SCP = SFalse - (%==) SCT SCQ = SFalse - (%==) SCT SCR = SFalse - (%==) SCT SCS = SFalse - (%==) SCT SCT = STrue - (%==) SCT SCU = SFalse - (%==) SCT SCV = SFalse - (%==) SCT SCW = SFalse - (%==) SCT SCX = SFalse - (%==) SCT SCY = SFalse - (%==) SCT SCZ = SFalse - (%==) SCU SCA = SFalse - (%==) SCU SCB = SFalse - (%==) SCU SCC = SFalse - (%==) SCU SCD = SFalse - (%==) SCU SCE = SFalse - (%==) SCU SCF = SFalse - (%==) SCU SCG = SFalse - (%==) SCU SCH = SFalse - (%==) SCU SCI = SFalse - (%==) SCU SCJ = SFalse - (%==) SCU SCK = SFalse - (%==) SCU SCL = SFalse - (%==) SCU SCM = SFalse - (%==) SCU SCN = SFalse - (%==) SCU SCO = SFalse - (%==) SCU SCP = SFalse - (%==) SCU SCQ = SFalse - (%==) SCU SCR = SFalse - (%==) SCU SCS = SFalse - (%==) SCU SCT = SFalse - (%==) SCU SCU = STrue - (%==) SCU SCV = SFalse - (%==) SCU SCW = SFalse - (%==) SCU SCX = SFalse - (%==) SCU SCY = SFalse - (%==) SCU SCZ = SFalse - (%==) SCV SCA = SFalse - (%==) SCV SCB = SFalse - (%==) SCV SCC = SFalse - (%==) SCV SCD = SFalse - (%==) SCV SCE = SFalse - (%==) SCV SCF = SFalse - (%==) SCV SCG = SFalse - (%==) SCV SCH = SFalse - (%==) SCV SCI = SFalse - (%==) SCV SCJ = SFalse - (%==) SCV SCK = SFalse - (%==) SCV SCL = SFalse - (%==) SCV SCM = SFalse - (%==) SCV SCN = SFalse - (%==) SCV SCO = SFalse - (%==) SCV SCP = SFalse - (%==) SCV SCQ = SFalse - (%==) SCV SCR = SFalse - (%==) SCV SCS = SFalse - (%==) SCV SCT = SFalse - (%==) SCV SCU = SFalse - (%==) SCV SCV = STrue - (%==) SCV SCW = SFalse - (%==) SCV SCX = SFalse - (%==) SCV SCY = SFalse - (%==) SCV SCZ = SFalse - (%==) SCW SCA = SFalse - (%==) SCW SCB = SFalse - (%==) SCW SCC = SFalse - (%==) SCW SCD = SFalse - (%==) SCW SCE = SFalse - (%==) SCW SCF = SFalse - (%==) SCW SCG = SFalse - (%==) SCW SCH = SFalse - (%==) SCW SCI = SFalse - (%==) SCW SCJ = SFalse - (%==) SCW SCK = SFalse - (%==) SCW SCL = SFalse - (%==) SCW SCM = SFalse - (%==) SCW SCN = SFalse - (%==) SCW SCO = SFalse - (%==) SCW SCP = SFalse - (%==) SCW SCQ = SFalse - (%==) SCW SCR = SFalse - (%==) SCW SCS = SFalse - (%==) SCW SCT = SFalse - (%==) SCW SCU = SFalse - (%==) SCW SCV = SFalse - (%==) SCW SCW = STrue - (%==) SCW SCX = SFalse - (%==) SCW SCY = SFalse - (%==) SCW SCZ = SFalse - (%==) SCX SCA = SFalse - (%==) SCX SCB = SFalse - (%==) SCX SCC = SFalse - (%==) SCX SCD = SFalse - (%==) SCX SCE = SFalse - (%==) SCX SCF = SFalse - (%==) SCX SCG = SFalse - (%==) SCX SCH = SFalse - (%==) SCX SCI = SFalse - (%==) SCX SCJ = SFalse - (%==) SCX SCK = SFalse - (%==) SCX SCL = SFalse - (%==) SCX SCM = SFalse - (%==) SCX SCN = SFalse - (%==) SCX SCO = SFalse - (%==) SCX SCP = SFalse - (%==) SCX SCQ = SFalse - (%==) SCX SCR = SFalse - (%==) SCX SCS = SFalse - (%==) SCX SCT = SFalse - (%==) SCX SCU = SFalse - (%==) SCX SCV = SFalse - (%==) SCX SCW = SFalse - (%==) SCX SCX = STrue - (%==) SCX SCY = SFalse - (%==) SCX SCZ = SFalse - (%==) SCY SCA = SFalse - (%==) SCY SCB = SFalse - (%==) SCY SCC = SFalse - (%==) SCY SCD = SFalse - (%==) SCY SCE = SFalse - (%==) SCY SCF = SFalse - (%==) SCY SCG = SFalse - (%==) SCY SCH = SFalse - (%==) SCY SCI = SFalse - (%==) SCY SCJ = SFalse - (%==) SCY SCK = SFalse - (%==) SCY SCL = SFalse - (%==) SCY SCM = SFalse - (%==) SCY SCN = SFalse - (%==) SCY SCO = SFalse - (%==) SCY SCP = SFalse - (%==) SCY SCQ = SFalse - (%==) SCY SCR = SFalse - (%==) SCY SCS = SFalse - (%==) SCY SCT = SFalse - (%==) SCY SCU = SFalse - (%==) SCY SCV = SFalse - (%==) SCY SCW = SFalse - (%==) SCY SCX = SFalse - (%==) SCY SCY = STrue - (%==) SCY SCZ = SFalse - (%==) SCZ SCA = SFalse - (%==) SCZ SCB = SFalse - (%==) SCZ SCC = SFalse - (%==) SCZ SCD = SFalse - (%==) SCZ SCE = SFalse - (%==) SCZ SCF = SFalse - (%==) SCZ SCG = SFalse - (%==) SCZ SCH = SFalse - (%==) SCZ SCI = SFalse - (%==) SCZ SCJ = SFalse - (%==) SCZ SCK = SFalse - (%==) SCZ SCL = SFalse - (%==) SCZ SCM = SFalse - (%==) SCZ SCN = SFalse - (%==) SCZ SCO = SFalse - (%==) SCZ SCP = SFalse - (%==) SCZ SCQ = SFalse - (%==) SCZ SCR = SFalse - (%==) SCZ SCS = SFalse - (%==) SCZ SCT = SFalse - (%==) SCZ SCU = SFalse - (%==) SCZ SCV = SFalse - (%==) SCZ SCW = SFalse - (%==) SCZ SCX = SFalse - (%==) SCZ SCY = SFalse - (%==) SCZ SCZ = STrue - instance (SDecide U, SDecide Nat) => SDecide U where - (%~) SBOOL SBOOL = Proved Refl - (%~) SBOOL SSTRING = Disproved (\ x -> case x of) - (%~) SBOOL SNAT = Disproved (\ x -> case x of) - (%~) SBOOL (SVEC _ _) = Disproved (\ x -> case x of) - (%~) SSTRING SBOOL = Disproved (\ x -> case x of) - (%~) SSTRING SSTRING = Proved Refl - (%~) SSTRING SNAT = Disproved (\ x -> case x of) - (%~) SSTRING (SVEC _ _) = Disproved (\ x -> case x of) - (%~) SNAT SBOOL = Disproved (\ x -> case x of) - (%~) SNAT SSTRING = Disproved (\ x -> case x of) - (%~) SNAT SNAT = Proved Refl - (%~) SNAT (SVEC _ _) = Disproved (\ x -> case x of) - (%~) (SVEC _ _) SBOOL = Disproved (\ x -> case x of) - (%~) (SVEC _ _) SSTRING = Disproved (\ x -> case x of) - (%~) (SVEC _ _) SNAT = Disproved (\ x -> case x of) - (%~) (SVEC a a) (SVEC b b) - = case ((,) (((%~) a) b)) (((%~) a) b) of - (,) (Proved Refl) (Proved Refl) -> Proved Refl - (,) (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - (,) _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - instance (SDecide U, SDecide Nat) => - Data.Type.Equality.TestEquality (SU :: U -> Type) where - Data.Type.Equality.testEquality - = Data.Singletons.Decide.decideEquality - instance (SDecide U, SDecide Nat) => - Data.Type.Coercion.TestCoercion (SU :: U -> Type) where - Data.Type.Coercion.testCoercion - = Data.Singletons.Decide.decideCoercion - instance SDecide AChar where - (%~) SCA SCA = Proved Refl - (%~) SCA SCB = Disproved (\ x -> case x of) - (%~) SCA SCC = Disproved (\ x -> case x of) - (%~) SCA SCD = Disproved (\ x -> case x of) - (%~) SCA SCE = Disproved (\ x -> case x of) - (%~) SCA SCF = Disproved (\ x -> case x of) - (%~) SCA SCG = Disproved (\ x -> case x of) - (%~) SCA SCH = Disproved (\ x -> case x of) - (%~) SCA SCI = Disproved (\ x -> case x of) - (%~) SCA SCJ = Disproved (\ x -> case x of) - (%~) SCA SCK = Disproved (\ x -> case x of) - (%~) SCA SCL = Disproved (\ x -> case x of) - (%~) SCA SCM = Disproved (\ x -> case x of) - (%~) SCA SCN = Disproved (\ x -> case x of) - (%~) SCA SCO = Disproved (\ x -> case x of) - (%~) SCA SCP = Disproved (\ x -> case x of) - (%~) SCA SCQ = Disproved (\ x -> case x of) - (%~) SCA SCR = Disproved (\ x -> case x of) - (%~) SCA SCS = Disproved (\ x -> case x of) - (%~) SCA SCT = Disproved (\ x -> case x of) - (%~) SCA SCU = Disproved (\ x -> case x of) - (%~) SCA SCV = Disproved (\ x -> case x of) - (%~) SCA SCW = Disproved (\ x -> case x of) - (%~) SCA SCX = Disproved (\ x -> case x of) - (%~) SCA SCY = Disproved (\ x -> case x of) - (%~) SCA SCZ = Disproved (\ x -> case x of) - (%~) SCB SCA = Disproved (\ x -> case x of) - (%~) SCB SCB = Proved Refl - (%~) SCB SCC = Disproved (\ x -> case x of) - (%~) SCB SCD = Disproved (\ x -> case x of) - (%~) SCB SCE = Disproved (\ x -> case x of) - (%~) SCB SCF = Disproved (\ x -> case x of) - (%~) SCB SCG = Disproved (\ x -> case x of) - (%~) SCB SCH = Disproved (\ x -> case x of) - (%~) SCB SCI = Disproved (\ x -> case x of) - (%~) SCB SCJ = Disproved (\ x -> case x of) - (%~) SCB SCK = Disproved (\ x -> case x of) - (%~) SCB SCL = Disproved (\ x -> case x of) - (%~) SCB SCM = Disproved (\ x -> case x of) - (%~) SCB SCN = Disproved (\ x -> case x of) - (%~) SCB SCO = Disproved (\ x -> case x of) - (%~) SCB SCP = Disproved (\ x -> case x of) - (%~) SCB SCQ = Disproved (\ x -> case x of) - (%~) SCB SCR = Disproved (\ x -> case x of) - (%~) SCB SCS = Disproved (\ x -> case x of) - (%~) SCB SCT = Disproved (\ x -> case x of) - (%~) SCB SCU = Disproved (\ x -> case x of) - (%~) SCB SCV = Disproved (\ x -> case x of) - (%~) SCB SCW = Disproved (\ x -> case x of) - (%~) SCB SCX = Disproved (\ x -> case x of) - (%~) SCB SCY = Disproved (\ x -> case x of) - (%~) SCB SCZ = Disproved (\ x -> case x of) - (%~) SCC SCA = Disproved (\ x -> case x of) - (%~) SCC SCB = Disproved (\ x -> case x of) - (%~) SCC SCC = Proved Refl - (%~) SCC SCD = Disproved (\ x -> case x of) - (%~) SCC SCE = Disproved (\ x -> case x of) - (%~) SCC SCF = Disproved (\ x -> case x of) - (%~) SCC SCG = Disproved (\ x -> case x of) - (%~) SCC SCH = Disproved (\ x -> case x of) - (%~) SCC SCI = Disproved (\ x -> case x of) - (%~) SCC SCJ = Disproved (\ x -> case x of) - (%~) SCC SCK = Disproved (\ x -> case x of) - (%~) SCC SCL = Disproved (\ x -> case x of) - (%~) SCC SCM = Disproved (\ x -> case x of) - (%~) SCC SCN = Disproved (\ x -> case x of) - (%~) SCC SCO = Disproved (\ x -> case x of) - (%~) SCC SCP = Disproved (\ x -> case x of) - (%~) SCC SCQ = Disproved (\ x -> case x of) - (%~) SCC SCR = Disproved (\ x -> case x of) - (%~) SCC SCS = Disproved (\ x -> case x of) - (%~) SCC SCT = Disproved (\ x -> case x of) - (%~) SCC SCU = Disproved (\ x -> case x of) - (%~) SCC SCV = Disproved (\ x -> case x of) - (%~) SCC SCW = Disproved (\ x -> case x of) - (%~) SCC SCX = Disproved (\ x -> case x of) - (%~) SCC SCY = Disproved (\ x -> case x of) - (%~) SCC SCZ = Disproved (\ x -> case x of) - (%~) SCD SCA = Disproved (\ x -> case x of) - (%~) SCD SCB = Disproved (\ x -> case x of) - (%~) SCD SCC = Disproved (\ x -> case x of) - (%~) SCD SCD = Proved Refl - (%~) SCD SCE = Disproved (\ x -> case x of) - (%~) SCD SCF = Disproved (\ x -> case x of) - (%~) SCD SCG = Disproved (\ x -> case x of) - (%~) SCD SCH = Disproved (\ x -> case x of) - (%~) SCD SCI = Disproved (\ x -> case x of) - (%~) SCD SCJ = Disproved (\ x -> case x of) - (%~) SCD SCK = Disproved (\ x -> case x of) - (%~) SCD SCL = Disproved (\ x -> case x of) - (%~) SCD SCM = Disproved (\ x -> case x of) - (%~) SCD SCN = Disproved (\ x -> case x of) - (%~) SCD SCO = Disproved (\ x -> case x of) - (%~) SCD SCP = Disproved (\ x -> case x of) - (%~) SCD SCQ = Disproved (\ x -> case x of) - (%~) SCD SCR = Disproved (\ x -> case x of) - (%~) SCD SCS = Disproved (\ x -> case x of) - (%~) SCD SCT = Disproved (\ x -> case x of) - (%~) SCD SCU = Disproved (\ x -> case x of) - (%~) SCD SCV = Disproved (\ x -> case x of) - (%~) SCD SCW = Disproved (\ x -> case x of) - (%~) SCD SCX = Disproved (\ x -> case x of) - (%~) SCD SCY = Disproved (\ x -> case x of) - (%~) SCD SCZ = Disproved (\ x -> case x of) - (%~) SCE SCA = Disproved (\ x -> case x of) - (%~) SCE SCB = Disproved (\ x -> case x of) - (%~) SCE SCC = Disproved (\ x -> case x of) - (%~) SCE SCD = Disproved (\ x -> case x of) - (%~) SCE SCE = Proved Refl - (%~) SCE SCF = Disproved (\ x -> case x of) - (%~) SCE SCG = Disproved (\ x -> case x of) - (%~) SCE SCH = Disproved (\ x -> case x of) - (%~) SCE SCI = Disproved (\ x -> case x of) - (%~) SCE SCJ = Disproved (\ x -> case x of) - (%~) SCE SCK = Disproved (\ x -> case x of) - (%~) SCE SCL = Disproved (\ x -> case x of) - (%~) SCE SCM = Disproved (\ x -> case x of) - (%~) SCE SCN = Disproved (\ x -> case x of) - (%~) SCE SCO = Disproved (\ x -> case x of) - (%~) SCE SCP = Disproved (\ x -> case x of) - (%~) SCE SCQ = Disproved (\ x -> case x of) - (%~) SCE SCR = Disproved (\ x -> case x of) - (%~) SCE SCS = Disproved (\ x -> case x of) - (%~) SCE SCT = Disproved (\ x -> case x of) - (%~) SCE SCU = Disproved (\ x -> case x of) - (%~) SCE SCV = Disproved (\ x -> case x of) - (%~) SCE SCW = Disproved (\ x -> case x of) - (%~) SCE SCX = Disproved (\ x -> case x of) - (%~) SCE SCY = Disproved (\ x -> case x of) - (%~) SCE SCZ = Disproved (\ x -> case x of) - (%~) SCF SCA = Disproved (\ x -> case x of) - (%~) SCF SCB = Disproved (\ x -> case x of) - (%~) SCF SCC = Disproved (\ x -> case x of) - (%~) SCF SCD = Disproved (\ x -> case x of) - (%~) SCF SCE = Disproved (\ x -> case x of) - (%~) SCF SCF = Proved Refl - (%~) SCF SCG = Disproved (\ x -> case x of) - (%~) SCF SCH = Disproved (\ x -> case x of) - (%~) SCF SCI = Disproved (\ x -> case x of) - (%~) SCF SCJ = Disproved (\ x -> case x of) - (%~) SCF SCK = Disproved (\ x -> case x of) - (%~) SCF SCL = Disproved (\ x -> case x of) - (%~) SCF SCM = Disproved (\ x -> case x of) - (%~) SCF SCN = Disproved (\ x -> case x of) - (%~) SCF SCO = Disproved (\ x -> case x of) - (%~) SCF SCP = Disproved (\ x -> case x of) - (%~) SCF SCQ = Disproved (\ x -> case x of) - (%~) SCF SCR = Disproved (\ x -> case x of) - (%~) SCF SCS = Disproved (\ x -> case x of) - (%~) SCF SCT = Disproved (\ x -> case x of) - (%~) SCF SCU = Disproved (\ x -> case x of) - (%~) SCF SCV = Disproved (\ x -> case x of) - (%~) SCF SCW = Disproved (\ x -> case x of) - (%~) SCF SCX = Disproved (\ x -> case x of) - (%~) SCF SCY = Disproved (\ x -> case x of) - (%~) SCF SCZ = Disproved (\ x -> case x of) - (%~) SCG SCA = Disproved (\ x -> case x of) - (%~) SCG SCB = Disproved (\ x -> case x of) - (%~) SCG SCC = Disproved (\ x -> case x of) - (%~) SCG SCD = Disproved (\ x -> case x of) - (%~) SCG SCE = Disproved (\ x -> case x of) - (%~) SCG SCF = Disproved (\ x -> case x of) - (%~) SCG SCG = Proved Refl - (%~) SCG SCH = Disproved (\ x -> case x of) - (%~) SCG SCI = Disproved (\ x -> case x of) - (%~) SCG SCJ = Disproved (\ x -> case x of) - (%~) SCG SCK = Disproved (\ x -> case x of) - (%~) SCG SCL = Disproved (\ x -> case x of) - (%~) SCG SCM = Disproved (\ x -> case x of) - (%~) SCG SCN = Disproved (\ x -> case x of) - (%~) SCG SCO = Disproved (\ x -> case x of) - (%~) SCG SCP = Disproved (\ x -> case x of) - (%~) SCG SCQ = Disproved (\ x -> case x of) - (%~) SCG SCR = Disproved (\ x -> case x of) - (%~) SCG SCS = Disproved (\ x -> case x of) - (%~) SCG SCT = Disproved (\ x -> case x of) - (%~) SCG SCU = Disproved (\ x -> case x of) - (%~) SCG SCV = Disproved (\ x -> case x of) - (%~) SCG SCW = Disproved (\ x -> case x of) - (%~) SCG SCX = Disproved (\ x -> case x of) - (%~) SCG SCY = Disproved (\ x -> case x of) - (%~) SCG SCZ = Disproved (\ x -> case x of) - (%~) SCH SCA = Disproved (\ x -> case x of) - (%~) SCH SCB = Disproved (\ x -> case x of) - (%~) SCH SCC = Disproved (\ x -> case x of) - (%~) SCH SCD = Disproved (\ x -> case x of) - (%~) SCH SCE = Disproved (\ x -> case x of) - (%~) SCH SCF = Disproved (\ x -> case x of) - (%~) SCH SCG = Disproved (\ x -> case x of) - (%~) SCH SCH = Proved Refl - (%~) SCH SCI = Disproved (\ x -> case x of) - (%~) SCH SCJ = Disproved (\ x -> case x of) - (%~) SCH SCK = Disproved (\ x -> case x of) - (%~) SCH SCL = Disproved (\ x -> case x of) - (%~) SCH SCM = Disproved (\ x -> case x of) - (%~) SCH SCN = Disproved (\ x -> case x of) - (%~) SCH SCO = Disproved (\ x -> case x of) - (%~) SCH SCP = Disproved (\ x -> case x of) - (%~) SCH SCQ = Disproved (\ x -> case x of) - (%~) SCH SCR = Disproved (\ x -> case x of) - (%~) SCH SCS = Disproved (\ x -> case x of) - (%~) SCH SCT = Disproved (\ x -> case x of) - (%~) SCH SCU = Disproved (\ x -> case x of) - (%~) SCH SCV = Disproved (\ x -> case x of) - (%~) SCH SCW = Disproved (\ x -> case x of) - (%~) SCH SCX = Disproved (\ x -> case x of) - (%~) SCH SCY = Disproved (\ x -> case x of) - (%~) SCH SCZ = Disproved (\ x -> case x of) - (%~) SCI SCA = Disproved (\ x -> case x of) - (%~) SCI SCB = Disproved (\ x -> case x of) - (%~) SCI SCC = Disproved (\ x -> case x of) - (%~) SCI SCD = Disproved (\ x -> case x of) - (%~) SCI SCE = Disproved (\ x -> case x of) - (%~) SCI SCF = Disproved (\ x -> case x of) - (%~) SCI SCG = Disproved (\ x -> case x of) - (%~) SCI SCH = Disproved (\ x -> case x of) - (%~) SCI SCI = Proved Refl - (%~) SCI SCJ = Disproved (\ x -> case x of) - (%~) SCI SCK = Disproved (\ x -> case x of) - (%~) SCI SCL = Disproved (\ x -> case x of) - (%~) SCI SCM = Disproved (\ x -> case x of) - (%~) SCI SCN = Disproved (\ x -> case x of) - (%~) SCI SCO = Disproved (\ x -> case x of) - (%~) SCI SCP = Disproved (\ x -> case x of) - (%~) SCI SCQ = Disproved (\ x -> case x of) - (%~) SCI SCR = Disproved (\ x -> case x of) - (%~) SCI SCS = Disproved (\ x -> case x of) - (%~) SCI SCT = Disproved (\ x -> case x of) - (%~) SCI SCU = Disproved (\ x -> case x of) - (%~) SCI SCV = Disproved (\ x -> case x of) - (%~) SCI SCW = Disproved (\ x -> case x of) - (%~) SCI SCX = Disproved (\ x -> case x of) - (%~) SCI SCY = Disproved (\ x -> case x of) - (%~) SCI SCZ = Disproved (\ x -> case x of) - (%~) SCJ SCA = Disproved (\ x -> case x of) - (%~) SCJ SCB = Disproved (\ x -> case x of) - (%~) SCJ SCC = Disproved (\ x -> case x of) - (%~) SCJ SCD = Disproved (\ x -> case x of) - (%~) SCJ SCE = Disproved (\ x -> case x of) - (%~) SCJ SCF = Disproved (\ x -> case x of) - (%~) SCJ SCG = Disproved (\ x -> case x of) - (%~) SCJ SCH = Disproved (\ x -> case x of) - (%~) SCJ SCI = Disproved (\ x -> case x of) - (%~) SCJ SCJ = Proved Refl - (%~) SCJ SCK = Disproved (\ x -> case x of) - (%~) SCJ SCL = Disproved (\ x -> case x of) - (%~) SCJ SCM = Disproved (\ x -> case x of) - (%~) SCJ SCN = Disproved (\ x -> case x of) - (%~) SCJ SCO = Disproved (\ x -> case x of) - (%~) SCJ SCP = Disproved (\ x -> case x of) - (%~) SCJ SCQ = Disproved (\ x -> case x of) - (%~) SCJ SCR = Disproved (\ x -> case x of) - (%~) SCJ SCS = Disproved (\ x -> case x of) - (%~) SCJ SCT = Disproved (\ x -> case x of) - (%~) SCJ SCU = Disproved (\ x -> case x of) - (%~) SCJ SCV = Disproved (\ x -> case x of) - (%~) SCJ SCW = Disproved (\ x -> case x of) - (%~) SCJ SCX = Disproved (\ x -> case x of) - (%~) SCJ SCY = Disproved (\ x -> case x of) - (%~) SCJ SCZ = Disproved (\ x -> case x of) - (%~) SCK SCA = Disproved (\ x -> case x of) - (%~) SCK SCB = Disproved (\ x -> case x of) - (%~) SCK SCC = Disproved (\ x -> case x of) - (%~) SCK SCD = Disproved (\ x -> case x of) - (%~) SCK SCE = Disproved (\ x -> case x of) - (%~) SCK SCF = Disproved (\ x -> case x of) - (%~) SCK SCG = Disproved (\ x -> case x of) - (%~) SCK SCH = Disproved (\ x -> case x of) - (%~) SCK SCI = Disproved (\ x -> case x of) - (%~) SCK SCJ = Disproved (\ x -> case x of) - (%~) SCK SCK = Proved Refl - (%~) SCK SCL = Disproved (\ x -> case x of) - (%~) SCK SCM = Disproved (\ x -> case x of) - (%~) SCK SCN = Disproved (\ x -> case x of) - (%~) SCK SCO = Disproved (\ x -> case x of) - (%~) SCK SCP = Disproved (\ x -> case x of) - (%~) SCK SCQ = Disproved (\ x -> case x of) - (%~) SCK SCR = Disproved (\ x -> case x of) - (%~) SCK SCS = Disproved (\ x -> case x of) - (%~) SCK SCT = Disproved (\ x -> case x of) - (%~) SCK SCU = Disproved (\ x -> case x of) - (%~) SCK SCV = Disproved (\ x -> case x of) - (%~) SCK SCW = Disproved (\ x -> case x of) - (%~) SCK SCX = Disproved (\ x -> case x of) - (%~) SCK SCY = Disproved (\ x -> case x of) - (%~) SCK SCZ = Disproved (\ x -> case x of) - (%~) SCL SCA = Disproved (\ x -> case x of) - (%~) SCL SCB = Disproved (\ x -> case x of) - (%~) SCL SCC = Disproved (\ x -> case x of) - (%~) SCL SCD = Disproved (\ x -> case x of) - (%~) SCL SCE = Disproved (\ x -> case x of) - (%~) SCL SCF = Disproved (\ x -> case x of) - (%~) SCL SCG = Disproved (\ x -> case x of) - (%~) SCL SCH = Disproved (\ x -> case x of) - (%~) SCL SCI = Disproved (\ x -> case x of) - (%~) SCL SCJ = Disproved (\ x -> case x of) - (%~) SCL SCK = Disproved (\ x -> case x of) - (%~) SCL SCL = Proved Refl - (%~) SCL SCM = Disproved (\ x -> case x of) - (%~) SCL SCN = Disproved (\ x -> case x of) - (%~) SCL SCO = Disproved (\ x -> case x of) - (%~) SCL SCP = Disproved (\ x -> case x of) - (%~) SCL SCQ = Disproved (\ x -> case x of) - (%~) SCL SCR = Disproved (\ x -> case x of) - (%~) SCL SCS = Disproved (\ x -> case x of) - (%~) SCL SCT = Disproved (\ x -> case x of) - (%~) SCL SCU = Disproved (\ x -> case x of) - (%~) SCL SCV = Disproved (\ x -> case x of) - (%~) SCL SCW = Disproved (\ x -> case x of) - (%~) SCL SCX = Disproved (\ x -> case x of) - (%~) SCL SCY = Disproved (\ x -> case x of) - (%~) SCL SCZ = Disproved (\ x -> case x of) - (%~) SCM SCA = Disproved (\ x -> case x of) - (%~) SCM SCB = Disproved (\ x -> case x of) - (%~) SCM SCC = Disproved (\ x -> case x of) - (%~) SCM SCD = Disproved (\ x -> case x of) - (%~) SCM SCE = Disproved (\ x -> case x of) - (%~) SCM SCF = Disproved (\ x -> case x of) - (%~) SCM SCG = Disproved (\ x -> case x of) - (%~) SCM SCH = Disproved (\ x -> case x of) - (%~) SCM SCI = Disproved (\ x -> case x of) - (%~) SCM SCJ = Disproved (\ x -> case x of) - (%~) SCM SCK = Disproved (\ x -> case x of) - (%~) SCM SCL = Disproved (\ x -> case x of) - (%~) SCM SCM = Proved Refl - (%~) SCM SCN = Disproved (\ x -> case x of) - (%~) SCM SCO = Disproved (\ x -> case x of) - (%~) SCM SCP = Disproved (\ x -> case x of) - (%~) SCM SCQ = Disproved (\ x -> case x of) - (%~) SCM SCR = Disproved (\ x -> case x of) - (%~) SCM SCS = Disproved (\ x -> case x of) - (%~) SCM SCT = Disproved (\ x -> case x of) - (%~) SCM SCU = Disproved (\ x -> case x of) - (%~) SCM SCV = Disproved (\ x -> case x of) - (%~) SCM SCW = Disproved (\ x -> case x of) - (%~) SCM SCX = Disproved (\ x -> case x of) - (%~) SCM SCY = Disproved (\ x -> case x of) - (%~) SCM SCZ = Disproved (\ x -> case x of) - (%~) SCN SCA = Disproved (\ x -> case x of) - (%~) SCN SCB = Disproved (\ x -> case x of) - (%~) SCN SCC = Disproved (\ x -> case x of) - (%~) SCN SCD = Disproved (\ x -> case x of) - (%~) SCN SCE = Disproved (\ x -> case x of) - (%~) SCN SCF = Disproved (\ x -> case x of) - (%~) SCN SCG = Disproved (\ x -> case x of) - (%~) SCN SCH = Disproved (\ x -> case x of) - (%~) SCN SCI = Disproved (\ x -> case x of) - (%~) SCN SCJ = Disproved (\ x -> case x of) - (%~) SCN SCK = Disproved (\ x -> case x of) - (%~) SCN SCL = Disproved (\ x -> case x of) - (%~) SCN SCM = Disproved (\ x -> case x of) - (%~) SCN SCN = Proved Refl - (%~) SCN SCO = Disproved (\ x -> case x of) - (%~) SCN SCP = Disproved (\ x -> case x of) - (%~) SCN SCQ = Disproved (\ x -> case x of) - (%~) SCN SCR = Disproved (\ x -> case x of) - (%~) SCN SCS = Disproved (\ x -> case x of) - (%~) SCN SCT = Disproved (\ x -> case x of) - (%~) SCN SCU = Disproved (\ x -> case x of) - (%~) SCN SCV = Disproved (\ x -> case x of) - (%~) SCN SCW = Disproved (\ x -> case x of) - (%~) SCN SCX = Disproved (\ x -> case x of) - (%~) SCN SCY = Disproved (\ x -> case x of) - (%~) SCN SCZ = Disproved (\ x -> case x of) - (%~) SCO SCA = Disproved (\ x -> case x of) - (%~) SCO SCB = Disproved (\ x -> case x of) - (%~) SCO SCC = Disproved (\ x -> case x of) - (%~) SCO SCD = Disproved (\ x -> case x of) - (%~) SCO SCE = Disproved (\ x -> case x of) - (%~) SCO SCF = Disproved (\ x -> case x of) - (%~) SCO SCG = Disproved (\ x -> case x of) - (%~) SCO SCH = Disproved (\ x -> case x of) - (%~) SCO SCI = Disproved (\ x -> case x of) - (%~) SCO SCJ = Disproved (\ x -> case x of) - (%~) SCO SCK = Disproved (\ x -> case x of) - (%~) SCO SCL = Disproved (\ x -> case x of) - (%~) SCO SCM = Disproved (\ x -> case x of) - (%~) SCO SCN = Disproved (\ x -> case x of) - (%~) SCO SCO = Proved Refl - (%~) SCO SCP = Disproved (\ x -> case x of) - (%~) SCO SCQ = Disproved (\ x -> case x of) - (%~) SCO SCR = Disproved (\ x -> case x of) - (%~) SCO SCS = Disproved (\ x -> case x of) - (%~) SCO SCT = Disproved (\ x -> case x of) - (%~) SCO SCU = Disproved (\ x -> case x of) - (%~) SCO SCV = Disproved (\ x -> case x of) - (%~) SCO SCW = Disproved (\ x -> case x of) - (%~) SCO SCX = Disproved (\ x -> case x of) - (%~) SCO SCY = Disproved (\ x -> case x of) - (%~) SCO SCZ = Disproved (\ x -> case x of) - (%~) SCP SCA = Disproved (\ x -> case x of) - (%~) SCP SCB = Disproved (\ x -> case x of) - (%~) SCP SCC = Disproved (\ x -> case x of) - (%~) SCP SCD = Disproved (\ x -> case x of) - (%~) SCP SCE = Disproved (\ x -> case x of) - (%~) SCP SCF = Disproved (\ x -> case x of) - (%~) SCP SCG = Disproved (\ x -> case x of) - (%~) SCP SCH = Disproved (\ x -> case x of) - (%~) SCP SCI = Disproved (\ x -> case x of) - (%~) SCP SCJ = Disproved (\ x -> case x of) - (%~) SCP SCK = Disproved (\ x -> case x of) - (%~) SCP SCL = Disproved (\ x -> case x of) - (%~) SCP SCM = Disproved (\ x -> case x of) - (%~) SCP SCN = Disproved (\ x -> case x of) - (%~) SCP SCO = Disproved (\ x -> case x of) - (%~) SCP SCP = Proved Refl - (%~) SCP SCQ = Disproved (\ x -> case x of) - (%~) SCP SCR = Disproved (\ x -> case x of) - (%~) SCP SCS = Disproved (\ x -> case x of) - (%~) SCP SCT = Disproved (\ x -> case x of) - (%~) SCP SCU = Disproved (\ x -> case x of) - (%~) SCP SCV = Disproved (\ x -> case x of) - (%~) SCP SCW = Disproved (\ x -> case x of) - (%~) SCP SCX = Disproved (\ x -> case x of) - (%~) SCP SCY = Disproved (\ x -> case x of) - (%~) SCP SCZ = Disproved (\ x -> case x of) - (%~) SCQ SCA = Disproved (\ x -> case x of) - (%~) SCQ SCB = Disproved (\ x -> case x of) - (%~) SCQ SCC = Disproved (\ x -> case x of) - (%~) SCQ SCD = Disproved (\ x -> case x of) - (%~) SCQ SCE = Disproved (\ x -> case x of) - (%~) SCQ SCF = Disproved (\ x -> case x of) - (%~) SCQ SCG = Disproved (\ x -> case x of) - (%~) SCQ SCH = Disproved (\ x -> case x of) - (%~) SCQ SCI = Disproved (\ x -> case x of) - (%~) SCQ SCJ = Disproved (\ x -> case x of) - (%~) SCQ SCK = Disproved (\ x -> case x of) - (%~) SCQ SCL = Disproved (\ x -> case x of) - (%~) SCQ SCM = Disproved (\ x -> case x of) - (%~) SCQ SCN = Disproved (\ x -> case x of) - (%~) SCQ SCO = Disproved (\ x -> case x of) - (%~) SCQ SCP = Disproved (\ x -> case x of) - (%~) SCQ SCQ = Proved Refl - (%~) SCQ SCR = Disproved (\ x -> case x of) - (%~) SCQ SCS = Disproved (\ x -> case x of) - (%~) SCQ SCT = Disproved (\ x -> case x of) - (%~) SCQ SCU = Disproved (\ x -> case x of) - (%~) SCQ SCV = Disproved (\ x -> case x of) - (%~) SCQ SCW = Disproved (\ x -> case x of) - (%~) SCQ SCX = Disproved (\ x -> case x of) - (%~) SCQ SCY = Disproved (\ x -> case x of) - (%~) SCQ SCZ = Disproved (\ x -> case x of) - (%~) SCR SCA = Disproved (\ x -> case x of) - (%~) SCR SCB = Disproved (\ x -> case x of) - (%~) SCR SCC = Disproved (\ x -> case x of) - (%~) SCR SCD = Disproved (\ x -> case x of) - (%~) SCR SCE = Disproved (\ x -> case x of) - (%~) SCR SCF = Disproved (\ x -> case x of) - (%~) SCR SCG = Disproved (\ x -> case x of) - (%~) SCR SCH = Disproved (\ x -> case x of) - (%~) SCR SCI = Disproved (\ x -> case x of) - (%~) SCR SCJ = Disproved (\ x -> case x of) - (%~) SCR SCK = Disproved (\ x -> case x of) - (%~) SCR SCL = Disproved (\ x -> case x of) - (%~) SCR SCM = Disproved (\ x -> case x of) - (%~) SCR SCN = Disproved (\ x -> case x of) - (%~) SCR SCO = Disproved (\ x -> case x of) - (%~) SCR SCP = Disproved (\ x -> case x of) - (%~) SCR SCQ = Disproved (\ x -> case x of) - (%~) SCR SCR = Proved Refl - (%~) SCR SCS = Disproved (\ x -> case x of) - (%~) SCR SCT = Disproved (\ x -> case x of) - (%~) SCR SCU = Disproved (\ x -> case x of) - (%~) SCR SCV = Disproved (\ x -> case x of) - (%~) SCR SCW = Disproved (\ x -> case x of) - (%~) SCR SCX = Disproved (\ x -> case x of) - (%~) SCR SCY = Disproved (\ x -> case x of) - (%~) SCR SCZ = Disproved (\ x -> case x of) - (%~) SCS SCA = Disproved (\ x -> case x of) - (%~) SCS SCB = Disproved (\ x -> case x of) - (%~) SCS SCC = Disproved (\ x -> case x of) - (%~) SCS SCD = Disproved (\ x -> case x of) - (%~) SCS SCE = Disproved (\ x -> case x of) - (%~) SCS SCF = Disproved (\ x -> case x of) - (%~) SCS SCG = Disproved (\ x -> case x of) - (%~) SCS SCH = Disproved (\ x -> case x of) - (%~) SCS SCI = Disproved (\ x -> case x of) - (%~) SCS SCJ = Disproved (\ x -> case x of) - (%~) SCS SCK = Disproved (\ x -> case x of) - (%~) SCS SCL = Disproved (\ x -> case x of) - (%~) SCS SCM = Disproved (\ x -> case x of) - (%~) SCS SCN = Disproved (\ x -> case x of) - (%~) SCS SCO = Disproved (\ x -> case x of) - (%~) SCS SCP = Disproved (\ x -> case x of) - (%~) SCS SCQ = Disproved (\ x -> case x of) - (%~) SCS SCR = Disproved (\ x -> case x of) - (%~) SCS SCS = Proved Refl - (%~) SCS SCT = Disproved (\ x -> case x of) - (%~) SCS SCU = Disproved (\ x -> case x of) - (%~) SCS SCV = Disproved (\ x -> case x of) - (%~) SCS SCW = Disproved (\ x -> case x of) - (%~) SCS SCX = Disproved (\ x -> case x of) - (%~) SCS SCY = Disproved (\ x -> case x of) - (%~) SCS SCZ = Disproved (\ x -> case x of) - (%~) SCT SCA = Disproved (\ x -> case x of) - (%~) SCT SCB = Disproved (\ x -> case x of) - (%~) SCT SCC = Disproved (\ x -> case x of) - (%~) SCT SCD = Disproved (\ x -> case x of) - (%~) SCT SCE = Disproved (\ x -> case x of) - (%~) SCT SCF = Disproved (\ x -> case x of) - (%~) SCT SCG = Disproved (\ x -> case x of) - (%~) SCT SCH = Disproved (\ x -> case x of) - (%~) SCT SCI = Disproved (\ x -> case x of) - (%~) SCT SCJ = Disproved (\ x -> case x of) - (%~) SCT SCK = Disproved (\ x -> case x of) - (%~) SCT SCL = Disproved (\ x -> case x of) - (%~) SCT SCM = Disproved (\ x -> case x of) - (%~) SCT SCN = Disproved (\ x -> case x of) - (%~) SCT SCO = Disproved (\ x -> case x of) - (%~) SCT SCP = Disproved (\ x -> case x of) - (%~) SCT SCQ = Disproved (\ x -> case x of) - (%~) SCT SCR = Disproved (\ x -> case x of) - (%~) SCT SCS = Disproved (\ x -> case x of) - (%~) SCT SCT = Proved Refl - (%~) SCT SCU = Disproved (\ x -> case x of) - (%~) SCT SCV = Disproved (\ x -> case x of) - (%~) SCT SCW = Disproved (\ x -> case x of) - (%~) SCT SCX = Disproved (\ x -> case x of) - (%~) SCT SCY = Disproved (\ x -> case x of) - (%~) SCT SCZ = Disproved (\ x -> case x of) - (%~) SCU SCA = Disproved (\ x -> case x of) - (%~) SCU SCB = Disproved (\ x -> case x of) - (%~) SCU SCC = Disproved (\ x -> case x of) - (%~) SCU SCD = Disproved (\ x -> case x of) - (%~) SCU SCE = Disproved (\ x -> case x of) - (%~) SCU SCF = Disproved (\ x -> case x of) - (%~) SCU SCG = Disproved (\ x -> case x of) - (%~) SCU SCH = Disproved (\ x -> case x of) - (%~) SCU SCI = Disproved (\ x -> case x of) - (%~) SCU SCJ = Disproved (\ x -> case x of) - (%~) SCU SCK = Disproved (\ x -> case x of) - (%~) SCU SCL = Disproved (\ x -> case x of) - (%~) SCU SCM = Disproved (\ x -> case x of) - (%~) SCU SCN = Disproved (\ x -> case x of) - (%~) SCU SCO = Disproved (\ x -> case x of) - (%~) SCU SCP = Disproved (\ x -> case x of) - (%~) SCU SCQ = Disproved (\ x -> case x of) - (%~) SCU SCR = Disproved (\ x -> case x of) - (%~) SCU SCS = Disproved (\ x -> case x of) - (%~) SCU SCT = Disproved (\ x -> case x of) - (%~) SCU SCU = Proved Refl - (%~) SCU SCV = Disproved (\ x -> case x of) - (%~) SCU SCW = Disproved (\ x -> case x of) - (%~) SCU SCX = Disproved (\ x -> case x of) - (%~) SCU SCY = Disproved (\ x -> case x of) - (%~) SCU SCZ = Disproved (\ x -> case x of) - (%~) SCV SCA = Disproved (\ x -> case x of) - (%~) SCV SCB = Disproved (\ x -> case x of) - (%~) SCV SCC = Disproved (\ x -> case x of) - (%~) SCV SCD = Disproved (\ x -> case x of) - (%~) SCV SCE = Disproved (\ x -> case x of) - (%~) SCV SCF = Disproved (\ x -> case x of) - (%~) SCV SCG = Disproved (\ x -> case x of) - (%~) SCV SCH = Disproved (\ x -> case x of) - (%~) SCV SCI = Disproved (\ x -> case x of) - (%~) SCV SCJ = Disproved (\ x -> case x of) - (%~) SCV SCK = Disproved (\ x -> case x of) - (%~) SCV SCL = Disproved (\ x -> case x of) - (%~) SCV SCM = Disproved (\ x -> case x of) - (%~) SCV SCN = Disproved (\ x -> case x of) - (%~) SCV SCO = Disproved (\ x -> case x of) - (%~) SCV SCP = Disproved (\ x -> case x of) - (%~) SCV SCQ = Disproved (\ x -> case x of) - (%~) SCV SCR = Disproved (\ x -> case x of) - (%~) SCV SCS = Disproved (\ x -> case x of) - (%~) SCV SCT = Disproved (\ x -> case x of) - (%~) SCV SCU = Disproved (\ x -> case x of) - (%~) SCV SCV = Proved Refl - (%~) SCV SCW = Disproved (\ x -> case x of) - (%~) SCV SCX = Disproved (\ x -> case x of) - (%~) SCV SCY = Disproved (\ x -> case x of) - (%~) SCV SCZ = Disproved (\ x -> case x of) - (%~) SCW SCA = Disproved (\ x -> case x of) - (%~) SCW SCB = Disproved (\ x -> case x of) - (%~) SCW SCC = Disproved (\ x -> case x of) - (%~) SCW SCD = Disproved (\ x -> case x of) - (%~) SCW SCE = Disproved (\ x -> case x of) - (%~) SCW SCF = Disproved (\ x -> case x of) - (%~) SCW SCG = Disproved (\ x -> case x of) - (%~) SCW SCH = Disproved (\ x -> case x of) - (%~) SCW SCI = Disproved (\ x -> case x of) - (%~) SCW SCJ = Disproved (\ x -> case x of) - (%~) SCW SCK = Disproved (\ x -> case x of) - (%~) SCW SCL = Disproved (\ x -> case x of) - (%~) SCW SCM = Disproved (\ x -> case x of) - (%~) SCW SCN = Disproved (\ x -> case x of) - (%~) SCW SCO = Disproved (\ x -> case x of) - (%~) SCW SCP = Disproved (\ x -> case x of) - (%~) SCW SCQ = Disproved (\ x -> case x of) - (%~) SCW SCR = Disproved (\ x -> case x of) - (%~) SCW SCS = Disproved (\ x -> case x of) - (%~) SCW SCT = Disproved (\ x -> case x of) - (%~) SCW SCU = Disproved (\ x -> case x of) - (%~) SCW SCV = Disproved (\ x -> case x of) - (%~) SCW SCW = Proved Refl - (%~) SCW SCX = Disproved (\ x -> case x of) - (%~) SCW SCY = Disproved (\ x -> case x of) - (%~) SCW SCZ = Disproved (\ x -> case x of) - (%~) SCX SCA = Disproved (\ x -> case x of) - (%~) SCX SCB = Disproved (\ x -> case x of) - (%~) SCX SCC = Disproved (\ x -> case x of) - (%~) SCX SCD = Disproved (\ x -> case x of) - (%~) SCX SCE = Disproved (\ x -> case x of) - (%~) SCX SCF = Disproved (\ x -> case x of) - (%~) SCX SCG = Disproved (\ x -> case x of) - (%~) SCX SCH = Disproved (\ x -> case x of) - (%~) SCX SCI = Disproved (\ x -> case x of) - (%~) SCX SCJ = Disproved (\ x -> case x of) - (%~) SCX SCK = Disproved (\ x -> case x of) - (%~) SCX SCL = Disproved (\ x -> case x of) - (%~) SCX SCM = Disproved (\ x -> case x of) - (%~) SCX SCN = Disproved (\ x -> case x of) - (%~) SCX SCO = Disproved (\ x -> case x of) - (%~) SCX SCP = Disproved (\ x -> case x of) - (%~) SCX SCQ = Disproved (\ x -> case x of) - (%~) SCX SCR = Disproved (\ x -> case x of) - (%~) SCX SCS = Disproved (\ x -> case x of) - (%~) SCX SCT = Disproved (\ x -> case x of) - (%~) SCX SCU = Disproved (\ x -> case x of) - (%~) SCX SCV = Disproved (\ x -> case x of) - (%~) SCX SCW = Disproved (\ x -> case x of) - (%~) SCX SCX = Proved Refl - (%~) SCX SCY = Disproved (\ x -> case x of) - (%~) SCX SCZ = Disproved (\ x -> case x of) - (%~) SCY SCA = Disproved (\ x -> case x of) - (%~) SCY SCB = Disproved (\ x -> case x of) - (%~) SCY SCC = Disproved (\ x -> case x of) - (%~) SCY SCD = Disproved (\ x -> case x of) - (%~) SCY SCE = Disproved (\ x -> case x of) - (%~) SCY SCF = Disproved (\ x -> case x of) - (%~) SCY SCG = Disproved (\ x -> case x of) - (%~) SCY SCH = Disproved (\ x -> case x of) - (%~) SCY SCI = Disproved (\ x -> case x of) - (%~) SCY SCJ = Disproved (\ x -> case x of) - (%~) SCY SCK = Disproved (\ x -> case x of) - (%~) SCY SCL = Disproved (\ x -> case x of) - (%~) SCY SCM = Disproved (\ x -> case x of) - (%~) SCY SCN = Disproved (\ x -> case x of) - (%~) SCY SCO = Disproved (\ x -> case x of) - (%~) SCY SCP = Disproved (\ x -> case x of) - (%~) SCY SCQ = Disproved (\ x -> case x of) - (%~) SCY SCR = Disproved (\ x -> case x of) - (%~) SCY SCS = Disproved (\ x -> case x of) - (%~) SCY SCT = Disproved (\ x -> case x of) - (%~) SCY SCU = Disproved (\ x -> case x of) - (%~) SCY SCV = Disproved (\ x -> case x of) - (%~) SCY SCW = Disproved (\ x -> case x of) - (%~) SCY SCX = Disproved (\ x -> case x of) - (%~) SCY SCY = Proved Refl - (%~) SCY SCZ = Disproved (\ x -> case x of) - (%~) SCZ SCA = Disproved (\ x -> case x of) - (%~) SCZ SCB = Disproved (\ x -> case x of) - (%~) SCZ SCC = Disproved (\ x -> case x of) - (%~) SCZ SCD = Disproved (\ x -> case x of) - (%~) SCZ SCE = Disproved (\ x -> case x of) - (%~) SCZ SCF = Disproved (\ x -> case x of) - (%~) SCZ SCG = Disproved (\ x -> case x of) - (%~) SCZ SCH = Disproved (\ x -> case x of) - (%~) SCZ SCI = Disproved (\ x -> case x of) - (%~) SCZ SCJ = Disproved (\ x -> case x of) - (%~) SCZ SCK = Disproved (\ x -> case x of) - (%~) SCZ SCL = Disproved (\ x -> case x of) - (%~) SCZ SCM = Disproved (\ x -> case x of) - (%~) SCZ SCN = Disproved (\ x -> case x of) - (%~) SCZ SCO = Disproved (\ x -> case x of) - (%~) SCZ SCP = Disproved (\ x -> case x of) - (%~) SCZ SCQ = Disproved (\ x -> case x of) - (%~) SCZ SCR = Disproved (\ x -> case x of) - (%~) SCZ SCS = Disproved (\ x -> case x of) - (%~) SCZ SCT = Disproved (\ x -> case x of) - (%~) SCZ SCU = Disproved (\ x -> case x of) - (%~) SCZ SCV = Disproved (\ x -> case x of) - (%~) SCZ SCW = Disproved (\ x -> case x of) - (%~) SCZ SCX = Disproved (\ x -> case x of) - (%~) SCZ SCY = Disproved (\ x -> case x of) - (%~) SCZ SCZ = Proved Refl - instance Data.Type.Equality.TestEquality (SAChar :: AChar - -> Type) where - Data.Type.Equality.testEquality - = Data.Singletons.Decide.decideEquality - instance Data.Type.Coercion.TestCoercion (SAChar :: AChar - -> Type) where - Data.Type.Coercion.testCoercion - = Data.Singletons.Decide.decideCoercion - deriving instance (Data.Singletons.ShowSing.ShowSing U, - Data.Singletons.ShowSing.ShowSing Nat) => - Show (SU (z :: U)) - deriving instance Show (SAChar (z :: AChar)) - instance SingI BOOL where - sing = SBOOL - instance SingI STRING where - sing = SSTRING - instance SingI NAT where - sing = SNAT - instance (SingI n, SingI n) => - SingI (VEC (n :: U) (n :: Nat)) where - sing = (SVEC sing) sing - instance SingI (VECSym0 :: (~>) U ((~>) Nat U)) where - sing = (singFun2 @VECSym0) SVEC - instance SingI d => SingI (VECSym1 (d :: U) :: (~>) Nat U) where - sing = (singFun1 @(VECSym1 (d :: U))) (SVEC (sing @d)) - instance SingI CA where - sing = SCA - instance SingI CB where - sing = SCB - instance SingI CC where - sing = SCC - instance SingI CD where - sing = SCD - instance SingI CE where - sing = SCE - instance SingI CF where - sing = SCF - instance SingI CG where - sing = SCG - instance SingI CH where - sing = SCH - instance SingI CI where - sing = SCI - instance SingI CJ where - sing = SCJ - instance SingI CK where - sing = SCK - instance SingI CL where - sing = SCL - instance SingI CM where - sing = SCM - instance SingI CN where - sing = SCN - instance SingI CO where - sing = SCO - instance SingI CP where - sing = SCP - instance SingI CQ where - sing = SCQ - instance SingI CR where - sing = SCR - instance SingI CS where - sing = SCS - instance SingI CT where - sing = SCT - instance SingI CU where - sing = SCU - instance SingI CV where - sing = SCV - instance SingI CW where - sing = SCW - instance SingI CX where - sing = SCX - instance SingI CY where - sing = SCY - instance SingI CZ where - sing = SCZ - instance (SingI n, SingI n) => - SingI (Attr (n :: [AChar]) (n :: U)) where - sing = (SAttr sing) sing - instance SingI (AttrSym0 :: (~>) [AChar] ((~>) U Attribute)) where - sing = (singFun2 @AttrSym0) SAttr - instance SingI d => - SingI (AttrSym1 (d :: [AChar]) :: (~>) U Attribute) where - sing = (singFun1 @(AttrSym1 (d :: [AChar]))) (SAttr (sing @d)) - instance SingI n => SingI (Sch (n :: [Attribute])) where - sing = SSch sing + = case toSing b :: SomeSing Nat of SomeSing c -> SomeSing (SSucc c) + instance SEq Nat => SEq Nat where + (%==) :: + forall (t1 :: Nat) (t2 :: Nat). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun Nat ((~>) Nat Bool) + -> Type) t1) t2) + (%==) SZero SZero = STrue + (%==) SZero (SSucc _) = SFalse + (%==) (SSucc _) SZero = SFalse + (%==) + (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210)) + (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210)) + = (applySing + ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210)) + sB_0123456789876543210 + instance SOrd Nat => SOrd Nat where + sCompare :: + forall (t1 :: Nat) (t2 :: Nat). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat ((~>) Nat Ordering) + -> Type) t1) t2) + sCompare SZero SZero + = (applySing + ((applySing + ((applySing ((singFun3 @FoldlSym0) sFoldl)) + ((singFun2 @ThenCmpSym0) sThenCmp))) + SEQ)) + SNil + sCompare + (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210)) + (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210)) + = (applySing + ((applySing + ((applySing ((singFun3 @FoldlSym0) sFoldl)) + ((singFun2 @ThenCmpSym0) sThenCmp))) + SEQ)) + ((applySing + ((applySing ((singFun2 @(:@#@$)) SCons)) + ((applySing + ((applySing ((singFun2 @CompareSym0) sCompare)) + sA_0123456789876543210)) + sB_0123456789876543210))) + SNil) + sCompare SZero (SSucc _) = SLT + sCompare (SSucc _) SZero = SGT + instance SDecide Nat => SDecide Nat where + (%~) SZero SZero = Proved Refl + (%~) SZero (SSucc _) = Disproved (\ x -> case x of {}) + (%~) (SSucc _) SZero = Disproved (\ x -> case x of {}) + (%~) (SSucc a) (SSucc b) + = case ((%~) a) b of + Proved Refl -> Proved Refl + Disproved contra + -> Disproved (\ refl -> case refl of Refl -> contra Refl) + instance SDecide Nat => + Data.Type.Equality.TestEquality (SNat :: Nat -> Type) where + Data.Type.Equality.testEquality + = Data.Singletons.Decide.decideEquality + instance SDecide Nat => + Data.Type.Coercion.TestCoercion (SNat :: Nat -> Type) where + Data.Type.Coercion.testCoercion + = Data.Singletons.Decide.decideCoercion + instance SingI Zero where + sing = SZero + instance SingI n => SingI (Succ (n :: Nat)) where + sing = SSucc sing + instance SingI1 Succ where + liftSing = SSucc + instance SingI (SuccSym0 :: (~>) Nat Nat) where + sing = (singFun1 @SuccSym0) SSucc +GradingClient/Database.hs:(0,0)-(0,0): Splicing declarations + singletons + [d| append :: Schema -> Schema -> Schema + append (Sch s1) (Sch s2) = Sch (s1 ++ s2) + attrNotIn :: Attribute -> Schema -> Bool + attrNotIn _ (Sch []) = True + attrNotIn (Attr name u) (Sch ((Attr name' _) : t)) + = (name /= name') && (attrNotIn (Attr name u) (Sch t)) + disjoint :: Schema -> Schema -> Bool + disjoint (Sch []) _ = True + disjoint (Sch (h : t)) s = (attrNotIn h s) && (disjoint (Sch t) s) + occurs :: [AChar] -> Schema -> Bool + occurs _ (Sch []) = False + occurs name (Sch ((Attr name' _) : attrs)) + = name == name' || occurs name (Sch attrs) + lookup :: [AChar] -> Schema -> U + lookup _ (Sch []) = undefined + lookup name (Sch ((Attr name' u) : attrs)) + = if name == name' then u else lookup name (Sch attrs) + + data U + = BOOL | STRING | NAT | VEC U Nat + deriving (Read, Eq, Show) + data AChar + = CA | + CB | + CC | + CD | + CE | + CF | + CG | + CH | + CI | + CJ | + CK | + CL | + CM | + CN | + CO | + CP | + CQ | + CR | + CS | + CT | + CU | + CV | + CW | + CX | + CY | + CZ + deriving (Read, Show, Eq) + data Attribute = Attr [AChar] U + data Schema = Sch [Attribute] |] + ======> + data U + = BOOL | STRING | NAT | VEC U Nat + deriving (Read, Eq, Show) + data AChar + = CA | + CB | + CC | + CD | + CE | + CF | + CG | + CH | + CI | + CJ | + CK | + CL | + CM | + CN | + CO | + CP | + CQ | + CR | + CS | + CT | + CU | + CV | + CW | + CX | + CY | + CZ + deriving (Read, Show, Eq) + data Attribute = Attr [AChar] U + data Schema = Sch [Attribute] + append :: Schema -> Schema -> Schema + append (Sch s1) (Sch s2) = Sch (s1 ++ s2) + attrNotIn :: Attribute -> Schema -> Bool + attrNotIn _ (Sch []) = True + attrNotIn (Attr name u) (Sch (Attr name' _ : t)) + = ((name /= name') && (attrNotIn ((Attr name) u)) (Sch t)) + disjoint :: Schema -> Schema -> Bool + disjoint (Sch []) _ = True + disjoint (Sch (h : t)) s + = ((attrNotIn h) s && (disjoint (Sch t)) s) + occurs :: [AChar] -> Schema -> Bool + occurs _ (Sch []) = False + occurs name (Sch (Attr name' _ : attrs)) + = ((name == name') || (occurs name) (Sch attrs)) + lookup :: [AChar] -> Schema -> U + lookup _ (Sch []) = undefined + lookup name (Sch (Attr name' u : attrs)) + = if (name == name') then u else (lookup name) (Sch attrs) + type BOOLSym0 :: U + type family BOOLSym0 :: U where + BOOLSym0 = BOOL + type STRINGSym0 :: U + type family STRINGSym0 :: U where + STRINGSym0 = STRING + type NATSym0 :: U + type family NATSym0 :: U where + NATSym0 = NAT + type VECSym0 :: (~>) U ((~>) Nat U) + data VECSym0 :: (~>) U ((~>) Nat U) + where + VECSym0KindInference :: SameKind (Apply VECSym0 arg) (VECSym1 arg) => + VECSym0 a0123456789876543210 + type instance Apply VECSym0 a0123456789876543210 = VECSym1 a0123456789876543210 + instance SuppressUnusedWarnings VECSym0 where + suppressUnusedWarnings = snd (((,) VECSym0KindInference) ()) + type VECSym1 :: U -> (~>) Nat U + data VECSym1 (a0123456789876543210 :: U) :: (~>) Nat U + where + VECSym1KindInference :: SameKind (Apply (VECSym1 a0123456789876543210) arg) (VECSym2 a0123456789876543210 arg) => + VECSym1 a0123456789876543210 a0123456789876543210 + type instance Apply (VECSym1 a0123456789876543210) a0123456789876543210 = VEC a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (VECSym1 a0123456789876543210) where + suppressUnusedWarnings = snd (((,) VECSym1KindInference) ()) + type VECSym2 :: U -> Nat -> U + type family VECSym2 (a0123456789876543210 :: U) (a0123456789876543210 :: Nat) :: U where + VECSym2 a0123456789876543210 a0123456789876543210 = VEC a0123456789876543210 a0123456789876543210 + type CASym0 :: AChar + type family CASym0 :: AChar where + CASym0 = CA + type CBSym0 :: AChar + type family CBSym0 :: AChar where + CBSym0 = CB + type CCSym0 :: AChar + type family CCSym0 :: AChar where + CCSym0 = CC + type CDSym0 :: AChar + type family CDSym0 :: AChar where + CDSym0 = CD + type CESym0 :: AChar + type family CESym0 :: AChar where + CESym0 = CE + type CFSym0 :: AChar + type family CFSym0 :: AChar where + CFSym0 = CF + type CGSym0 :: AChar + type family CGSym0 :: AChar where + CGSym0 = CG + type CHSym0 :: AChar + type family CHSym0 :: AChar where + CHSym0 = CH + type CISym0 :: AChar + type family CISym0 :: AChar where + CISym0 = CI + type CJSym0 :: AChar + type family CJSym0 :: AChar where + CJSym0 = CJ + type CKSym0 :: AChar + type family CKSym0 :: AChar where + CKSym0 = CK + type CLSym0 :: AChar + type family CLSym0 :: AChar where + CLSym0 = CL + type CMSym0 :: AChar + type family CMSym0 :: AChar where + CMSym0 = CM + type CNSym0 :: AChar + type family CNSym0 :: AChar where + CNSym0 = CN + type COSym0 :: AChar + type family COSym0 :: AChar where + COSym0 = CO + type CPSym0 :: AChar + type family CPSym0 :: AChar where + CPSym0 = CP + type CQSym0 :: AChar + type family CQSym0 :: AChar where + CQSym0 = CQ + type CRSym0 :: AChar + type family CRSym0 :: AChar where + CRSym0 = CR + type CSSym0 :: AChar + type family CSSym0 :: AChar where + CSSym0 = CS + type CTSym0 :: AChar + type family CTSym0 :: AChar where + CTSym0 = CT + type CUSym0 :: AChar + type family CUSym0 :: AChar where + CUSym0 = CU + type CVSym0 :: AChar + type family CVSym0 :: AChar where + CVSym0 = CV + type CWSym0 :: AChar + type family CWSym0 :: AChar where + CWSym0 = CW + type CXSym0 :: AChar + type family CXSym0 :: AChar where + CXSym0 = CX + type CYSym0 :: AChar + type family CYSym0 :: AChar where + CYSym0 = CY + type CZSym0 :: AChar + type family CZSym0 :: AChar where + CZSym0 = CZ + type AttrSym0 :: (~>) [AChar] ((~>) U Attribute) + data AttrSym0 :: (~>) [AChar] ((~>) U Attribute) + where + AttrSym0KindInference :: SameKind (Apply AttrSym0 arg) (AttrSym1 arg) => + AttrSym0 a0123456789876543210 + type instance Apply AttrSym0 a0123456789876543210 = AttrSym1 a0123456789876543210 + instance SuppressUnusedWarnings AttrSym0 where + suppressUnusedWarnings = snd (((,) AttrSym0KindInference) ()) + type AttrSym1 :: [AChar] -> (~>) U Attribute + data AttrSym1 (a0123456789876543210 :: [AChar]) :: (~>) U Attribute + where + AttrSym1KindInference :: SameKind (Apply (AttrSym1 a0123456789876543210) arg) (AttrSym2 a0123456789876543210 arg) => + AttrSym1 a0123456789876543210 a0123456789876543210 + type instance Apply (AttrSym1 a0123456789876543210) a0123456789876543210 = Attr a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (AttrSym1 a0123456789876543210) where + suppressUnusedWarnings = snd (((,) AttrSym1KindInference) ()) + type AttrSym2 :: [AChar] -> U -> Attribute + type family AttrSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: U) :: Attribute where + AttrSym2 a0123456789876543210 a0123456789876543210 = Attr a0123456789876543210 a0123456789876543210 + type SchSym0 :: (~>) [Attribute] Schema + data SchSym0 :: (~>) [Attribute] Schema + where + SchSym0KindInference :: SameKind (Apply SchSym0 arg) (SchSym1 arg) => + SchSym0 a0123456789876543210 + type instance Apply SchSym0 a0123456789876543210 = Sch a0123456789876543210 + instance SuppressUnusedWarnings SchSym0 where + suppressUnusedWarnings = snd (((,) SchSym0KindInference) ()) + type SchSym1 :: [Attribute] -> Schema + type family SchSym1 (a0123456789876543210 :: [Attribute]) :: Schema where + SchSym1 a0123456789876543210 = Sch a0123456789876543210 + data Let0123456789876543210Scrutinee_0123456789876543210Sym0 name0123456789876543210 + where + Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) => + Let0123456789876543210Scrutinee_0123456789876543210Sym0 name0123456789876543210 + type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 name0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210 + instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where + suppressUnusedWarnings + = snd + (((,) + Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference) + ()) + data Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210 name'0123456789876543210 + where + Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference :: SameKind (Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210) arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 arg) => + Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210 name'0123456789876543210 + type instance Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210) name'0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210 + instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210) where + suppressUnusedWarnings + = snd + (((,) + Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference) + ()) + data Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210 u0123456789876543210 + where + Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference :: SameKind (Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210) arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 arg) => + Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210 u0123456789876543210 + type instance Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210) u0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210 + instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210) where + suppressUnusedWarnings + = snd + (((,) + Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference) + ()) + data Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 + where + Let0123456789876543210Scrutinee_0123456789876543210Sym3KindInference :: SameKind (Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210) arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name0123456789876543210 name'0123456789876543210 u0123456789876543210 arg) => + Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 + type instance Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210) attrs0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 + instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210) where + suppressUnusedWarnings + = snd + (((,) + Let0123456789876543210Scrutinee_0123456789876543210Sym3KindInference) + ()) + type family Let0123456789876543210Scrutinee_0123456789876543210Sym4 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 where + Let0123456789876543210Scrutinee_0123456789876543210Sym4 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 + type family Let0123456789876543210Scrutinee_0123456789876543210 name name' u attrs where + Let0123456789876543210Scrutinee_0123456789876543210 name name' u attrs = Apply (Apply (==@#@$) name) name' + type family Case_0123456789876543210 name name' u attrs t where + Case_0123456789876543210 name name' u attrs 'True = u + Case_0123456789876543210 name name' u attrs 'False = Apply (Apply LookupSym0 name) (Apply SchSym0 attrs) + type LookupSym0 :: (~>) [AChar] ((~>) Schema U) + data LookupSym0 :: (~>) [AChar] ((~>) Schema U) + where + LookupSym0KindInference :: SameKind (Apply LookupSym0 arg) (LookupSym1 arg) => + LookupSym0 a0123456789876543210 + type instance Apply LookupSym0 a0123456789876543210 = LookupSym1 a0123456789876543210 + instance SuppressUnusedWarnings LookupSym0 where + suppressUnusedWarnings = snd (((,) LookupSym0KindInference) ()) + type LookupSym1 :: [AChar] -> (~>) Schema U + data LookupSym1 (a0123456789876543210 :: [AChar]) :: (~>) Schema U + where + LookupSym1KindInference :: SameKind (Apply (LookupSym1 a0123456789876543210) arg) (LookupSym2 a0123456789876543210 arg) => + LookupSym1 a0123456789876543210 a0123456789876543210 + type instance Apply (LookupSym1 a0123456789876543210) a0123456789876543210 = Lookup a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (LookupSym1 a0123456789876543210) where + suppressUnusedWarnings = snd (((,) LookupSym1KindInference) ()) + type LookupSym2 :: [AChar] -> Schema -> U + type family LookupSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: Schema) :: U where + LookupSym2 a0123456789876543210 a0123456789876543210 = Lookup a0123456789876543210 a0123456789876543210 + type OccursSym0 :: (~>) [AChar] ((~>) Schema Bool) + data OccursSym0 :: (~>) [AChar] ((~>) Schema Bool) + where + OccursSym0KindInference :: SameKind (Apply OccursSym0 arg) (OccursSym1 arg) => + OccursSym0 a0123456789876543210 + type instance Apply OccursSym0 a0123456789876543210 = OccursSym1 a0123456789876543210 + instance SuppressUnusedWarnings OccursSym0 where + suppressUnusedWarnings = snd (((,) OccursSym0KindInference) ()) + type OccursSym1 :: [AChar] -> (~>) Schema Bool + data OccursSym1 (a0123456789876543210 :: [AChar]) :: (~>) Schema Bool + where + OccursSym1KindInference :: SameKind (Apply (OccursSym1 a0123456789876543210) arg) (OccursSym2 a0123456789876543210 arg) => + OccursSym1 a0123456789876543210 a0123456789876543210 + type instance Apply (OccursSym1 a0123456789876543210) a0123456789876543210 = Occurs a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (OccursSym1 a0123456789876543210) where + suppressUnusedWarnings = snd (((,) OccursSym1KindInference) ()) + type OccursSym2 :: [AChar] -> Schema -> Bool + type family OccursSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: Schema) :: Bool where + OccursSym2 a0123456789876543210 a0123456789876543210 = Occurs a0123456789876543210 a0123456789876543210 + type DisjointSym0 :: (~>) Schema ((~>) Schema Bool) + data DisjointSym0 :: (~>) Schema ((~>) Schema Bool) + where + DisjointSym0KindInference :: SameKind (Apply DisjointSym0 arg) (DisjointSym1 arg) => + DisjointSym0 a0123456789876543210 + type instance Apply DisjointSym0 a0123456789876543210 = DisjointSym1 a0123456789876543210 + instance SuppressUnusedWarnings DisjointSym0 where + suppressUnusedWarnings = snd (((,) DisjointSym0KindInference) ()) + type DisjointSym1 :: Schema -> (~>) Schema Bool + data DisjointSym1 (a0123456789876543210 :: Schema) :: (~>) Schema Bool + where + DisjointSym1KindInference :: SameKind (Apply (DisjointSym1 a0123456789876543210) arg) (DisjointSym2 a0123456789876543210 arg) => + DisjointSym1 a0123456789876543210 a0123456789876543210 + type instance Apply (DisjointSym1 a0123456789876543210) a0123456789876543210 = Disjoint a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (DisjointSym1 a0123456789876543210) where + suppressUnusedWarnings = snd (((,) DisjointSym1KindInference) ()) + type DisjointSym2 :: Schema -> Schema -> Bool + type family DisjointSym2 (a0123456789876543210 :: Schema) (a0123456789876543210 :: Schema) :: Bool where + DisjointSym2 a0123456789876543210 a0123456789876543210 = Disjoint a0123456789876543210 a0123456789876543210 + type AttrNotInSym0 :: (~>) Attribute ((~>) Schema Bool) + data AttrNotInSym0 :: (~>) Attribute ((~>) Schema Bool) + where + AttrNotInSym0KindInference :: SameKind (Apply AttrNotInSym0 arg) (AttrNotInSym1 arg) => + AttrNotInSym0 a0123456789876543210 + type instance Apply AttrNotInSym0 a0123456789876543210 = AttrNotInSym1 a0123456789876543210 + instance SuppressUnusedWarnings AttrNotInSym0 where + suppressUnusedWarnings = snd (((,) AttrNotInSym0KindInference) ()) + type AttrNotInSym1 :: Attribute -> (~>) Schema Bool + data AttrNotInSym1 (a0123456789876543210 :: Attribute) :: (~>) Schema Bool + where + AttrNotInSym1KindInference :: SameKind (Apply (AttrNotInSym1 a0123456789876543210) arg) (AttrNotInSym2 a0123456789876543210 arg) => + AttrNotInSym1 a0123456789876543210 a0123456789876543210 + type instance Apply (AttrNotInSym1 a0123456789876543210) a0123456789876543210 = AttrNotIn a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (AttrNotInSym1 a0123456789876543210) where + suppressUnusedWarnings = snd (((,) AttrNotInSym1KindInference) ()) + type AttrNotInSym2 :: Attribute -> Schema -> Bool + type family AttrNotInSym2 (a0123456789876543210 :: Attribute) (a0123456789876543210 :: Schema) :: Bool where + AttrNotInSym2 a0123456789876543210 a0123456789876543210 = AttrNotIn a0123456789876543210 a0123456789876543210 + type AppendSym0 :: (~>) Schema ((~>) Schema Schema) + data AppendSym0 :: (~>) Schema ((~>) Schema Schema) + where + AppendSym0KindInference :: SameKind (Apply AppendSym0 arg) (AppendSym1 arg) => + AppendSym0 a0123456789876543210 + type instance Apply AppendSym0 a0123456789876543210 = AppendSym1 a0123456789876543210 + instance SuppressUnusedWarnings AppendSym0 where + suppressUnusedWarnings = snd (((,) AppendSym0KindInference) ()) + type AppendSym1 :: Schema -> (~>) Schema Schema + data AppendSym1 (a0123456789876543210 :: Schema) :: (~>) Schema Schema + where + AppendSym1KindInference :: SameKind (Apply (AppendSym1 a0123456789876543210) arg) (AppendSym2 a0123456789876543210 arg) => + AppendSym1 a0123456789876543210 a0123456789876543210 + type instance Apply (AppendSym1 a0123456789876543210) a0123456789876543210 = Append a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (AppendSym1 a0123456789876543210) where + suppressUnusedWarnings = snd (((,) AppendSym1KindInference) ()) + type AppendSym2 :: Schema -> Schema -> Schema + type family AppendSym2 (a0123456789876543210 :: Schema) (a0123456789876543210 :: Schema) :: Schema where + AppendSym2 a0123456789876543210 a0123456789876543210 = Append a0123456789876543210 a0123456789876543210 + type Lookup :: [AChar] -> Schema -> U + type family Lookup (a :: [AChar]) (a :: Schema) :: U where + Lookup _ (Sch '[]) = UndefinedSym0 + Lookup name (Sch ('(:) (Attr name' u) attrs)) = Case_0123456789876543210 name name' u attrs (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name name' u attrs) + type Occurs :: [AChar] -> Schema -> Bool + type family Occurs (a :: [AChar]) (a :: Schema) :: Bool where + Occurs _ (Sch '[]) = FalseSym0 + Occurs name (Sch ('(:) (Attr name' _) attrs)) = Apply (Apply (||@#@$) (Apply (Apply (==@#@$) name) name')) (Apply (Apply OccursSym0 name) (Apply SchSym0 attrs)) + type Disjoint :: Schema -> Schema -> Bool + type family Disjoint (a :: Schema) (a :: Schema) :: Bool where + Disjoint (Sch '[]) _ = TrueSym0 + Disjoint (Sch ('(:) h t)) s = Apply (Apply (&&@#@$) (Apply (Apply AttrNotInSym0 h) s)) (Apply (Apply DisjointSym0 (Apply SchSym0 t)) s) + type AttrNotIn :: Attribute -> Schema -> Bool + type family AttrNotIn (a :: Attribute) (a :: Schema) :: Bool where + AttrNotIn _ (Sch '[]) = TrueSym0 + AttrNotIn (Attr name u) (Sch ('(:) (Attr name' _) t)) = Apply (Apply (&&@#@$) (Apply (Apply (/=@#@$) name) name')) (Apply (Apply AttrNotInSym0 (Apply (Apply AttrSym0 name) u)) (Apply SchSym0 t)) + type Append :: Schema -> Schema -> Schema + type family Append (a :: Schema) (a :: Schema) :: Schema where + Append (Sch s1) (Sch s2) = Apply SchSym0 (Apply (Apply (++@#@$) s1) s2) + type TFHelper_0123456789876543210 :: U -> U -> Bool + type family TFHelper_0123456789876543210 (a :: U) (a :: U) :: Bool where + TFHelper_0123456789876543210 BOOL BOOL = TrueSym0 + TFHelper_0123456789876543210 BOOL STRING = FalseSym0 + TFHelper_0123456789876543210 BOOL NAT = FalseSym0 + TFHelper_0123456789876543210 BOOL (VEC _ _) = FalseSym0 + TFHelper_0123456789876543210 STRING BOOL = FalseSym0 + TFHelper_0123456789876543210 STRING STRING = TrueSym0 + TFHelper_0123456789876543210 STRING NAT = FalseSym0 + TFHelper_0123456789876543210 STRING (VEC _ _) = FalseSym0 + TFHelper_0123456789876543210 NAT BOOL = FalseSym0 + TFHelper_0123456789876543210 NAT STRING = FalseSym0 + TFHelper_0123456789876543210 NAT NAT = TrueSym0 + TFHelper_0123456789876543210 NAT (VEC _ _) = FalseSym0 + TFHelper_0123456789876543210 (VEC _ _) BOOL = FalseSym0 + TFHelper_0123456789876543210 (VEC _ _) STRING = FalseSym0 + TFHelper_0123456789876543210 (VEC _ _) NAT = FalseSym0 + TFHelper_0123456789876543210 (VEC a_0123456789876543210 a_0123456789876543210) (VEC b_0123456789876543210 b_0123456789876543210) = Apply (Apply (&&@#@$) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (==@#@$) a_0123456789876543210) b_0123456789876543210) + type TFHelper_0123456789876543210Sym0 :: (~>) U ((~>) U Bool) + data TFHelper_0123456789876543210Sym0 :: (~>) U ((~>) U Bool) + where + TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) => + TFHelper_0123456789876543210Sym0 a0123456789876543210 + type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210 + instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where + suppressUnusedWarnings + = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ()) + type TFHelper_0123456789876543210Sym1 :: U -> (~>) U Bool + data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: U) :: (~>) U Bool + where + TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) => + TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 + type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where + suppressUnusedWarnings + = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ()) + type TFHelper_0123456789876543210Sym2 :: U -> U -> Bool + type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: U) (a0123456789876543210 :: U) :: Bool where + TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 + instance PEq U where + type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural + -> U -> Symbol -> Symbol + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: U) (a :: Symbol) :: Symbol where + ShowsPrec_0123456789876543210 _ BOOL a_0123456789876543210 = Apply (Apply ShowStringSym0 "BOOL") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ STRING a_0123456789876543210 = Apply (Apply ShowStringSym0 "STRING") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ NAT a_0123456789876543210 = Apply (Apply ShowStringSym0 "NAT") a_0123456789876543210 + ShowsPrec_0123456789876543210 p_0123456789876543210 (VEC arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "VEC ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210 + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) U ((~>) Symbol Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) U ((~>) Symbol Symbol)) + where + ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => + ShowsPrec_0123456789876543210Sym0 a0123456789876543210 + type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210 + instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where + suppressUnusedWarnings + = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural + -> (~>) U ((~>) Symbol Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) U ((~>) Symbol Symbol) + where + ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => + ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 + type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where + suppressUnusedWarnings + = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural + -> U -> (~>) Symbol Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: U) :: (~>) Symbol Symbol + where + ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => + ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 + type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where + suppressUnusedWarnings + = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural + -> U -> Symbol -> Symbol + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: U) (a0123456789876543210 :: Symbol) :: Symbol where + ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 + instance PShow U where + type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural + -> AChar -> Symbol -> Symbol + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: AChar) (a :: Symbol) :: Symbol where + ShowsPrec_0123456789876543210 _ CA a_0123456789876543210 = Apply (Apply ShowStringSym0 "CA") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CB a_0123456789876543210 = Apply (Apply ShowStringSym0 "CB") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CC a_0123456789876543210 = Apply (Apply ShowStringSym0 "CC") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CD a_0123456789876543210 = Apply (Apply ShowStringSym0 "CD") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CE a_0123456789876543210 = Apply (Apply ShowStringSym0 "CE") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CF a_0123456789876543210 = Apply (Apply ShowStringSym0 "CF") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CG a_0123456789876543210 = Apply (Apply ShowStringSym0 "CG") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CH a_0123456789876543210 = Apply (Apply ShowStringSym0 "CH") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CI a_0123456789876543210 = Apply (Apply ShowStringSym0 "CI") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CJ a_0123456789876543210 = Apply (Apply ShowStringSym0 "CJ") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CK a_0123456789876543210 = Apply (Apply ShowStringSym0 "CK") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CL a_0123456789876543210 = Apply (Apply ShowStringSym0 "CL") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CM a_0123456789876543210 = Apply (Apply ShowStringSym0 "CM") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CN a_0123456789876543210 = Apply (Apply ShowStringSym0 "CN") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CO a_0123456789876543210 = Apply (Apply ShowStringSym0 "CO") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CP a_0123456789876543210 = Apply (Apply ShowStringSym0 "CP") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CQ a_0123456789876543210 = Apply (Apply ShowStringSym0 "CQ") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CR a_0123456789876543210 = Apply (Apply ShowStringSym0 "CR") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CS a_0123456789876543210 = Apply (Apply ShowStringSym0 "CS") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CT a_0123456789876543210 = Apply (Apply ShowStringSym0 "CT") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CU a_0123456789876543210 = Apply (Apply ShowStringSym0 "CU") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CV a_0123456789876543210 = Apply (Apply ShowStringSym0 "CV") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CW a_0123456789876543210 = Apply (Apply ShowStringSym0 "CW") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CX a_0123456789876543210 = Apply (Apply ShowStringSym0 "CX") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CY a_0123456789876543210 = Apply (Apply ShowStringSym0 "CY") a_0123456789876543210 + ShowsPrec_0123456789876543210 _ CZ a_0123456789876543210 = Apply (Apply ShowStringSym0 "CZ") a_0123456789876543210 + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) AChar ((~>) Symbol Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) AChar ((~>) Symbol Symbol)) + where + ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => + ShowsPrec_0123456789876543210Sym0 a0123456789876543210 + type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210 + instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where + suppressUnusedWarnings + = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural + -> (~>) AChar ((~>) Symbol Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) AChar ((~>) Symbol Symbol) + where + ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => + ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 + type instance Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where + suppressUnusedWarnings + = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural + -> AChar -> (~>) Symbol Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: AChar) :: (~>) Symbol Symbol + where + ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => + ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 + type instance Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where + suppressUnusedWarnings + = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural + -> AChar -> Symbol -> Symbol + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: AChar) (a0123456789876543210 :: Symbol) :: Symbol where + ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 + instance PShow AChar where + type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a + type TFHelper_0123456789876543210 :: AChar -> AChar -> Bool + type family TFHelper_0123456789876543210 (a :: AChar) (a :: AChar) :: Bool where + TFHelper_0123456789876543210 CA CA = TrueSym0 + TFHelper_0123456789876543210 CA CB = FalseSym0 + TFHelper_0123456789876543210 CA CC = FalseSym0 + TFHelper_0123456789876543210 CA CD = FalseSym0 + TFHelper_0123456789876543210 CA CE = FalseSym0 + TFHelper_0123456789876543210 CA CF = FalseSym0 + TFHelper_0123456789876543210 CA CG = FalseSym0 + TFHelper_0123456789876543210 CA CH = FalseSym0 + TFHelper_0123456789876543210 CA CI = FalseSym0 + TFHelper_0123456789876543210 CA CJ = FalseSym0 + TFHelper_0123456789876543210 CA CK = FalseSym0 + TFHelper_0123456789876543210 CA CL = FalseSym0 + TFHelper_0123456789876543210 CA CM = FalseSym0 + TFHelper_0123456789876543210 CA CN = FalseSym0 + TFHelper_0123456789876543210 CA CO = FalseSym0 + TFHelper_0123456789876543210 CA CP = FalseSym0 + TFHelper_0123456789876543210 CA CQ = FalseSym0 + TFHelper_0123456789876543210 CA CR = FalseSym0 + TFHelper_0123456789876543210 CA CS = FalseSym0 + TFHelper_0123456789876543210 CA CT = FalseSym0 + TFHelper_0123456789876543210 CA CU = FalseSym0 + TFHelper_0123456789876543210 CA CV = FalseSym0 + TFHelper_0123456789876543210 CA CW = FalseSym0 + TFHelper_0123456789876543210 CA CX = FalseSym0 + TFHelper_0123456789876543210 CA CY = FalseSym0 + TFHelper_0123456789876543210 CA CZ = FalseSym0 + TFHelper_0123456789876543210 CB CA = FalseSym0 + TFHelper_0123456789876543210 CB CB = TrueSym0 + TFHelper_0123456789876543210 CB CC = FalseSym0 + TFHelper_0123456789876543210 CB CD = FalseSym0 + TFHelper_0123456789876543210 CB CE = FalseSym0 + TFHelper_0123456789876543210 CB CF = FalseSym0 + TFHelper_0123456789876543210 CB CG = FalseSym0 + TFHelper_0123456789876543210 CB CH = FalseSym0 + TFHelper_0123456789876543210 CB CI = FalseSym0 + TFHelper_0123456789876543210 CB CJ = FalseSym0 + TFHelper_0123456789876543210 CB CK = FalseSym0 + TFHelper_0123456789876543210 CB CL = FalseSym0 + TFHelper_0123456789876543210 CB CM = FalseSym0 + TFHelper_0123456789876543210 CB CN = FalseSym0 + TFHelper_0123456789876543210 CB CO = FalseSym0 + TFHelper_0123456789876543210 CB CP = FalseSym0 + TFHelper_0123456789876543210 CB CQ = FalseSym0 + TFHelper_0123456789876543210 CB CR = FalseSym0 + TFHelper_0123456789876543210 CB CS = FalseSym0 + TFHelper_0123456789876543210 CB CT = FalseSym0 + TFHelper_0123456789876543210 CB CU = FalseSym0 + TFHelper_0123456789876543210 CB CV = FalseSym0 + TFHelper_0123456789876543210 CB CW = FalseSym0 + TFHelper_0123456789876543210 CB CX = FalseSym0 + TFHelper_0123456789876543210 CB CY = FalseSym0 + TFHelper_0123456789876543210 CB CZ = FalseSym0 + TFHelper_0123456789876543210 CC CA = FalseSym0 + TFHelper_0123456789876543210 CC CB = FalseSym0 + TFHelper_0123456789876543210 CC CC = TrueSym0 + TFHelper_0123456789876543210 CC CD = FalseSym0 + TFHelper_0123456789876543210 CC CE = FalseSym0 + TFHelper_0123456789876543210 CC CF = FalseSym0 + TFHelper_0123456789876543210 CC CG = FalseSym0 + TFHelper_0123456789876543210 CC CH = FalseSym0 + TFHelper_0123456789876543210 CC CI = FalseSym0 + TFHelper_0123456789876543210 CC CJ = FalseSym0 + TFHelper_0123456789876543210 CC CK = FalseSym0 + TFHelper_0123456789876543210 CC CL = FalseSym0 + TFHelper_0123456789876543210 CC CM = FalseSym0 + TFHelper_0123456789876543210 CC CN = FalseSym0 + TFHelper_0123456789876543210 CC CO = FalseSym0 + TFHelper_0123456789876543210 CC CP = FalseSym0 + TFHelper_0123456789876543210 CC CQ = FalseSym0 + TFHelper_0123456789876543210 CC CR = FalseSym0 + TFHelper_0123456789876543210 CC CS = FalseSym0 + TFHelper_0123456789876543210 CC CT = FalseSym0 + TFHelper_0123456789876543210 CC CU = FalseSym0 + TFHelper_0123456789876543210 CC CV = FalseSym0 + TFHelper_0123456789876543210 CC CW = FalseSym0 + TFHelper_0123456789876543210 CC CX = FalseSym0 + TFHelper_0123456789876543210 CC CY = FalseSym0 + TFHelper_0123456789876543210 CC CZ = FalseSym0 + TFHelper_0123456789876543210 CD CA = FalseSym0 + TFHelper_0123456789876543210 CD CB = FalseSym0 + TFHelper_0123456789876543210 CD CC = FalseSym0 + TFHelper_0123456789876543210 CD CD = TrueSym0 + TFHelper_0123456789876543210 CD CE = FalseSym0 + TFHelper_0123456789876543210 CD CF = FalseSym0 + TFHelper_0123456789876543210 CD CG = FalseSym0 + TFHelper_0123456789876543210 CD CH = FalseSym0 + TFHelper_0123456789876543210 CD CI = FalseSym0 + TFHelper_0123456789876543210 CD CJ = FalseSym0 + TFHelper_0123456789876543210 CD CK = FalseSym0 + TFHelper_0123456789876543210 CD CL = FalseSym0 + TFHelper_0123456789876543210 CD CM = FalseSym0 + TFHelper_0123456789876543210 CD CN = FalseSym0 + TFHelper_0123456789876543210 CD CO = FalseSym0 + TFHelper_0123456789876543210 CD CP = FalseSym0 + TFHelper_0123456789876543210 CD CQ = FalseSym0 + TFHelper_0123456789876543210 CD CR = FalseSym0 + TFHelper_0123456789876543210 CD CS = FalseSym0 + TFHelper_0123456789876543210 CD CT = FalseSym0 + TFHelper_0123456789876543210 CD CU = FalseSym0 + TFHelper_0123456789876543210 CD CV = FalseSym0 + TFHelper_0123456789876543210 CD CW = FalseSym0 + TFHelper_0123456789876543210 CD CX = FalseSym0 + TFHelper_0123456789876543210 CD CY = FalseSym0 + TFHelper_0123456789876543210 CD CZ = FalseSym0 + TFHelper_0123456789876543210 CE CA = FalseSym0 + TFHelper_0123456789876543210 CE CB = FalseSym0 + TFHelper_0123456789876543210 CE CC = FalseSym0 + TFHelper_0123456789876543210 CE CD = FalseSym0 + TFHelper_0123456789876543210 CE CE = TrueSym0 + TFHelper_0123456789876543210 CE CF = FalseSym0 + TFHelper_0123456789876543210 CE CG = FalseSym0 + TFHelper_0123456789876543210 CE CH = FalseSym0 + TFHelper_0123456789876543210 CE CI = FalseSym0 + TFHelper_0123456789876543210 CE CJ = FalseSym0 + TFHelper_0123456789876543210 CE CK = FalseSym0 + TFHelper_0123456789876543210 CE CL = FalseSym0 + TFHelper_0123456789876543210 CE CM = FalseSym0 + TFHelper_0123456789876543210 CE CN = FalseSym0 + TFHelper_0123456789876543210 CE CO = FalseSym0 + TFHelper_0123456789876543210 CE CP = FalseSym0 + TFHelper_0123456789876543210 CE CQ = FalseSym0 + TFHelper_0123456789876543210 CE CR = FalseSym0 + TFHelper_0123456789876543210 CE CS = FalseSym0 + TFHelper_0123456789876543210 CE CT = FalseSym0 + TFHelper_0123456789876543210 CE CU = FalseSym0 + TFHelper_0123456789876543210 CE CV = FalseSym0 + TFHelper_0123456789876543210 CE CW = FalseSym0 + TFHelper_0123456789876543210 CE CX = FalseSym0 + TFHelper_0123456789876543210 CE CY = FalseSym0 + TFHelper_0123456789876543210 CE CZ = FalseSym0 + TFHelper_0123456789876543210 CF CA = FalseSym0 + TFHelper_0123456789876543210 CF CB = FalseSym0 + TFHelper_0123456789876543210 CF CC = FalseSym0 + TFHelper_0123456789876543210 CF CD = FalseSym0 + TFHelper_0123456789876543210 CF CE = FalseSym0 + TFHelper_0123456789876543210 CF CF = TrueSym0 + TFHelper_0123456789876543210 CF CG = FalseSym0 + TFHelper_0123456789876543210 CF CH = FalseSym0 + TFHelper_0123456789876543210 CF CI = FalseSym0 + TFHelper_0123456789876543210 CF CJ = FalseSym0 + TFHelper_0123456789876543210 CF CK = FalseSym0 + TFHelper_0123456789876543210 CF CL = FalseSym0 + TFHelper_0123456789876543210 CF CM = FalseSym0 + TFHelper_0123456789876543210 CF CN = FalseSym0 + TFHelper_0123456789876543210 CF CO = FalseSym0 + TFHelper_0123456789876543210 CF CP = FalseSym0 + TFHelper_0123456789876543210 CF CQ = FalseSym0 + TFHelper_0123456789876543210 CF CR = FalseSym0 + TFHelper_0123456789876543210 CF CS = FalseSym0 + TFHelper_0123456789876543210 CF CT = FalseSym0 + TFHelper_0123456789876543210 CF CU = FalseSym0 + TFHelper_0123456789876543210 CF CV = FalseSym0 + TFHelper_0123456789876543210 CF CW = FalseSym0 + TFHelper_0123456789876543210 CF CX = FalseSym0 + TFHelper_0123456789876543210 CF CY = FalseSym0 + TFHelper_0123456789876543210 CF CZ = FalseSym0 + TFHelper_0123456789876543210 CG CA = FalseSym0 + TFHelper_0123456789876543210 CG CB = FalseSym0 + TFHelper_0123456789876543210 CG CC = FalseSym0 + TFHelper_0123456789876543210 CG CD = FalseSym0 + TFHelper_0123456789876543210 CG CE = FalseSym0 + TFHelper_0123456789876543210 CG CF = FalseSym0 + TFHelper_0123456789876543210 CG CG = TrueSym0 + TFHelper_0123456789876543210 CG CH = FalseSym0 + TFHelper_0123456789876543210 CG CI = FalseSym0 + TFHelper_0123456789876543210 CG CJ = FalseSym0 + TFHelper_0123456789876543210 CG CK = FalseSym0 + TFHelper_0123456789876543210 CG CL = FalseSym0 + TFHelper_0123456789876543210 CG CM = FalseSym0 + TFHelper_0123456789876543210 CG CN = FalseSym0 + TFHelper_0123456789876543210 CG CO = FalseSym0 + TFHelper_0123456789876543210 CG CP = FalseSym0 + TFHelper_0123456789876543210 CG CQ = FalseSym0 + TFHelper_0123456789876543210 CG CR = FalseSym0 + TFHelper_0123456789876543210 CG CS = FalseSym0 + TFHelper_0123456789876543210 CG CT = FalseSym0 + TFHelper_0123456789876543210 CG CU = FalseSym0 + TFHelper_0123456789876543210 CG CV = FalseSym0 + TFHelper_0123456789876543210 CG CW = FalseSym0 + TFHelper_0123456789876543210 CG CX = FalseSym0 + TFHelper_0123456789876543210 CG CY = FalseSym0 + TFHelper_0123456789876543210 CG CZ = FalseSym0 + TFHelper_0123456789876543210 CH CA = FalseSym0 + TFHelper_0123456789876543210 CH CB = FalseSym0 + TFHelper_0123456789876543210 CH CC = FalseSym0 + TFHelper_0123456789876543210 CH CD = FalseSym0 + TFHelper_0123456789876543210 CH CE = FalseSym0 + TFHelper_0123456789876543210 CH CF = FalseSym0 + TFHelper_0123456789876543210 CH CG = FalseSym0 + TFHelper_0123456789876543210 CH CH = TrueSym0 + TFHelper_0123456789876543210 CH CI = FalseSym0 + TFHelper_0123456789876543210 CH CJ = FalseSym0 + TFHelper_0123456789876543210 CH CK = FalseSym0 + TFHelper_0123456789876543210 CH CL = FalseSym0 + TFHelper_0123456789876543210 CH CM = FalseSym0 + TFHelper_0123456789876543210 CH CN = FalseSym0 + TFHelper_0123456789876543210 CH CO = FalseSym0 + TFHelper_0123456789876543210 CH CP = FalseSym0 + TFHelper_0123456789876543210 CH CQ = FalseSym0 + TFHelper_0123456789876543210 CH CR = FalseSym0 + TFHelper_0123456789876543210 CH CS = FalseSym0 + TFHelper_0123456789876543210 CH CT = FalseSym0 + TFHelper_0123456789876543210 CH CU = FalseSym0 + TFHelper_0123456789876543210 CH CV = FalseSym0 + TFHelper_0123456789876543210 CH CW = FalseSym0 + TFHelper_0123456789876543210 CH CX = FalseSym0 + TFHelper_0123456789876543210 CH CY = FalseSym0 + TFHelper_0123456789876543210 CH CZ = FalseSym0 + TFHelper_0123456789876543210 CI CA = FalseSym0 + TFHelper_0123456789876543210 CI CB = FalseSym0 + TFHelper_0123456789876543210 CI CC = FalseSym0 + TFHelper_0123456789876543210 CI CD = FalseSym0 + TFHelper_0123456789876543210 CI CE = FalseSym0 + TFHelper_0123456789876543210 CI CF = FalseSym0 + TFHelper_0123456789876543210 CI CG = FalseSym0 + TFHelper_0123456789876543210 CI CH = FalseSym0 + TFHelper_0123456789876543210 CI CI = TrueSym0 + TFHelper_0123456789876543210 CI CJ = FalseSym0 + TFHelper_0123456789876543210 CI CK = FalseSym0 + TFHelper_0123456789876543210 CI CL = FalseSym0 + TFHelper_0123456789876543210 CI CM = FalseSym0 + TFHelper_0123456789876543210 CI CN = FalseSym0 + TFHelper_0123456789876543210 CI CO = FalseSym0 + TFHelper_0123456789876543210 CI CP = FalseSym0 + TFHelper_0123456789876543210 CI CQ = FalseSym0 + TFHelper_0123456789876543210 CI CR = FalseSym0 + TFHelper_0123456789876543210 CI CS = FalseSym0 + TFHelper_0123456789876543210 CI CT = FalseSym0 + TFHelper_0123456789876543210 CI CU = FalseSym0 + TFHelper_0123456789876543210 CI CV = FalseSym0 + TFHelper_0123456789876543210 CI CW = FalseSym0 + TFHelper_0123456789876543210 CI CX = FalseSym0 + TFHelper_0123456789876543210 CI CY = FalseSym0 + TFHelper_0123456789876543210 CI CZ = FalseSym0 + TFHelper_0123456789876543210 CJ CA = FalseSym0 + TFHelper_0123456789876543210 CJ CB = FalseSym0 + TFHelper_0123456789876543210 CJ CC = FalseSym0 + TFHelper_0123456789876543210 CJ CD = FalseSym0 + TFHelper_0123456789876543210 CJ CE = FalseSym0 + TFHelper_0123456789876543210 CJ CF = FalseSym0 + TFHelper_0123456789876543210 CJ CG = FalseSym0 + TFHelper_0123456789876543210 CJ CH = FalseSym0 + TFHelper_0123456789876543210 CJ CI = FalseSym0 + TFHelper_0123456789876543210 CJ CJ = TrueSym0 + TFHelper_0123456789876543210 CJ CK = FalseSym0 + TFHelper_0123456789876543210 CJ CL = FalseSym0 + TFHelper_0123456789876543210 CJ CM = FalseSym0 + TFHelper_0123456789876543210 CJ CN = FalseSym0 + TFHelper_0123456789876543210 CJ CO = FalseSym0 + TFHelper_0123456789876543210 CJ CP = FalseSym0 + TFHelper_0123456789876543210 CJ CQ = FalseSym0 + TFHelper_0123456789876543210 CJ CR = FalseSym0 + TFHelper_0123456789876543210 CJ CS = FalseSym0 + TFHelper_0123456789876543210 CJ CT = FalseSym0 + TFHelper_0123456789876543210 CJ CU = FalseSym0 + TFHelper_0123456789876543210 CJ CV = FalseSym0 + TFHelper_0123456789876543210 CJ CW = FalseSym0 + TFHelper_0123456789876543210 CJ CX = FalseSym0 + TFHelper_0123456789876543210 CJ CY = FalseSym0 + TFHelper_0123456789876543210 CJ CZ = FalseSym0 + TFHelper_0123456789876543210 CK CA = FalseSym0 + TFHelper_0123456789876543210 CK CB = FalseSym0 + TFHelper_0123456789876543210 CK CC = FalseSym0 + TFHelper_0123456789876543210 CK CD = FalseSym0 + TFHelper_0123456789876543210 CK CE = FalseSym0 + TFHelper_0123456789876543210 CK CF = FalseSym0 + TFHelper_0123456789876543210 CK CG = FalseSym0 + TFHelper_0123456789876543210 CK CH = FalseSym0 + TFHelper_0123456789876543210 CK CI = FalseSym0 + TFHelper_0123456789876543210 CK CJ = FalseSym0 + TFHelper_0123456789876543210 CK CK = TrueSym0 + TFHelper_0123456789876543210 CK CL = FalseSym0 + TFHelper_0123456789876543210 CK CM = FalseSym0 + TFHelper_0123456789876543210 CK CN = FalseSym0 + TFHelper_0123456789876543210 CK CO = FalseSym0 + TFHelper_0123456789876543210 CK CP = FalseSym0 + TFHelper_0123456789876543210 CK CQ = FalseSym0 + TFHelper_0123456789876543210 CK CR = FalseSym0 + TFHelper_0123456789876543210 CK CS = FalseSym0 + TFHelper_0123456789876543210 CK CT = FalseSym0 + TFHelper_0123456789876543210 CK CU = FalseSym0 + TFHelper_0123456789876543210 CK CV = FalseSym0 + TFHelper_0123456789876543210 CK CW = FalseSym0 + TFHelper_0123456789876543210 CK CX = FalseSym0 + TFHelper_0123456789876543210 CK CY = FalseSym0 + TFHelper_0123456789876543210 CK CZ = FalseSym0 + TFHelper_0123456789876543210 CL CA = FalseSym0 + TFHelper_0123456789876543210 CL CB = FalseSym0 + TFHelper_0123456789876543210 CL CC = FalseSym0 + TFHelper_0123456789876543210 CL CD = FalseSym0 + TFHelper_0123456789876543210 CL CE = FalseSym0 + TFHelper_0123456789876543210 CL CF = FalseSym0 + TFHelper_0123456789876543210 CL CG = FalseSym0 + TFHelper_0123456789876543210 CL CH = FalseSym0 + TFHelper_0123456789876543210 CL CI = FalseSym0 + TFHelper_0123456789876543210 CL CJ = FalseSym0 + TFHelper_0123456789876543210 CL CK = FalseSym0 + TFHelper_0123456789876543210 CL CL = TrueSym0 + TFHelper_0123456789876543210 CL CM = FalseSym0 + TFHelper_0123456789876543210 CL CN = FalseSym0 + TFHelper_0123456789876543210 CL CO = FalseSym0 + TFHelper_0123456789876543210 CL CP = FalseSym0 + TFHelper_0123456789876543210 CL CQ = FalseSym0 + TFHelper_0123456789876543210 CL CR = FalseSym0 + TFHelper_0123456789876543210 CL CS = FalseSym0 + TFHelper_0123456789876543210 CL CT = FalseSym0 + TFHelper_0123456789876543210 CL CU = FalseSym0 + TFHelper_0123456789876543210 CL CV = FalseSym0 + TFHelper_0123456789876543210 CL CW = FalseSym0 + TFHelper_0123456789876543210 CL CX = FalseSym0 + TFHelper_0123456789876543210 CL CY = FalseSym0 + TFHelper_0123456789876543210 CL CZ = FalseSym0 + TFHelper_0123456789876543210 CM CA = FalseSym0 + TFHelper_0123456789876543210 CM CB = FalseSym0 + TFHelper_0123456789876543210 CM CC = FalseSym0 + TFHelper_0123456789876543210 CM CD = FalseSym0 + TFHelper_0123456789876543210 CM CE = FalseSym0 + TFHelper_0123456789876543210 CM CF = FalseSym0 + TFHelper_0123456789876543210 CM CG = FalseSym0 + TFHelper_0123456789876543210 CM CH = FalseSym0 + TFHelper_0123456789876543210 CM CI = FalseSym0 + TFHelper_0123456789876543210 CM CJ = FalseSym0 + TFHelper_0123456789876543210 CM CK = FalseSym0 + TFHelper_0123456789876543210 CM CL = FalseSym0 + TFHelper_0123456789876543210 CM CM = TrueSym0 + TFHelper_0123456789876543210 CM CN = FalseSym0 + TFHelper_0123456789876543210 CM CO = FalseSym0 + TFHelper_0123456789876543210 CM CP = FalseSym0 + TFHelper_0123456789876543210 CM CQ = FalseSym0 + TFHelper_0123456789876543210 CM CR = FalseSym0 + TFHelper_0123456789876543210 CM CS = FalseSym0 + TFHelper_0123456789876543210 CM CT = FalseSym0 + TFHelper_0123456789876543210 CM CU = FalseSym0 + TFHelper_0123456789876543210 CM CV = FalseSym0 + TFHelper_0123456789876543210 CM CW = FalseSym0 + TFHelper_0123456789876543210 CM CX = FalseSym0 + TFHelper_0123456789876543210 CM CY = FalseSym0 + TFHelper_0123456789876543210 CM CZ = FalseSym0 + TFHelper_0123456789876543210 CN CA = FalseSym0 + TFHelper_0123456789876543210 CN CB = FalseSym0 + TFHelper_0123456789876543210 CN CC = FalseSym0 + TFHelper_0123456789876543210 CN CD = FalseSym0 + TFHelper_0123456789876543210 CN CE = FalseSym0 + TFHelper_0123456789876543210 CN CF = FalseSym0 + TFHelper_0123456789876543210 CN CG = FalseSym0 + TFHelper_0123456789876543210 CN CH = FalseSym0 + TFHelper_0123456789876543210 CN CI = FalseSym0 + TFHelper_0123456789876543210 CN CJ = FalseSym0 + TFHelper_0123456789876543210 CN CK = FalseSym0 + TFHelper_0123456789876543210 CN CL = FalseSym0 + TFHelper_0123456789876543210 CN CM = FalseSym0 + TFHelper_0123456789876543210 CN CN = TrueSym0 + TFHelper_0123456789876543210 CN CO = FalseSym0 + TFHelper_0123456789876543210 CN CP = FalseSym0 + TFHelper_0123456789876543210 CN CQ = FalseSym0 + TFHelper_0123456789876543210 CN CR = FalseSym0 + TFHelper_0123456789876543210 CN CS = FalseSym0 + TFHelper_0123456789876543210 CN CT = FalseSym0 + TFHelper_0123456789876543210 CN CU = FalseSym0 + TFHelper_0123456789876543210 CN CV = FalseSym0 + TFHelper_0123456789876543210 CN CW = FalseSym0 + TFHelper_0123456789876543210 CN CX = FalseSym0 + TFHelper_0123456789876543210 CN CY = FalseSym0 + TFHelper_0123456789876543210 CN CZ = FalseSym0 + TFHelper_0123456789876543210 CO CA = FalseSym0 + TFHelper_0123456789876543210 CO CB = FalseSym0 + TFHelper_0123456789876543210 CO CC = FalseSym0 + TFHelper_0123456789876543210 CO CD = FalseSym0 + TFHelper_0123456789876543210 CO CE = FalseSym0 + TFHelper_0123456789876543210 CO CF = FalseSym0 + TFHelper_0123456789876543210 CO CG = FalseSym0 + TFHelper_0123456789876543210 CO CH = FalseSym0 + TFHelper_0123456789876543210 CO CI = FalseSym0 + TFHelper_0123456789876543210 CO CJ = FalseSym0 + TFHelper_0123456789876543210 CO CK = FalseSym0 + TFHelper_0123456789876543210 CO CL = FalseSym0 + TFHelper_0123456789876543210 CO CM = FalseSym0 + TFHelper_0123456789876543210 CO CN = FalseSym0 + TFHelper_0123456789876543210 CO CO = TrueSym0 + TFHelper_0123456789876543210 CO CP = FalseSym0 + TFHelper_0123456789876543210 CO CQ = FalseSym0 + TFHelper_0123456789876543210 CO CR = FalseSym0 + TFHelper_0123456789876543210 CO CS = FalseSym0 + TFHelper_0123456789876543210 CO CT = FalseSym0 + TFHelper_0123456789876543210 CO CU = FalseSym0 + TFHelper_0123456789876543210 CO CV = FalseSym0 + TFHelper_0123456789876543210 CO CW = FalseSym0 + TFHelper_0123456789876543210 CO CX = FalseSym0 + TFHelper_0123456789876543210 CO CY = FalseSym0 + TFHelper_0123456789876543210 CO CZ = FalseSym0 + TFHelper_0123456789876543210 CP CA = FalseSym0 + TFHelper_0123456789876543210 CP CB = FalseSym0 + TFHelper_0123456789876543210 CP CC = FalseSym0 + TFHelper_0123456789876543210 CP CD = FalseSym0 + TFHelper_0123456789876543210 CP CE = FalseSym0 + TFHelper_0123456789876543210 CP CF = FalseSym0 + TFHelper_0123456789876543210 CP CG = FalseSym0 + TFHelper_0123456789876543210 CP CH = FalseSym0 + TFHelper_0123456789876543210 CP CI = FalseSym0 + TFHelper_0123456789876543210 CP CJ = FalseSym0 + TFHelper_0123456789876543210 CP CK = FalseSym0 + TFHelper_0123456789876543210 CP CL = FalseSym0 + TFHelper_0123456789876543210 CP CM = FalseSym0 + TFHelper_0123456789876543210 CP CN = FalseSym0 + TFHelper_0123456789876543210 CP CO = FalseSym0 + TFHelper_0123456789876543210 CP CP = TrueSym0 + TFHelper_0123456789876543210 CP CQ = FalseSym0 + TFHelper_0123456789876543210 CP CR = FalseSym0 + TFHelper_0123456789876543210 CP CS = FalseSym0 + TFHelper_0123456789876543210 CP CT = FalseSym0 + TFHelper_0123456789876543210 CP CU = FalseSym0 + TFHelper_0123456789876543210 CP CV = FalseSym0 + TFHelper_0123456789876543210 CP CW = FalseSym0 + TFHelper_0123456789876543210 CP CX = FalseSym0 + TFHelper_0123456789876543210 CP CY = FalseSym0 + TFHelper_0123456789876543210 CP CZ = FalseSym0 + TFHelper_0123456789876543210 CQ CA = FalseSym0 + TFHelper_0123456789876543210 CQ CB = FalseSym0 + TFHelper_0123456789876543210 CQ CC = FalseSym0 + TFHelper_0123456789876543210 CQ CD = FalseSym0 + TFHelper_0123456789876543210 CQ CE = FalseSym0 + TFHelper_0123456789876543210 CQ CF = FalseSym0 + TFHelper_0123456789876543210 CQ CG = FalseSym0 + TFHelper_0123456789876543210 CQ CH = FalseSym0 + TFHelper_0123456789876543210 CQ CI = FalseSym0 + TFHelper_0123456789876543210 CQ CJ = FalseSym0 + TFHelper_0123456789876543210 CQ CK = FalseSym0 + TFHelper_0123456789876543210 CQ CL = FalseSym0 + TFHelper_0123456789876543210 CQ CM = FalseSym0 + TFHelper_0123456789876543210 CQ CN = FalseSym0 + TFHelper_0123456789876543210 CQ CO = FalseSym0 + TFHelper_0123456789876543210 CQ CP = FalseSym0 + TFHelper_0123456789876543210 CQ CQ = TrueSym0 + TFHelper_0123456789876543210 CQ CR = FalseSym0 + TFHelper_0123456789876543210 CQ CS = FalseSym0 + TFHelper_0123456789876543210 CQ CT = FalseSym0 + TFHelper_0123456789876543210 CQ CU = FalseSym0 + TFHelper_0123456789876543210 CQ CV = FalseSym0 + TFHelper_0123456789876543210 CQ CW = FalseSym0 + TFHelper_0123456789876543210 CQ CX = FalseSym0 + TFHelper_0123456789876543210 CQ CY = FalseSym0 + TFHelper_0123456789876543210 CQ CZ = FalseSym0 + TFHelper_0123456789876543210 CR CA = FalseSym0 + TFHelper_0123456789876543210 CR CB = FalseSym0 + TFHelper_0123456789876543210 CR CC = FalseSym0 + TFHelper_0123456789876543210 CR CD = FalseSym0 + TFHelper_0123456789876543210 CR CE = FalseSym0 + TFHelper_0123456789876543210 CR CF = FalseSym0 + TFHelper_0123456789876543210 CR CG = FalseSym0 + TFHelper_0123456789876543210 CR CH = FalseSym0 + TFHelper_0123456789876543210 CR CI = FalseSym0 + TFHelper_0123456789876543210 CR CJ = FalseSym0 + TFHelper_0123456789876543210 CR CK = FalseSym0 + TFHelper_0123456789876543210 CR CL = FalseSym0 + TFHelper_0123456789876543210 CR CM = FalseSym0 + TFHelper_0123456789876543210 CR CN = FalseSym0 + TFHelper_0123456789876543210 CR CO = FalseSym0 + TFHelper_0123456789876543210 CR CP = FalseSym0 + TFHelper_0123456789876543210 CR CQ = FalseSym0 + TFHelper_0123456789876543210 CR CR = TrueSym0 + TFHelper_0123456789876543210 CR CS = FalseSym0 + TFHelper_0123456789876543210 CR CT = FalseSym0 + TFHelper_0123456789876543210 CR CU = FalseSym0 + TFHelper_0123456789876543210 CR CV = FalseSym0 + TFHelper_0123456789876543210 CR CW = FalseSym0 + TFHelper_0123456789876543210 CR CX = FalseSym0 + TFHelper_0123456789876543210 CR CY = FalseSym0 + TFHelper_0123456789876543210 CR CZ = FalseSym0 + TFHelper_0123456789876543210 CS CA = FalseSym0 + TFHelper_0123456789876543210 CS CB = FalseSym0 + TFHelper_0123456789876543210 CS CC = FalseSym0 + TFHelper_0123456789876543210 CS CD = FalseSym0 + TFHelper_0123456789876543210 CS CE = FalseSym0 + TFHelper_0123456789876543210 CS CF = FalseSym0 + TFHelper_0123456789876543210 CS CG = FalseSym0 + TFHelper_0123456789876543210 CS CH = FalseSym0 + TFHelper_0123456789876543210 CS CI = FalseSym0 + TFHelper_0123456789876543210 CS CJ = FalseSym0 + TFHelper_0123456789876543210 CS CK = FalseSym0 + TFHelper_0123456789876543210 CS CL = FalseSym0 + TFHelper_0123456789876543210 CS CM = FalseSym0 + TFHelper_0123456789876543210 CS CN = FalseSym0 + TFHelper_0123456789876543210 CS CO = FalseSym0 + TFHelper_0123456789876543210 CS CP = FalseSym0 + TFHelper_0123456789876543210 CS CQ = FalseSym0 + TFHelper_0123456789876543210 CS CR = FalseSym0 + TFHelper_0123456789876543210 CS CS = TrueSym0 + TFHelper_0123456789876543210 CS CT = FalseSym0 + TFHelper_0123456789876543210 CS CU = FalseSym0 + TFHelper_0123456789876543210 CS CV = FalseSym0 + TFHelper_0123456789876543210 CS CW = FalseSym0 + TFHelper_0123456789876543210 CS CX = FalseSym0 + TFHelper_0123456789876543210 CS CY = FalseSym0 + TFHelper_0123456789876543210 CS CZ = FalseSym0 + TFHelper_0123456789876543210 CT CA = FalseSym0 + TFHelper_0123456789876543210 CT CB = FalseSym0 + TFHelper_0123456789876543210 CT CC = FalseSym0 + TFHelper_0123456789876543210 CT CD = FalseSym0 + TFHelper_0123456789876543210 CT CE = FalseSym0 + TFHelper_0123456789876543210 CT CF = FalseSym0 + TFHelper_0123456789876543210 CT CG = FalseSym0 + TFHelper_0123456789876543210 CT CH = FalseSym0 + TFHelper_0123456789876543210 CT CI = FalseSym0 + TFHelper_0123456789876543210 CT CJ = FalseSym0 + TFHelper_0123456789876543210 CT CK = FalseSym0 + TFHelper_0123456789876543210 CT CL = FalseSym0 + TFHelper_0123456789876543210 CT CM = FalseSym0 + TFHelper_0123456789876543210 CT CN = FalseSym0 + TFHelper_0123456789876543210 CT CO = FalseSym0 + TFHelper_0123456789876543210 CT CP = FalseSym0 + TFHelper_0123456789876543210 CT CQ = FalseSym0 + TFHelper_0123456789876543210 CT CR = FalseSym0 + TFHelper_0123456789876543210 CT CS = FalseSym0 + TFHelper_0123456789876543210 CT CT = TrueSym0 + TFHelper_0123456789876543210 CT CU = FalseSym0 + TFHelper_0123456789876543210 CT CV = FalseSym0 + TFHelper_0123456789876543210 CT CW = FalseSym0 + TFHelper_0123456789876543210 CT CX = FalseSym0 + TFHelper_0123456789876543210 CT CY = FalseSym0 + TFHelper_0123456789876543210 CT CZ = FalseSym0 + TFHelper_0123456789876543210 CU CA = FalseSym0 + TFHelper_0123456789876543210 CU CB = FalseSym0 + TFHelper_0123456789876543210 CU CC = FalseSym0 + TFHelper_0123456789876543210 CU CD = FalseSym0 + TFHelper_0123456789876543210 CU CE = FalseSym0 + TFHelper_0123456789876543210 CU CF = FalseSym0 + TFHelper_0123456789876543210 CU CG = FalseSym0 + TFHelper_0123456789876543210 CU CH = FalseSym0 + TFHelper_0123456789876543210 CU CI = FalseSym0 + TFHelper_0123456789876543210 CU CJ = FalseSym0 + TFHelper_0123456789876543210 CU CK = FalseSym0 + TFHelper_0123456789876543210 CU CL = FalseSym0 + TFHelper_0123456789876543210 CU CM = FalseSym0 + TFHelper_0123456789876543210 CU CN = FalseSym0 + TFHelper_0123456789876543210 CU CO = FalseSym0 + TFHelper_0123456789876543210 CU CP = FalseSym0 + TFHelper_0123456789876543210 CU CQ = FalseSym0 + TFHelper_0123456789876543210 CU CR = FalseSym0 + TFHelper_0123456789876543210 CU CS = FalseSym0 + TFHelper_0123456789876543210 CU CT = FalseSym0 + TFHelper_0123456789876543210 CU CU = TrueSym0 + TFHelper_0123456789876543210 CU CV = FalseSym0 + TFHelper_0123456789876543210 CU CW = FalseSym0 + TFHelper_0123456789876543210 CU CX = FalseSym0 + TFHelper_0123456789876543210 CU CY = FalseSym0 + TFHelper_0123456789876543210 CU CZ = FalseSym0 + TFHelper_0123456789876543210 CV CA = FalseSym0 + TFHelper_0123456789876543210 CV CB = FalseSym0 + TFHelper_0123456789876543210 CV CC = FalseSym0 + TFHelper_0123456789876543210 CV CD = FalseSym0 + TFHelper_0123456789876543210 CV CE = FalseSym0 + TFHelper_0123456789876543210 CV CF = FalseSym0 + TFHelper_0123456789876543210 CV CG = FalseSym0 + TFHelper_0123456789876543210 CV CH = FalseSym0 + TFHelper_0123456789876543210 CV CI = FalseSym0 + TFHelper_0123456789876543210 CV CJ = FalseSym0 + TFHelper_0123456789876543210 CV CK = FalseSym0 + TFHelper_0123456789876543210 CV CL = FalseSym0 + TFHelper_0123456789876543210 CV CM = FalseSym0 + TFHelper_0123456789876543210 CV CN = FalseSym0 + TFHelper_0123456789876543210 CV CO = FalseSym0 + TFHelper_0123456789876543210 CV CP = FalseSym0 + TFHelper_0123456789876543210 CV CQ = FalseSym0 + TFHelper_0123456789876543210 CV CR = FalseSym0 + TFHelper_0123456789876543210 CV CS = FalseSym0 + TFHelper_0123456789876543210 CV CT = FalseSym0 + TFHelper_0123456789876543210 CV CU = FalseSym0 + TFHelper_0123456789876543210 CV CV = TrueSym0 + TFHelper_0123456789876543210 CV CW = FalseSym0 + TFHelper_0123456789876543210 CV CX = FalseSym0 + TFHelper_0123456789876543210 CV CY = FalseSym0 + TFHelper_0123456789876543210 CV CZ = FalseSym0 + TFHelper_0123456789876543210 CW CA = FalseSym0 + TFHelper_0123456789876543210 CW CB = FalseSym0 + TFHelper_0123456789876543210 CW CC = FalseSym0 + TFHelper_0123456789876543210 CW CD = FalseSym0 + TFHelper_0123456789876543210 CW CE = FalseSym0 + TFHelper_0123456789876543210 CW CF = FalseSym0 + TFHelper_0123456789876543210 CW CG = FalseSym0 + TFHelper_0123456789876543210 CW CH = FalseSym0 + TFHelper_0123456789876543210 CW CI = FalseSym0 + TFHelper_0123456789876543210 CW CJ = FalseSym0 + TFHelper_0123456789876543210 CW CK = FalseSym0 + TFHelper_0123456789876543210 CW CL = FalseSym0 + TFHelper_0123456789876543210 CW CM = FalseSym0 + TFHelper_0123456789876543210 CW CN = FalseSym0 + TFHelper_0123456789876543210 CW CO = FalseSym0 + TFHelper_0123456789876543210 CW CP = FalseSym0 + TFHelper_0123456789876543210 CW CQ = FalseSym0 + TFHelper_0123456789876543210 CW CR = FalseSym0 + TFHelper_0123456789876543210 CW CS = FalseSym0 + TFHelper_0123456789876543210 CW CT = FalseSym0 + TFHelper_0123456789876543210 CW CU = FalseSym0 + TFHelper_0123456789876543210 CW CV = FalseSym0 + TFHelper_0123456789876543210 CW CW = TrueSym0 + TFHelper_0123456789876543210 CW CX = FalseSym0 + TFHelper_0123456789876543210 CW CY = FalseSym0 + TFHelper_0123456789876543210 CW CZ = FalseSym0 + TFHelper_0123456789876543210 CX CA = FalseSym0 + TFHelper_0123456789876543210 CX CB = FalseSym0 + TFHelper_0123456789876543210 CX CC = FalseSym0 + TFHelper_0123456789876543210 CX CD = FalseSym0 + TFHelper_0123456789876543210 CX CE = FalseSym0 + TFHelper_0123456789876543210 CX CF = FalseSym0 + TFHelper_0123456789876543210 CX CG = FalseSym0 + TFHelper_0123456789876543210 CX CH = FalseSym0 + TFHelper_0123456789876543210 CX CI = FalseSym0 + TFHelper_0123456789876543210 CX CJ = FalseSym0 + TFHelper_0123456789876543210 CX CK = FalseSym0 + TFHelper_0123456789876543210 CX CL = FalseSym0 + TFHelper_0123456789876543210 CX CM = FalseSym0 + TFHelper_0123456789876543210 CX CN = FalseSym0 + TFHelper_0123456789876543210 CX CO = FalseSym0 + TFHelper_0123456789876543210 CX CP = FalseSym0 + TFHelper_0123456789876543210 CX CQ = FalseSym0 + TFHelper_0123456789876543210 CX CR = FalseSym0 + TFHelper_0123456789876543210 CX CS = FalseSym0 + TFHelper_0123456789876543210 CX CT = FalseSym0 + TFHelper_0123456789876543210 CX CU = FalseSym0 + TFHelper_0123456789876543210 CX CV = FalseSym0 + TFHelper_0123456789876543210 CX CW = FalseSym0 + TFHelper_0123456789876543210 CX CX = TrueSym0 + TFHelper_0123456789876543210 CX CY = FalseSym0 + TFHelper_0123456789876543210 CX CZ = FalseSym0 + TFHelper_0123456789876543210 CY CA = FalseSym0 + TFHelper_0123456789876543210 CY CB = FalseSym0 + TFHelper_0123456789876543210 CY CC = FalseSym0 + TFHelper_0123456789876543210 CY CD = FalseSym0 + TFHelper_0123456789876543210 CY CE = FalseSym0 + TFHelper_0123456789876543210 CY CF = FalseSym0 + TFHelper_0123456789876543210 CY CG = FalseSym0 + TFHelper_0123456789876543210 CY CH = FalseSym0 + TFHelper_0123456789876543210 CY CI = FalseSym0 + TFHelper_0123456789876543210 CY CJ = FalseSym0 + TFHelper_0123456789876543210 CY CK = FalseSym0 + TFHelper_0123456789876543210 CY CL = FalseSym0 + TFHelper_0123456789876543210 CY CM = FalseSym0 + TFHelper_0123456789876543210 CY CN = FalseSym0 + TFHelper_0123456789876543210 CY CO = FalseSym0 + TFHelper_0123456789876543210 CY CP = FalseSym0 + TFHelper_0123456789876543210 CY CQ = FalseSym0 + TFHelper_0123456789876543210 CY CR = FalseSym0 + TFHelper_0123456789876543210 CY CS = FalseSym0 + TFHelper_0123456789876543210 CY CT = FalseSym0 + TFHelper_0123456789876543210 CY CU = FalseSym0 + TFHelper_0123456789876543210 CY CV = FalseSym0 + TFHelper_0123456789876543210 CY CW = FalseSym0 + TFHelper_0123456789876543210 CY CX = FalseSym0 + TFHelper_0123456789876543210 CY CY = TrueSym0 + TFHelper_0123456789876543210 CY CZ = FalseSym0 + TFHelper_0123456789876543210 CZ CA = FalseSym0 + TFHelper_0123456789876543210 CZ CB = FalseSym0 + TFHelper_0123456789876543210 CZ CC = FalseSym0 + TFHelper_0123456789876543210 CZ CD = FalseSym0 + TFHelper_0123456789876543210 CZ CE = FalseSym0 + TFHelper_0123456789876543210 CZ CF = FalseSym0 + TFHelper_0123456789876543210 CZ CG = FalseSym0 + TFHelper_0123456789876543210 CZ CH = FalseSym0 + TFHelper_0123456789876543210 CZ CI = FalseSym0 + TFHelper_0123456789876543210 CZ CJ = FalseSym0 + TFHelper_0123456789876543210 CZ CK = FalseSym0 + TFHelper_0123456789876543210 CZ CL = FalseSym0 + TFHelper_0123456789876543210 CZ CM = FalseSym0 + TFHelper_0123456789876543210 CZ CN = FalseSym0 + TFHelper_0123456789876543210 CZ CO = FalseSym0 + TFHelper_0123456789876543210 CZ CP = FalseSym0 + TFHelper_0123456789876543210 CZ CQ = FalseSym0 + TFHelper_0123456789876543210 CZ CR = FalseSym0 + TFHelper_0123456789876543210 CZ CS = FalseSym0 + TFHelper_0123456789876543210 CZ CT = FalseSym0 + TFHelper_0123456789876543210 CZ CU = FalseSym0 + TFHelper_0123456789876543210 CZ CV = FalseSym0 + TFHelper_0123456789876543210 CZ CW = FalseSym0 + TFHelper_0123456789876543210 CZ CX = FalseSym0 + TFHelper_0123456789876543210 CZ CY = FalseSym0 + TFHelper_0123456789876543210 CZ CZ = TrueSym0 + type TFHelper_0123456789876543210Sym0 :: (~>) AChar ((~>) AChar Bool) + data TFHelper_0123456789876543210Sym0 :: (~>) AChar ((~>) AChar Bool) + where + TFHelper_0123456789876543210Sym0KindInference :: SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) => + TFHelper_0123456789876543210Sym0 a0123456789876543210 + type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210 + instance SuppressUnusedWarnings TFHelper_0123456789876543210Sym0 where + suppressUnusedWarnings + = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ()) + type TFHelper_0123456789876543210Sym1 :: AChar -> (~>) AChar Bool + data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: AChar) :: (~>) AChar Bool + where + TFHelper_0123456789876543210Sym1KindInference :: SameKind (Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) arg) (TFHelper_0123456789876543210Sym2 a0123456789876543210 arg) => + TFHelper_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 + type instance Apply (TFHelper_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where + suppressUnusedWarnings + = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ()) + type TFHelper_0123456789876543210Sym2 :: AChar -> AChar -> Bool + type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: AChar) (a0123456789876543210 :: AChar) :: Bool where + TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 + instance PEq AChar where + type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a + sLookup :: + forall (t :: [AChar]) (t :: Schema). Sing t + -> Sing t -> Sing (Apply (Apply LookupSym0 t) t :: U) + sOccurs :: + forall (t :: [AChar]) (t :: Schema). Sing t + -> Sing t -> Sing (Apply (Apply OccursSym0 t) t :: Bool) + sDisjoint :: + forall (t :: Schema) (t :: Schema). Sing t + -> Sing t -> Sing (Apply (Apply DisjointSym0 t) t :: Bool) + sAttrNotIn :: + forall (t :: Attribute) (t :: Schema). Sing t + -> Sing t + -> Sing (Apply (Apply AttrNotInSym0 t) t :: Bool) + sAppend :: + forall (t :: Schema) (t :: Schema). Sing t + -> Sing t -> Sing (Apply (Apply AppendSym0 t) t :: Schema) + sLookup _ (SSch SNil) = sUndefined + sLookup + (sName :: Sing name) + (SSch (SCons (SAttr (sName' :: Sing name') (sU :: Sing u)) + (sAttrs :: Sing attrs))) + = let + sScrutinee_0123456789876543210 :: + Sing @_ (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name name' u attrs) + sScrutinee_0123456789876543210 + = (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sName)) + sName' + in + (GHC.Base.id + @(Sing (Case_0123456789876543210 name name' u attrs (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name name' u attrs) :: U))) + (case sScrutinee_0123456789876543210 of + STrue -> sU + SFalse + -> (applySing ((applySing ((singFun2 @LookupSym0) sLookup)) sName)) + ((applySing ((singFun1 @SchSym0) SSch)) sAttrs)) + sOccurs _ (SSch SNil) = SFalse + sOccurs + (sName :: Sing name) + (SSch (SCons (SAttr (sName' :: Sing name') _) + (sAttrs :: Sing attrs))) + = (applySing + ((applySing ((singFun2 @(||@#@$)) (%||))) + ((applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sName)) + sName'))) + ((applySing ((applySing ((singFun2 @OccursSym0) sOccurs)) sName)) + ((applySing ((singFun1 @SchSym0) SSch)) sAttrs)) + sDisjoint (SSch SNil) _ = STrue + sDisjoint + (SSch (SCons (sH :: Sing h) (sT :: Sing t))) + (sS :: Sing s) + = (applySing + ((applySing ((singFun2 @(&&@#@$)) (%&&))) + ((applySing + ((applySing ((singFun2 @AttrNotInSym0) sAttrNotIn)) sH)) + sS))) + ((applySing + ((applySing ((singFun2 @DisjointSym0) sDisjoint)) + ((applySing ((singFun1 @SchSym0) SSch)) sT))) + sS) + sAttrNotIn _ (SSch SNil) = STrue + sAttrNotIn + (SAttr (sName :: Sing name) (sU :: Sing u)) + (SSch (SCons (SAttr (sName' :: Sing name') _) (sT :: Sing t))) + = (applySing + ((applySing ((singFun2 @(&&@#@$)) (%&&))) + ((applySing ((applySing ((singFun2 @(/=@#@$)) (%/=))) sName)) + sName'))) + ((applySing + ((applySing ((singFun2 @AttrNotInSym0) sAttrNotIn)) + ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sName)) sU))) + ((applySing ((singFun1 @SchSym0) SSch)) sT)) + sAppend (SSch (sS1 :: Sing s1)) (SSch (sS2 :: Sing s2)) + = (applySing ((singFun1 @SchSym0) SSch)) + ((applySing ((applySing ((singFun2 @(++@#@$)) (%++))) sS1)) sS2) + instance SingI (LookupSym0 :: (~>) [AChar] ((~>) Schema U)) where + sing = (singFun2 @LookupSym0) sLookup + instance SingI d => + SingI (LookupSym1 (d :: [AChar]) :: (~>) Schema U) where + sing = (singFun1 @(LookupSym1 (d :: [AChar]))) (sLookup (sing @d)) + instance SingI1 (LookupSym1 :: [AChar] -> (~>) Schema U) where + liftSing (s :: Sing (d :: [AChar])) + = (singFun1 @(LookupSym1 (d :: [AChar]))) (sLookup s) + instance SingI (OccursSym0 :: (~>) [AChar] ((~>) Schema Bool)) where + sing = (singFun2 @OccursSym0) sOccurs + instance SingI d => + SingI (OccursSym1 (d :: [AChar]) :: (~>) Schema Bool) where + sing = (singFun1 @(OccursSym1 (d :: [AChar]))) (sOccurs (sing @d)) + instance SingI1 (OccursSym1 :: [AChar] -> (~>) Schema Bool) where + liftSing (s :: Sing (d :: [AChar])) + = (singFun1 @(OccursSym1 (d :: [AChar]))) (sOccurs s) + instance SingI (DisjointSym0 :: (~>) Schema ((~>) Schema Bool)) where + sing = (singFun2 @DisjointSym0) sDisjoint + instance SingI d => + SingI (DisjointSym1 (d :: Schema) :: (~>) Schema Bool) where + sing + = (singFun1 @(DisjointSym1 (d :: Schema))) (sDisjoint (sing @d)) + instance SingI1 (DisjointSym1 :: Schema -> (~>) Schema Bool) where + liftSing (s :: Sing (d :: Schema)) + = (singFun1 @(DisjointSym1 (d :: Schema))) (sDisjoint s) + instance SingI (AttrNotInSym0 :: (~>) Attribute ((~>) Schema Bool)) where + sing = (singFun2 @AttrNotInSym0) sAttrNotIn + instance SingI d => + SingI (AttrNotInSym1 (d :: Attribute) :: (~>) Schema Bool) where + sing + = (singFun1 @(AttrNotInSym1 (d :: Attribute))) + (sAttrNotIn (sing @d)) + instance SingI1 (AttrNotInSym1 :: Attribute + -> (~>) Schema Bool) where + liftSing (s :: Sing (d :: Attribute)) + = (singFun1 @(AttrNotInSym1 (d :: Attribute))) (sAttrNotIn s) + instance SingI (AppendSym0 :: (~>) Schema ((~>) Schema Schema)) where + sing = (singFun2 @AppendSym0) sAppend + instance SingI d => + SingI (AppendSym1 (d :: Schema) :: (~>) Schema Schema) where + sing = (singFun1 @(AppendSym1 (d :: Schema))) (sAppend (sing @d)) + instance SingI1 (AppendSym1 :: Schema -> (~>) Schema Schema) where + liftSing (s :: Sing (d :: Schema)) + = (singFun1 @(AppendSym1 (d :: Schema))) (sAppend s) + data SU :: U -> Type + where + SBOOL :: SU (BOOL :: U) + SSTRING :: SU (STRING :: U) + SNAT :: SU (NAT :: U) + SVEC :: forall (n :: U) (n :: Nat). + (Sing n) -> (Sing n) -> SU (VEC n n :: U) + type instance Sing @U = SU + instance SingKind U where + type Demote U = U + fromSing SBOOL = BOOL + fromSing SSTRING = STRING + fromSing SNAT = NAT + fromSing (SVEC b b) = (VEC (fromSing b)) (fromSing b) + toSing BOOL = SomeSing SBOOL + toSing STRING = SomeSing SSTRING + toSing NAT = SomeSing SNAT + toSing (VEC (b :: Demote U) (b :: Demote Nat)) + = case ((,) (toSing b :: SomeSing U)) (toSing b :: SomeSing Nat) of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SVEC c) c) + data SAChar :: AChar -> Type + where + SCA :: SAChar (CA :: AChar) + SCB :: SAChar (CB :: AChar) + SCC :: SAChar (CC :: AChar) + SCD :: SAChar (CD :: AChar) + SCE :: SAChar (CE :: AChar) + SCF :: SAChar (CF :: AChar) + SCG :: SAChar (CG :: AChar) + SCH :: SAChar (CH :: AChar) + SCI :: SAChar (CI :: AChar) + SCJ :: SAChar (CJ :: AChar) + SCK :: SAChar (CK :: AChar) + SCL :: SAChar (CL :: AChar) + SCM :: SAChar (CM :: AChar) + SCN :: SAChar (CN :: AChar) + SCO :: SAChar (CO :: AChar) + SCP :: SAChar (CP :: AChar) + SCQ :: SAChar (CQ :: AChar) + SCR :: SAChar (CR :: AChar) + SCS :: SAChar (CS :: AChar) + SCT :: SAChar (CT :: AChar) + SCU :: SAChar (CU :: AChar) + SCV :: SAChar (CV :: AChar) + SCW :: SAChar (CW :: AChar) + SCX :: SAChar (CX :: AChar) + SCY :: SAChar (CY :: AChar) + SCZ :: SAChar (CZ :: AChar) + type instance Sing @AChar = SAChar + instance SingKind AChar where + type Demote AChar = AChar + fromSing SCA = CA + fromSing SCB = CB + fromSing SCC = CC + fromSing SCD = CD + fromSing SCE = CE + fromSing SCF = CF + fromSing SCG = CG + fromSing SCH = CH + fromSing SCI = CI + fromSing SCJ = CJ + fromSing SCK = CK + fromSing SCL = CL + fromSing SCM = CM + fromSing SCN = CN + fromSing SCO = CO + fromSing SCP = CP + fromSing SCQ = CQ + fromSing SCR = CR + fromSing SCS = CS + fromSing SCT = CT + fromSing SCU = CU + fromSing SCV = CV + fromSing SCW = CW + fromSing SCX = CX + fromSing SCY = CY + fromSing SCZ = CZ + toSing CA = SomeSing SCA + toSing CB = SomeSing SCB + toSing CC = SomeSing SCC + toSing CD = SomeSing SCD + toSing CE = SomeSing SCE + toSing CF = SomeSing SCF + toSing CG = SomeSing SCG + toSing CH = SomeSing SCH + toSing CI = SomeSing SCI + toSing CJ = SomeSing SCJ + toSing CK = SomeSing SCK + toSing CL = SomeSing SCL + toSing CM = SomeSing SCM + toSing CN = SomeSing SCN + toSing CO = SomeSing SCO + toSing CP = SomeSing SCP + toSing CQ = SomeSing SCQ + toSing CR = SomeSing SCR + toSing CS = SomeSing SCS + toSing CT = SomeSing SCT + toSing CU = SomeSing SCU + toSing CV = SomeSing SCV + toSing CW = SomeSing SCW + toSing CX = SomeSing SCX + toSing CY = SomeSing SCY + toSing CZ = SomeSing SCZ + data SAttribute :: Attribute -> Type + where + SAttr :: forall (n :: [AChar]) (n :: U). + (Sing n) -> (Sing n) -> SAttribute (Attr n n :: Attribute) + type instance Sing @Attribute = SAttribute + instance SingKind Attribute where + type Demote Attribute = Attribute + fromSing (SAttr b b) = (Attr (fromSing b)) (fromSing b) + toSing (Attr (b :: Demote [AChar]) (b :: Demote U)) + = case + ((,) (toSing b :: SomeSing [AChar])) (toSing b :: SomeSing U) + of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SAttr c) c) + data SSchema :: Schema -> Type + where + SSch :: forall (n :: [Attribute]). + (Sing n) -> SSchema (Sch n :: Schema) + type instance Sing @Schema = SSchema + instance SingKind Schema where + type Demote Schema = Schema + fromSing (SSch b) = Sch (fromSing b) + toSing (Sch (b :: Demote [Attribute])) + = case toSing b :: SomeSing [Attribute] of + SomeSing c -> SomeSing (SSch c) + instance (SEq U, SEq Nat) => SEq U where + (%==) :: + forall (t1 :: U) (t2 :: U). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun U ((~>) U Bool) + -> Type) t1) t2) + (%==) SBOOL SBOOL = STrue + (%==) SBOOL SSTRING = SFalse + (%==) SBOOL SNAT = SFalse + (%==) SBOOL (SVEC _ _) = SFalse + (%==) SSTRING SBOOL = SFalse + (%==) SSTRING SSTRING = STrue + (%==) SSTRING SNAT = SFalse + (%==) SSTRING (SVEC _ _) = SFalse + (%==) SNAT SBOOL = SFalse + (%==) SNAT SSTRING = SFalse + (%==) SNAT SNAT = STrue + (%==) SNAT (SVEC _ _) = SFalse + (%==) (SVEC _ _) SBOOL = SFalse + (%==) (SVEC _ _) SSTRING = SFalse + (%==) (SVEC _ _) SNAT = SFalse + (%==) + (SVEC (sA_0123456789876543210 :: Sing a_0123456789876543210) + (sA_0123456789876543210 :: Sing a_0123456789876543210)) + (SVEC (sB_0123456789876543210 :: Sing b_0123456789876543210) + (sB_0123456789876543210 :: Sing b_0123456789876543210)) + = (applySing + ((applySing ((singFun2 @(&&@#@$)) (%&&))) + ((applySing + ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210)) + sB_0123456789876543210))) + ((applySing + ((applySing ((singFun2 @(==@#@$)) (%==))) sA_0123456789876543210)) + sB_0123456789876543210) + instance (SShow U, SShow Nat) => SShow U where + sShowsPrec :: + forall (t1 :: GHC.Num.Natural.Natural) + (t2 :: U) + (t3 :: Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) U ((~>) Symbol Symbol)) + -> Type) t1) t2) t3) + sShowsPrec + _ + SBOOL + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "BOOL"))) + sA_0123456789876543210 + sShowsPrec + _ + SSTRING + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "STRING"))) + sA_0123456789876543210 + sShowsPrec + _ + SNAT + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "NAT"))) + sA_0123456789876543210 + sShowsPrec + (sP_0123456789876543210 :: Sing p_0123456789876543210) + (SVEC (sArg_0123456789876543210 :: Sing arg_0123456789876543210) + (sArg_0123456789876543210 :: Sing arg_0123456789876543210)) + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing + ((applySing ((singFun3 @ShowParenSym0) sShowParen)) + ((applySing + ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210)) + (sFromInteger (sing :: Sing 10))))) + ((applySing + ((applySing ((singFun3 @(.@#@$)) (%.))) + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "VEC ")))) + ((applySing + ((applySing ((singFun3 @(.@#@$)) (%.))) + ((applySing + ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec)) + (sFromInteger (sing :: Sing 11)))) + sArg_0123456789876543210))) + ((applySing + ((applySing ((singFun3 @(.@#@$)) (%.))) + ((singFun1 @ShowSpaceSym0) sShowSpace))) + ((applySing + ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec)) + (sFromInteger (sing :: Sing 11)))) + sArg_0123456789876543210)))))) + sA_0123456789876543210 + instance SShow AChar where + sShowsPrec :: + forall (t1 :: GHC.Num.Natural.Natural) + (t2 :: AChar) + (t3 :: Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) AChar ((~>) Symbol Symbol)) + -> Type) t1) t2) t3) + sShowsPrec + _ + SCA + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CA"))) + sA_0123456789876543210 + sShowsPrec + _ + SCB + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CB"))) + sA_0123456789876543210 + sShowsPrec + _ + SCC + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CC"))) + sA_0123456789876543210 + sShowsPrec + _ + SCD + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CD"))) + sA_0123456789876543210 + sShowsPrec + _ + SCE + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CE"))) + sA_0123456789876543210 + sShowsPrec + _ + SCF + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CF"))) + sA_0123456789876543210 + sShowsPrec + _ + SCG + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CG"))) + sA_0123456789876543210 + sShowsPrec + _ + SCH + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CH"))) + sA_0123456789876543210 + sShowsPrec + _ + SCI + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CI"))) + sA_0123456789876543210 + sShowsPrec + _ + SCJ + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CJ"))) + sA_0123456789876543210 + sShowsPrec + _ + SCK + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CK"))) + sA_0123456789876543210 + sShowsPrec + _ + SCL + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CL"))) + sA_0123456789876543210 + sShowsPrec + _ + SCM + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CM"))) + sA_0123456789876543210 + sShowsPrec + _ + SCN + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CN"))) + sA_0123456789876543210 + sShowsPrec + _ + SCO + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CO"))) + sA_0123456789876543210 + sShowsPrec + _ + SCP + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CP"))) + sA_0123456789876543210 + sShowsPrec + _ + SCQ + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CQ"))) + sA_0123456789876543210 + sShowsPrec + _ + SCR + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CR"))) + sA_0123456789876543210 + sShowsPrec + _ + SCS + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CS"))) + sA_0123456789876543210 + sShowsPrec + _ + SCT + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CT"))) + sA_0123456789876543210 + sShowsPrec + _ + SCU + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CU"))) + sA_0123456789876543210 + sShowsPrec + _ + SCV + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CV"))) + sA_0123456789876543210 + sShowsPrec + _ + SCW + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CW"))) + sA_0123456789876543210 + sShowsPrec + _ + SCX + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CX"))) + sA_0123456789876543210 + sShowsPrec + _ + SCY + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CY"))) + sA_0123456789876543210 + sShowsPrec + _ + SCZ + (sA_0123456789876543210 :: Sing a_0123456789876543210) + = (applySing + ((applySing ((singFun2 @ShowStringSym0) sShowString)) + (sing :: Sing "CZ"))) + sA_0123456789876543210 + instance SEq AChar where + (%==) :: + forall (t1 :: AChar) (t2 :: AChar). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun AChar ((~>) AChar Bool) + -> Type) t1) t2) + (%==) SCA SCA = STrue + (%==) SCA SCB = SFalse + (%==) SCA SCC = SFalse + (%==) SCA SCD = SFalse + (%==) SCA SCE = SFalse + (%==) SCA SCF = SFalse + (%==) SCA SCG = SFalse + (%==) SCA SCH = SFalse + (%==) SCA SCI = SFalse + (%==) SCA SCJ = SFalse + (%==) SCA SCK = SFalse + (%==) SCA SCL = SFalse + (%==) SCA SCM = SFalse + (%==) SCA SCN = SFalse + (%==) SCA SCO = SFalse + (%==) SCA SCP = SFalse + (%==) SCA SCQ = SFalse + (%==) SCA SCR = SFalse + (%==) SCA SCS = SFalse + (%==) SCA SCT = SFalse + (%==) SCA SCU = SFalse + (%==) SCA SCV = SFalse + (%==) SCA SCW = SFalse + (%==) SCA SCX = SFalse + (%==) SCA SCY = SFalse + (%==) SCA SCZ = SFalse + (%==) SCB SCA = SFalse + (%==) SCB SCB = STrue + (%==) SCB SCC = SFalse + (%==) SCB SCD = SFalse + (%==) SCB SCE = SFalse + (%==) SCB SCF = SFalse + (%==) SCB SCG = SFalse + (%==) SCB SCH = SFalse + (%==) SCB SCI = SFalse + (%==) SCB SCJ = SFalse + (%==) SCB SCK = SFalse + (%==) SCB SCL = SFalse + (%==) SCB SCM = SFalse + (%==) SCB SCN = SFalse + (%==) SCB SCO = SFalse + (%==) SCB SCP = SFalse + (%==) SCB SCQ = SFalse + (%==) SCB SCR = SFalse + (%==) SCB SCS = SFalse + (%==) SCB SCT = SFalse + (%==) SCB SCU = SFalse + (%==) SCB SCV = SFalse + (%==) SCB SCW = SFalse + (%==) SCB SCX = SFalse + (%==) SCB SCY = SFalse + (%==) SCB SCZ = SFalse + (%==) SCC SCA = SFalse + (%==) SCC SCB = SFalse + (%==) SCC SCC = STrue + (%==) SCC SCD = SFalse + (%==) SCC SCE = SFalse + (%==) SCC SCF = SFalse + (%==) SCC SCG = SFalse + (%==) SCC SCH = SFalse + (%==) SCC SCI = SFalse + (%==) SCC SCJ = SFalse + (%==) SCC SCK = SFalse + (%==) SCC SCL = SFalse + (%==) SCC SCM = SFalse + (%==) SCC SCN = SFalse + (%==) SCC SCO = SFalse + (%==) SCC SCP = SFalse + (%==) SCC SCQ = SFalse + (%==) SCC SCR = SFalse + (%==) SCC SCS = SFalse + (%==) SCC SCT = SFalse + (%==) SCC SCU = SFalse + (%==) SCC SCV = SFalse + (%==) SCC SCW = SFalse + (%==) SCC SCX = SFalse + (%==) SCC SCY = SFalse + (%==) SCC SCZ = SFalse + (%==) SCD SCA = SFalse + (%==) SCD SCB = SFalse + (%==) SCD SCC = SFalse + (%==) SCD SCD = STrue + (%==) SCD SCE = SFalse + (%==) SCD SCF = SFalse + (%==) SCD SCG = SFalse + (%==) SCD SCH = SFalse + (%==) SCD SCI = SFalse + (%==) SCD SCJ = SFalse + (%==) SCD SCK = SFalse + (%==) SCD SCL = SFalse + (%==) SCD SCM = SFalse + (%==) SCD SCN = SFalse + (%==) SCD SCO = SFalse + (%==) SCD SCP = SFalse + (%==) SCD SCQ = SFalse + (%==) SCD SCR = SFalse + (%==) SCD SCS = SFalse + (%==) SCD SCT = SFalse + (%==) SCD SCU = SFalse + (%==) SCD SCV = SFalse + (%==) SCD SCW = SFalse + (%==) SCD SCX = SFalse + (%==) SCD SCY = SFalse + (%==) SCD SCZ = SFalse + (%==) SCE SCA = SFalse + (%==) SCE SCB = SFalse + (%==) SCE SCC = SFalse + (%==) SCE SCD = SFalse + (%==) SCE SCE = STrue + (%==) SCE SCF = SFalse + (%==) SCE SCG = SFalse + (%==) SCE SCH = SFalse + (%==) SCE SCI = SFalse + (%==) SCE SCJ = SFalse + (%==) SCE SCK = SFalse + (%==) SCE SCL = SFalse + (%==) SCE SCM = SFalse + (%==) SCE SCN = SFalse + (%==) SCE SCO = SFalse + (%==) SCE SCP = SFalse + (%==) SCE SCQ = SFalse + (%==) SCE SCR = SFalse + (%==) SCE SCS = SFalse + (%==) SCE SCT = SFalse + (%==) SCE SCU = SFalse + (%==) SCE SCV = SFalse + (%==) SCE SCW = SFalse + (%==) SCE SCX = SFalse + (%==) SCE SCY = SFalse + (%==) SCE SCZ = SFalse + (%==) SCF SCA = SFalse + (%==) SCF SCB = SFalse + (%==) SCF SCC = SFalse + (%==) SCF SCD = SFalse + (%==) SCF SCE = SFalse + (%==) SCF SCF = STrue + (%==) SCF SCG = SFalse + (%==) SCF SCH = SFalse + (%==) SCF SCI = SFalse + (%==) SCF SCJ = SFalse + (%==) SCF SCK = SFalse + (%==) SCF SCL = SFalse + (%==) SCF SCM = SFalse + (%==) SCF SCN = SFalse + (%==) SCF SCO = SFalse + (%==) SCF SCP = SFalse + (%==) SCF SCQ = SFalse + (%==) SCF SCR = SFalse + (%==) SCF SCS = SFalse + (%==) SCF SCT = SFalse + (%==) SCF SCU = SFalse + (%==) SCF SCV = SFalse + (%==) SCF SCW = SFalse + (%==) SCF SCX = SFalse + (%==) SCF SCY = SFalse + (%==) SCF SCZ = SFalse + (%==) SCG SCA = SFalse + (%==) SCG SCB = SFalse + (%==) SCG SCC = SFalse + (%==) SCG SCD = SFalse + (%==) SCG SCE = SFalse + (%==) SCG SCF = SFalse + (%==) SCG SCG = STrue + (%==) SCG SCH = SFalse + (%==) SCG SCI = SFalse + (%==) SCG SCJ = SFalse + (%==) SCG SCK = SFalse + (%==) SCG SCL = SFalse + (%==) SCG SCM = SFalse + (%==) SCG SCN = SFalse + (%==) SCG SCO = SFalse + (%==) SCG SCP = SFalse + (%==) SCG SCQ = SFalse + (%==) SCG SCR = SFalse + (%==) SCG SCS = SFalse + (%==) SCG SCT = SFalse + (%==) SCG SCU = SFalse + (%==) SCG SCV = SFalse + (%==) SCG SCW = SFalse + (%==) SCG SCX = SFalse + (%==) SCG SCY = SFalse + (%==) SCG SCZ = SFalse + (%==) SCH SCA = SFalse + (%==) SCH SCB = SFalse + (%==) SCH SCC = SFalse + (%==) SCH SCD = SFalse + (%==) SCH SCE = SFalse + (%==) SCH SCF = SFalse + (%==) SCH SCG = SFalse + (%==) SCH SCH = STrue + (%==) SCH SCI = SFalse + (%==) SCH SCJ = SFalse + (%==) SCH SCK = SFalse + (%==) SCH SCL = SFalse + (%==) SCH SCM = SFalse + (%==) SCH SCN = SFalse + (%==) SCH SCO = SFalse + (%==) SCH SCP = SFalse + (%==) SCH SCQ = SFalse + (%==) SCH SCR = SFalse + (%==) SCH SCS = SFalse + (%==) SCH SCT = SFalse + (%==) SCH SCU = SFalse + (%==) SCH SCV = SFalse + (%==) SCH SCW = SFalse + (%==) SCH SCX = SFalse + (%==) SCH SCY = SFalse + (%==) SCH SCZ = SFalse + (%==) SCI SCA = SFalse + (%==) SCI SCB = SFalse + (%==) SCI SCC = SFalse + (%==) SCI SCD = SFalse + (%==) SCI SCE = SFalse + (%==) SCI SCF = SFalse + (%==) SCI SCG = SFalse + (%==) SCI SCH = SFalse + (%==) SCI SCI = STrue + (%==) SCI SCJ = SFalse + (%==) SCI SCK = SFalse + (%==) SCI SCL = SFalse + (%==) SCI SCM = SFalse + (%==) SCI SCN = SFalse + (%==) SCI SCO = SFalse + (%==) SCI SCP = SFalse + (%==) SCI SCQ = SFalse + (%==) SCI SCR = SFalse + (%==) SCI SCS = SFalse + (%==) SCI SCT = SFalse + (%==) SCI SCU = SFalse + (%==) SCI SCV = SFalse + (%==) SCI SCW = SFalse + (%==) SCI SCX = SFalse + (%==) SCI SCY = SFalse + (%==) SCI SCZ = SFalse + (%==) SCJ SCA = SFalse + (%==) SCJ SCB = SFalse + (%==) SCJ SCC = SFalse + (%==) SCJ SCD = SFalse + (%==) SCJ SCE = SFalse + (%==) SCJ SCF = SFalse + (%==) SCJ SCG = SFalse + (%==) SCJ SCH = SFalse + (%==) SCJ SCI = SFalse + (%==) SCJ SCJ = STrue + (%==) SCJ SCK = SFalse + (%==) SCJ SCL = SFalse + (%==) SCJ SCM = SFalse + (%==) SCJ SCN = SFalse + (%==) SCJ SCO = SFalse + (%==) SCJ SCP = SFalse + (%==) SCJ SCQ = SFalse + (%==) SCJ SCR = SFalse + (%==) SCJ SCS = SFalse + (%==) SCJ SCT = SFalse + (%==) SCJ SCU = SFalse + (%==) SCJ SCV = SFalse + (%==) SCJ SCW = SFalse + (%==) SCJ SCX = SFalse + (%==) SCJ SCY = SFalse + (%==) SCJ SCZ = SFalse + (%==) SCK SCA = SFalse + (%==) SCK SCB = SFalse + (%==) SCK SCC = SFalse + (%==) SCK SCD = SFalse + (%==) SCK SCE = SFalse + (%==) SCK SCF = SFalse + (%==) SCK SCG = SFalse + (%==) SCK SCH = SFalse + (%==) SCK SCI = SFalse + (%==) SCK SCJ = SFalse + (%==) SCK SCK = STrue + (%==) SCK SCL = SFalse + (%==) SCK SCM = SFalse + (%==) SCK SCN = SFalse + (%==) SCK SCO = SFalse + (%==) SCK SCP = SFalse + (%==) SCK SCQ = SFalse + (%==) SCK SCR = SFalse + (%==) SCK SCS = SFalse + (%==) SCK SCT = SFalse + (%==) SCK SCU = SFalse + (%==) SCK SCV = SFalse + (%==) SCK SCW = SFalse + (%==) SCK SCX = SFalse + (%==) SCK SCY = SFalse + (%==) SCK SCZ = SFalse + (%==) SCL SCA = SFalse + (%==) SCL SCB = SFalse + (%==) SCL SCC = SFalse + (%==) SCL SCD = SFalse + (%==) SCL SCE = SFalse + (%==) SCL SCF = SFalse + (%==) SCL SCG = SFalse + (%==) SCL SCH = SFalse + (%==) SCL SCI = SFalse + (%==) SCL SCJ = SFalse + (%==) SCL SCK = SFalse + (%==) SCL SCL = STrue + (%==) SCL SCM = SFalse + (%==) SCL SCN = SFalse + (%==) SCL SCO = SFalse + (%==) SCL SCP = SFalse + (%==) SCL SCQ = SFalse + (%==) SCL SCR = SFalse + (%==) SCL SCS = SFalse + (%==) SCL SCT = SFalse + (%==) SCL SCU = SFalse + (%==) SCL SCV = SFalse + (%==) SCL SCW = SFalse + (%==) SCL SCX = SFalse + (%==) SCL SCY = SFalse + (%==) SCL SCZ = SFalse + (%==) SCM SCA = SFalse + (%==) SCM SCB = SFalse + (%==) SCM SCC = SFalse + (%==) SCM SCD = SFalse + (%==) SCM SCE = SFalse + (%==) SCM SCF = SFalse + (%==) SCM SCG = SFalse + (%==) SCM SCH = SFalse + (%==) SCM SCI = SFalse + (%==) SCM SCJ = SFalse + (%==) SCM SCK = SFalse + (%==) SCM SCL = SFalse + (%==) SCM SCM = STrue + (%==) SCM SCN = SFalse + (%==) SCM SCO = SFalse + (%==) SCM SCP = SFalse + (%==) SCM SCQ = SFalse + (%==) SCM SCR = SFalse + (%==) SCM SCS = SFalse + (%==) SCM SCT = SFalse + (%==) SCM SCU = SFalse + (%==) SCM SCV = SFalse + (%==) SCM SCW = SFalse + (%==) SCM SCX = SFalse + (%==) SCM SCY = SFalse + (%==) SCM SCZ = SFalse + (%==) SCN SCA = SFalse + (%==) SCN SCB = SFalse + (%==) SCN SCC = SFalse + (%==) SCN SCD = SFalse + (%==) SCN SCE = SFalse + (%==) SCN SCF = SFalse + (%==) SCN SCG = SFalse + (%==) SCN SCH = SFalse + (%==) SCN SCI = SFalse + (%==) SCN SCJ = SFalse + (%==) SCN SCK = SFalse + (%==) SCN SCL = SFalse + (%==) SCN SCM = SFalse + (%==) SCN SCN = STrue + (%==) SCN SCO = SFalse + (%==) SCN SCP = SFalse + (%==) SCN SCQ = SFalse + (%==) SCN SCR = SFalse + (%==) SCN SCS = SFalse + (%==) SCN SCT = SFalse + (%==) SCN SCU = SFalse + (%==) SCN SCV = SFalse + (%==) SCN SCW = SFalse + (%==) SCN SCX = SFalse + (%==) SCN SCY = SFalse + (%==) SCN SCZ = SFalse + (%==) SCO SCA = SFalse + (%==) SCO SCB = SFalse + (%==) SCO SCC = SFalse + (%==) SCO SCD = SFalse + (%==) SCO SCE = SFalse + (%==) SCO SCF = SFalse + (%==) SCO SCG = SFalse + (%==) SCO SCH = SFalse + (%==) SCO SCI = SFalse + (%==) SCO SCJ = SFalse + (%==) SCO SCK = SFalse + (%==) SCO SCL = SFalse + (%==) SCO SCM = SFalse + (%==) SCO SCN = SFalse + (%==) SCO SCO = STrue + (%==) SCO SCP = SFalse + (%==) SCO SCQ = SFalse + (%==) SCO SCR = SFalse + (%==) SCO SCS = SFalse + (%==) SCO SCT = SFalse + (%==) SCO SCU = SFalse + (%==) SCO SCV = SFalse + (%==) SCO SCW = SFalse + (%==) SCO SCX = SFalse + (%==) SCO SCY = SFalse + (%==) SCO SCZ = SFalse + (%==) SCP SCA = SFalse + (%==) SCP SCB = SFalse + (%==) SCP SCC = SFalse + (%==) SCP SCD = SFalse + (%==) SCP SCE = SFalse + (%==) SCP SCF = SFalse + (%==) SCP SCG = SFalse + (%==) SCP SCH = SFalse + (%==) SCP SCI = SFalse + (%==) SCP SCJ = SFalse + (%==) SCP SCK = SFalse + (%==) SCP SCL = SFalse + (%==) SCP SCM = SFalse + (%==) SCP SCN = SFalse + (%==) SCP SCO = SFalse + (%==) SCP SCP = STrue + (%==) SCP SCQ = SFalse + (%==) SCP SCR = SFalse + (%==) SCP SCS = SFalse + (%==) SCP SCT = SFalse + (%==) SCP SCU = SFalse + (%==) SCP SCV = SFalse + (%==) SCP SCW = SFalse + (%==) SCP SCX = SFalse + (%==) SCP SCY = SFalse + (%==) SCP SCZ = SFalse + (%==) SCQ SCA = SFalse + (%==) SCQ SCB = SFalse + (%==) SCQ SCC = SFalse + (%==) SCQ SCD = SFalse + (%==) SCQ SCE = SFalse + (%==) SCQ SCF = SFalse + (%==) SCQ SCG = SFalse + (%==) SCQ SCH = SFalse + (%==) SCQ SCI = SFalse + (%==) SCQ SCJ = SFalse + (%==) SCQ SCK = SFalse + (%==) SCQ SCL = SFalse + (%==) SCQ SCM = SFalse + (%==) SCQ SCN = SFalse + (%==) SCQ SCO = SFalse + (%==) SCQ SCP = SFalse + (%==) SCQ SCQ = STrue + (%==) SCQ SCR = SFalse + (%==) SCQ SCS = SFalse + (%==) SCQ SCT = SFalse + (%==) SCQ SCU = SFalse + (%==) SCQ SCV = SFalse + (%==) SCQ SCW = SFalse + (%==) SCQ SCX = SFalse + (%==) SCQ SCY = SFalse + (%==) SCQ SCZ = SFalse + (%==) SCR SCA = SFalse + (%==) SCR SCB = SFalse + (%==) SCR SCC = SFalse + (%==) SCR SCD = SFalse + (%==) SCR SCE = SFalse + (%==) SCR SCF = SFalse + (%==) SCR SCG = SFalse + (%==) SCR SCH = SFalse + (%==) SCR SCI = SFalse + (%==) SCR SCJ = SFalse + (%==) SCR SCK = SFalse + (%==) SCR SCL = SFalse + (%==) SCR SCM = SFalse + (%==) SCR SCN = SFalse + (%==) SCR SCO = SFalse + (%==) SCR SCP = SFalse + (%==) SCR SCQ = SFalse + (%==) SCR SCR = STrue + (%==) SCR SCS = SFalse + (%==) SCR SCT = SFalse + (%==) SCR SCU = SFalse + (%==) SCR SCV = SFalse + (%==) SCR SCW = SFalse + (%==) SCR SCX = SFalse + (%==) SCR SCY = SFalse + (%==) SCR SCZ = SFalse + (%==) SCS SCA = SFalse + (%==) SCS SCB = SFalse + (%==) SCS SCC = SFalse + (%==) SCS SCD = SFalse + (%==) SCS SCE = SFalse + (%==) SCS SCF = SFalse + (%==) SCS SCG = SFalse + (%==) SCS SCH = SFalse + (%==) SCS SCI = SFalse + (%==) SCS SCJ = SFalse + (%==) SCS SCK = SFalse + (%==) SCS SCL = SFalse + (%==) SCS SCM = SFalse + (%==) SCS SCN = SFalse + (%==) SCS SCO = SFalse + (%==) SCS SCP = SFalse + (%==) SCS SCQ = SFalse + (%==) SCS SCR = SFalse + (%==) SCS SCS = STrue + (%==) SCS SCT = SFalse + (%==) SCS SCU = SFalse + (%==) SCS SCV = SFalse + (%==) SCS SCW = SFalse + (%==) SCS SCX = SFalse + (%==) SCS SCY = SFalse + (%==) SCS SCZ = SFalse + (%==) SCT SCA = SFalse + (%==) SCT SCB = SFalse + (%==) SCT SCC = SFalse + (%==) SCT SCD = SFalse + (%==) SCT SCE = SFalse + (%==) SCT SCF = SFalse + (%==) SCT SCG = SFalse + (%==) SCT SCH = SFalse + (%==) SCT SCI = SFalse + (%==) SCT SCJ = SFalse + (%==) SCT SCK = SFalse + (%==) SCT SCL = SFalse + (%==) SCT SCM = SFalse + (%==) SCT SCN = SFalse + (%==) SCT SCO = SFalse + (%==) SCT SCP = SFalse + (%==) SCT SCQ = SFalse + (%==) SCT SCR = SFalse + (%==) SCT SCS = SFalse + (%==) SCT SCT = STrue + (%==) SCT SCU = SFalse + (%==) SCT SCV = SFalse + (%==) SCT SCW = SFalse + (%==) SCT SCX = SFalse + (%==) SCT SCY = SFalse + (%==) SCT SCZ = SFalse + (%==) SCU SCA = SFalse + (%==) SCU SCB = SFalse + (%==) SCU SCC = SFalse + (%==) SCU SCD = SFalse + (%==) SCU SCE = SFalse + (%==) SCU SCF = SFalse + (%==) SCU SCG = SFalse + (%==) SCU SCH = SFalse + (%==) SCU SCI = SFalse + (%==) SCU SCJ = SFalse + (%==) SCU SCK = SFalse + (%==) SCU SCL = SFalse + (%==) SCU SCM = SFalse + (%==) SCU SCN = SFalse + (%==) SCU SCO = SFalse + (%==) SCU SCP = SFalse + (%==) SCU SCQ = SFalse + (%==) SCU SCR = SFalse + (%==) SCU SCS = SFalse + (%==) SCU SCT = SFalse + (%==) SCU SCU = STrue + (%==) SCU SCV = SFalse + (%==) SCU SCW = SFalse + (%==) SCU SCX = SFalse + (%==) SCU SCY = SFalse + (%==) SCU SCZ = SFalse + (%==) SCV SCA = SFalse + (%==) SCV SCB = SFalse + (%==) SCV SCC = SFalse + (%==) SCV SCD = SFalse + (%==) SCV SCE = SFalse + (%==) SCV SCF = SFalse + (%==) SCV SCG = SFalse + (%==) SCV SCH = SFalse + (%==) SCV SCI = SFalse + (%==) SCV SCJ = SFalse + (%==) SCV SCK = SFalse + (%==) SCV SCL = SFalse + (%==) SCV SCM = SFalse + (%==) SCV SCN = SFalse + (%==) SCV SCO = SFalse + (%==) SCV SCP = SFalse + (%==) SCV SCQ = SFalse + (%==) SCV SCR = SFalse + (%==) SCV SCS = SFalse + (%==) SCV SCT = SFalse + (%==) SCV SCU = SFalse + (%==) SCV SCV = STrue + (%==) SCV SCW = SFalse + (%==) SCV SCX = SFalse + (%==) SCV SCY = SFalse + (%==) SCV SCZ = SFalse + (%==) SCW SCA = SFalse + (%==) SCW SCB = SFalse + (%==) SCW SCC = SFalse + (%==) SCW SCD = SFalse + (%==) SCW SCE = SFalse + (%==) SCW SCF = SFalse + (%==) SCW SCG = SFalse + (%==) SCW SCH = SFalse + (%==) SCW SCI = SFalse + (%==) SCW SCJ = SFalse + (%==) SCW SCK = SFalse + (%==) SCW SCL = SFalse + (%==) SCW SCM = SFalse + (%==) SCW SCN = SFalse + (%==) SCW SCO = SFalse + (%==) SCW SCP = SFalse + (%==) SCW SCQ = SFalse + (%==) SCW SCR = SFalse + (%==) SCW SCS = SFalse + (%==) SCW SCT = SFalse + (%==) SCW SCU = SFalse + (%==) SCW SCV = SFalse + (%==) SCW SCW = STrue + (%==) SCW SCX = SFalse + (%==) SCW SCY = SFalse + (%==) SCW SCZ = SFalse + (%==) SCX SCA = SFalse + (%==) SCX SCB = SFalse + (%==) SCX SCC = SFalse + (%==) SCX SCD = SFalse + (%==) SCX SCE = SFalse + (%==) SCX SCF = SFalse + (%==) SCX SCG = SFalse + (%==) SCX SCH = SFalse + (%==) SCX SCI = SFalse + (%==) SCX SCJ = SFalse + (%==) SCX SCK = SFalse + (%==) SCX SCL = SFalse + (%==) SCX SCM = SFalse + (%==) SCX SCN = SFalse + (%==) SCX SCO = SFalse + (%==) SCX SCP = SFalse + (%==) SCX SCQ = SFalse + (%==) SCX SCR = SFalse + (%==) SCX SCS = SFalse + (%==) SCX SCT = SFalse + (%==) SCX SCU = SFalse + (%==) SCX SCV = SFalse + (%==) SCX SCW = SFalse + (%==) SCX SCX = STrue + (%==) SCX SCY = SFalse + (%==) SCX SCZ = SFalse + (%==) SCY SCA = SFalse + (%==) SCY SCB = SFalse + (%==) SCY SCC = SFalse + (%==) SCY SCD = SFalse + (%==) SCY SCE = SFalse + (%==) SCY SCF = SFalse + (%==) SCY SCG = SFalse + (%==) SCY SCH = SFalse + (%==) SCY SCI = SFalse + (%==) SCY SCJ = SFalse + (%==) SCY SCK = SFalse + (%==) SCY SCL = SFalse + (%==) SCY SCM = SFalse + (%==) SCY SCN = SFalse + (%==) SCY SCO = SFalse + (%==) SCY SCP = SFalse + (%==) SCY SCQ = SFalse + (%==) SCY SCR = SFalse + (%==) SCY SCS = SFalse + (%==) SCY SCT = SFalse + (%==) SCY SCU = SFalse + (%==) SCY SCV = SFalse + (%==) SCY SCW = SFalse + (%==) SCY SCX = SFalse + (%==) SCY SCY = STrue + (%==) SCY SCZ = SFalse + (%==) SCZ SCA = SFalse + (%==) SCZ SCB = SFalse + (%==) SCZ SCC = SFalse + (%==) SCZ SCD = SFalse + (%==) SCZ SCE = SFalse + (%==) SCZ SCF = SFalse + (%==) SCZ SCG = SFalse + (%==) SCZ SCH = SFalse + (%==) SCZ SCI = SFalse + (%==) SCZ SCJ = SFalse + (%==) SCZ SCK = SFalse + (%==) SCZ SCL = SFalse + (%==) SCZ SCM = SFalse + (%==) SCZ SCN = SFalse + (%==) SCZ SCO = SFalse + (%==) SCZ SCP = SFalse + (%==) SCZ SCQ = SFalse + (%==) SCZ SCR = SFalse + (%==) SCZ SCS = SFalse + (%==) SCZ SCT = SFalse + (%==) SCZ SCU = SFalse + (%==) SCZ SCV = SFalse + (%==) SCZ SCW = SFalse + (%==) SCZ SCX = SFalse + (%==) SCZ SCY = SFalse + (%==) SCZ SCZ = STrue + instance (SDecide U, SDecide Nat) => SDecide U where + (%~) SBOOL SBOOL = Proved Refl + (%~) SBOOL SSTRING = Disproved (\ x -> case x of {}) + (%~) SBOOL SNAT = Disproved (\ x -> case x of {}) + (%~) SBOOL (SVEC _ _) = Disproved (\ x -> case x of {}) + (%~) SSTRING SBOOL = Disproved (\ x -> case x of {}) + (%~) SSTRING SSTRING = Proved Refl + (%~) SSTRING SNAT = Disproved (\ x -> case x of {}) + (%~) SSTRING (SVEC _ _) = Disproved (\ x -> case x of {}) + (%~) SNAT SBOOL = Disproved (\ x -> case x of {}) + (%~) SNAT SSTRING = Disproved (\ x -> case x of {}) + (%~) SNAT SNAT = Proved Refl + (%~) SNAT (SVEC _ _) = Disproved (\ x -> case x of {}) + (%~) (SVEC _ _) SBOOL = Disproved (\ x -> case x of {}) + (%~) (SVEC _ _) SSTRING = Disproved (\ x -> case x of {}) + (%~) (SVEC _ _) SNAT = Disproved (\ x -> case x of {}) + (%~) (SVEC a a) (SVEC b b) + = case ((,) (((%~) a) b)) (((%~) a) b) of + (,) (Proved Refl) (Proved Refl) -> Proved Refl + (,) (Disproved contra) _ + -> Disproved (\ refl -> case refl of Refl -> contra Refl) + (,) _ (Disproved contra) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) + instance (SDecide U, SDecide Nat) => + Data.Type.Equality.TestEquality (SU :: U -> Type) where + Data.Type.Equality.testEquality + = Data.Singletons.Decide.decideEquality + instance (SDecide U, SDecide Nat) => + Data.Type.Coercion.TestCoercion (SU :: U -> Type) where + Data.Type.Coercion.testCoercion + = Data.Singletons.Decide.decideCoercion + instance SDecide AChar where + (%~) SCA SCA = Proved Refl + (%~) SCA SCB = Disproved (\ x -> case x of {}) + (%~) SCA SCC = Disproved (\ x -> case x of {}) + (%~) SCA SCD = Disproved (\ x -> case x of {}) + (%~) SCA SCE = Disproved (\ x -> case x of {}) + (%~) SCA SCF = Disproved (\ x -> case x of {}) + (%~) SCA SCG = Disproved (\ x -> case x of {}) + (%~) SCA SCH = Disproved (\ x -> case x of {}) + (%~) SCA SCI = Disproved (\ x -> case x of {}) + (%~) SCA SCJ = Disproved (\ x -> case x of {}) + (%~) SCA SCK = Disproved (\ x -> case x of {}) + (%~) SCA SCL = Disproved (\ x -> case x of {}) + (%~) SCA SCM = Disproved (\ x -> case x of {}) + (%~) SCA SCN = Disproved (\ x -> case x of {}) + (%~) SCA SCO = Disproved (\ x -> case x of {}) + (%~) SCA SCP = Disproved (\ x -> case x of {}) + (%~) SCA SCQ = Disproved (\ x -> case x of {}) + (%~) SCA SCR = Disproved (\ x -> case x of {}) + (%~) SCA SCS = Disproved (\ x -> case x of {}) + (%~) SCA SCT = Disproved (\ x -> case x of {}) + (%~) SCA SCU = Disproved (\ x -> case x of {}) + (%~) SCA SCV = Disproved (\ x -> case x of {}) + (%~) SCA SCW = Disproved (\ x -> case x of {}) + (%~) SCA SCX = Disproved (\ x -> case x of {}) + (%~) SCA SCY = Disproved (\ x -> case x of {}) + (%~) SCA SCZ = Disproved (\ x -> case x of {}) + (%~) SCB SCA = Disproved (\ x -> case x of {}) + (%~) SCB SCB = Proved Refl + (%~) SCB SCC = Disproved (\ x -> case x of {}) + (%~) SCB SCD = Disproved (\ x -> case x of {}) + (%~) SCB SCE = Disproved (\ x -> case x of {}) + (%~) SCB SCF = Disproved (\ x -> case x of {}) + (%~) SCB SCG = Disproved (\ x -> case x of {}) + (%~) SCB SCH = Disproved (\ x -> case x of {}) + (%~) SCB SCI = Disproved (\ x -> case x of {}) + (%~) SCB SCJ = Disproved (\ x -> case x of {}) + (%~) SCB SCK = Disproved (\ x -> case x of {}) + (%~) SCB SCL = Disproved (\ x -> case x of {}) + (%~) SCB SCM = Disproved (\ x -> case x of {}) + (%~) SCB SCN = Disproved (\ x -> case x of {}) + (%~) SCB SCO = Disproved (\ x -> case x of {}) + (%~) SCB SCP = Disproved (\ x -> case x of {}) + (%~) SCB SCQ = Disproved (\ x -> case x of {}) + (%~) SCB SCR = Disproved (\ x -> case x of {}) + (%~) SCB SCS = Disproved (\ x -> case x of {}) + (%~) SCB SCT = Disproved (\ x -> case x of {}) + (%~) SCB SCU = Disproved (\ x -> case x of {}) + (%~) SCB SCV = Disproved (\ x -> case x of {}) + (%~) SCB SCW = Disproved (\ x -> case x of {}) + (%~) SCB SCX = Disproved (\ x -> case x of {}) + (%~) SCB SCY = Disproved (\ x -> case x of {}) + (%~) SCB SCZ = Disproved (\ x -> case x of {}) + (%~) SCC SCA = Disproved (\ x -> case x of {}) + (%~) SCC SCB = Disproved (\ x -> case x of {}) + (%~) SCC SCC = Proved Refl + (%~) SCC SCD = Disproved (\ x -> case x of {}) + (%~) SCC SCE = Disproved (\ x -> case x of {}) + (%~) SCC SCF = Disproved (\ x -> case x of {}) + (%~) SCC SCG = Disproved (\ x -> case x of {}) + (%~) SCC SCH = Disproved (\ x -> case x of {}) + (%~) SCC SCI = Disproved (\ x -> case x of {}) + (%~) SCC SCJ = Disproved (\ x -> case x of {}) + (%~) SCC SCK = Disproved (\ x -> case x of {}) + (%~) SCC SCL = Disproved (\ x -> case x of {}) + (%~) SCC SCM = Disproved (\ x -> case x of {}) + (%~) SCC SCN = Disproved (\ x -> case x of {}) + (%~) SCC SCO = Disproved (\ x -> case x of {}) + (%~) SCC SCP = Disproved (\ x -> case x of {}) + (%~) SCC SCQ = Disproved (\ x -> case x of {}) + (%~) SCC SCR = Disproved (\ x -> case x of {}) + (%~) SCC SCS = Disproved (\ x -> case x of {}) + (%~) SCC SCT = Disproved (\ x -> case x of {}) + (%~) SCC SCU = Disproved (\ x -> case x of {}) + (%~) SCC SCV = Disproved (\ x -> case x of {}) + (%~) SCC SCW = Disproved (\ x -> case x of {}) + (%~) SCC SCX = Disproved (\ x -> case x of {}) + (%~) SCC SCY = Disproved (\ x -> case x of {}) + (%~) SCC SCZ = Disproved (\ x -> case x of {}) + (%~) SCD SCA = Disproved (\ x -> case x of {}) + (%~) SCD SCB = Disproved (\ x -> case x of {}) + (%~) SCD SCC = Disproved (\ x -> case x of {}) + (%~) SCD SCD = Proved Refl + (%~) SCD SCE = Disproved (\ x -> case x of {}) + (%~) SCD SCF = Disproved (\ x -> case x of {}) + (%~) SCD SCG = Disproved (\ x -> case x of {}) + (%~) SCD SCH = Disproved (\ x -> case x of {}) + (%~) SCD SCI = Disproved (\ x -> case x of {}) + (%~) SCD SCJ = Disproved (\ x -> case x of {}) + (%~) SCD SCK = Disproved (\ x -> case x of {}) + (%~) SCD SCL = Disproved (\ x -> case x of {}) + (%~) SCD SCM = Disproved (\ x -> case x of {}) + (%~) SCD SCN = Disproved (\ x -> case x of {}) + (%~) SCD SCO = Disproved (\ x -> case x of {}) + (%~) SCD SCP = Disproved (\ x -> case x of {}) + (%~) SCD SCQ = Disproved (\ x -> case x of {}) + (%~) SCD SCR = Disproved (\ x -> case x of {}) + (%~) SCD SCS = Disproved (\ x -> case x of {}) + (%~) SCD SCT = Disproved (\ x -> case x of {}) + (%~) SCD SCU = Disproved (\ x -> case x of {}) + (%~) SCD SCV = Disproved (\ x -> case x of {}) + (%~) SCD SCW = Disproved (\ x -> case x of {}) + (%~) SCD SCX = Disproved (\ x -> case x of {}) + (%~) SCD SCY = Disproved (\ x -> case x of {}) + (%~) SCD SCZ = Disproved (\ x -> case x of {}) + (%~) SCE SCA = Disproved (\ x -> case x of {}) + (%~) SCE SCB = Disproved (\ x -> case x of {}) + (%~) SCE SCC = Disproved (\ x -> case x of {}) + (%~) SCE SCD = Disproved (\ x -> case x of {}) + (%~) SCE SCE = Proved Refl + (%~) SCE SCF = Disproved (\ x -> case x of {}) + (%~) SCE SCG = Disproved (\ x -> case x of {}) + (%~) SCE SCH = Disproved (\ x -> case x of {}) + (%~) SCE SCI = Disproved (\ x -> case x of {}) + (%~) SCE SCJ = Disproved (\ x -> case x of {}) + (%~) SCE SCK = Disproved (\ x -> case x of {}) + (%~) SCE SCL = Disproved (\ x -> case x of {}) + (%~) SCE SCM = Disproved (\ x -> case x of {}) + (%~) SCE SCN = Disproved (\ x -> case x of {}) + (%~) SCE SCO = Disproved (\ x -> case x of {}) + (%~) SCE SCP = Disproved (\ x -> case x of {}) + (%~) SCE SCQ = Disproved (\ x -> case x of {}) + (%~) SCE SCR = Disproved (\ x -> case x of {}) + (%~) SCE SCS = Disproved (\ x -> case x of {}) + (%~) SCE SCT = Disproved (\ x -> case x of {}) + (%~) SCE SCU = Disproved (\ x -> case x of {}) + (%~) SCE SCV = Disproved (\ x -> case x of {}) + (%~) SCE SCW = Disproved (\ x -> case x of {}) + (%~) SCE SCX = Disproved (\ x -> case x of {}) + (%~) SCE SCY = Disproved (\ x -> case x of {}) + (%~) SCE SCZ = Disproved (\ x -> case x of {}) + (%~) SCF SCA = Disproved (\ x -> case x of {}) + (%~) SCF SCB = Disproved (\ x -> case x of {}) + (%~) SCF SCC = Disproved (\ x -> case x of {}) + (%~) SCF SCD = Disproved (\ x -> case x of {}) + (%~) SCF SCE = Disproved (\ x -> case x of {}) + (%~) SCF SCF = Proved Refl + (%~) SCF SCG = Disproved (\ x -> case x of {}) + (%~) SCF SCH = Disproved (\ x -> case x of {}) + (%~) SCF SCI = Disproved (\ x -> case x of {}) + (%~) SCF SCJ = Disproved (\ x -> case x of {}) + (%~) SCF SCK = Disproved (\ x -> case x of {}) + (%~) SCF SCL = Disproved (\ x -> case x of {}) + (%~) SCF SCM = Disproved (\ x -> case x of {}) + (%~) SCF SCN = Disproved (\ x -> case x of {}) + (%~) SCF SCO = Disproved (\ x -> case x of {}) + (%~) SCF SCP = Disproved (\ x -> case x of {}) + (%~) SCF SCQ = Disproved (\ x -> case x of {}) + (%~) SCF SCR = Disproved (\ x -> case x of {}) + (%~) SCF SCS = Disproved (\ x -> case x of {}) + (%~) SCF SCT = Disproved (\ x -> case x of {}) + (%~) SCF SCU = Disproved (\ x -> case x of {}) + (%~) SCF SCV = Disproved (\ x -> case x of {}) + (%~) SCF SCW = Disproved (\ x -> case x of {}) + (%~) SCF SCX = Disproved (\ x -> case x of {}) + (%~) SCF SCY = Disproved (\ x -> case x of {}) + (%~) SCF SCZ = Disproved (\ x -> case x of {}) + (%~) SCG SCA = Disproved (\ x -> case x of {}) + (%~) SCG SCB = Disproved (\ x -> case x of {}) + (%~) SCG SCC = Disproved (\ x -> case x of {}) + (%~) SCG SCD = Disproved (\ x -> case x of {}) + (%~) SCG SCE = Disproved (\ x -> case x of {}) + (%~) SCG SCF = Disproved (\ x -> case x of {}) + (%~) SCG SCG = Proved Refl + (%~) SCG SCH = Disproved (\ x -> case x of {}) + (%~) SCG SCI = Disproved (\ x -> case x of {}) + (%~) SCG SCJ = Disproved (\ x -> case x of {}) + (%~) SCG SCK = Disproved (\ x -> case x of {}) + (%~) SCG SCL = Disproved (\ x -> case x of {}) + (%~) SCG SCM = Disproved (\ x -> case x of {}) + (%~) SCG SCN = Disproved (\ x -> case x of {}) + (%~) SCG SCO = Disproved (\ x -> case x of {}) + (%~) SCG SCP = Disproved (\ x -> case x of {}) + (%~) SCG SCQ = Disproved (\ x -> case x of {}) + (%~) SCG SCR = Disproved (\ x -> case x of {}) + (%~) SCG SCS = Disproved (\ x -> case x of {}) + (%~) SCG SCT = Disproved (\ x -> case x of {}) + (%~) SCG SCU = Disproved (\ x -> case x of {}) + (%~) SCG SCV = Disproved (\ x -> case x of {}) + (%~) SCG SCW = Disproved (\ x -> case x of {}) + (%~) SCG SCX = Disproved (\ x -> case x of {}) + (%~) SCG SCY = Disproved (\ x -> case x of {}) + (%~) SCG SCZ = Disproved (\ x -> case x of {}) + (%~) SCH SCA = Disproved (\ x -> case x of {}) + (%~) SCH SCB = Disproved (\ x -> case x of {}) + (%~) SCH SCC = Disproved (\ x -> case x of {}) + (%~) SCH SCD = Disproved (\ x -> case x of {}) + (%~) SCH SCE = Disproved (\ x -> case x of {}) + (%~) SCH SCF = Disproved (\ x -> case x of {}) + (%~) SCH SCG = Disproved (\ x -> case x of {}) + (%~) SCH SCH = Proved Refl + (%~) SCH SCI = Disproved (\ x -> case x of {}) + (%~) SCH SCJ = Disproved (\ x -> case x of {}) + (%~) SCH SCK = Disproved (\ x -> case x of {}) + (%~) SCH SCL = Disproved (\ x -> case x of {}) + (%~) SCH SCM = Disproved (\ x -> case x of {}) + (%~) SCH SCN = Disproved (\ x -> case x of {}) + (%~) SCH SCO = Disproved (\ x -> case x of {}) + (%~) SCH SCP = Disproved (\ x -> case x of {}) + (%~) SCH SCQ = Disproved (\ x -> case x of {}) + (%~) SCH SCR = Disproved (\ x -> case x of {}) + (%~) SCH SCS = Disproved (\ x -> case x of {}) + (%~) SCH SCT = Disproved (\ x -> case x of {}) + (%~) SCH SCU = Disproved (\ x -> case x of {}) + (%~) SCH SCV = Disproved (\ x -> case x of {}) + (%~) SCH SCW = Disproved (\ x -> case x of {}) + (%~) SCH SCX = Disproved (\ x -> case x of {}) + (%~) SCH SCY = Disproved (\ x -> case x of {}) + (%~) SCH SCZ = Disproved (\ x -> case x of {}) + (%~) SCI SCA = Disproved (\ x -> case x of {}) + (%~) SCI SCB = Disproved (\ x -> case x of {}) + (%~) SCI SCC = Disproved (\ x -> case x of {}) + (%~) SCI SCD = Disproved (\ x -> case x of {}) + (%~) SCI SCE = Disproved (\ x -> case x of {}) + (%~) SCI SCF = Disproved (\ x -> case x of {}) + (%~) SCI SCG = Disproved (\ x -> case x of {}) + (%~) SCI SCH = Disproved (\ x -> case x of {}) + (%~) SCI SCI = Proved Refl + (%~) SCI SCJ = Disproved (\ x -> case x of {}) + (%~) SCI SCK = Disproved (\ x -> case x of {}) + (%~) SCI SCL = Disproved (\ x -> case x of {}) + (%~) SCI SCM = Disproved (\ x -> case x of {}) + (%~) SCI SCN = Disproved (\ x -> case x of {}) + (%~) SCI SCO = Disproved (\ x -> case x of {}) + (%~) SCI SCP = Disproved (\ x -> case x of {}) + (%~) SCI SCQ = Disproved (\ x -> case x of {}) + (%~) SCI SCR = Disproved (\ x -> case x of {}) + (%~) SCI SCS = Disproved (\ x -> case x of {}) + (%~) SCI SCT = Disproved (\ x -> case x of {}) + (%~) SCI SCU = Disproved (\ x -> case x of {}) + (%~) SCI SCV = Disproved (\ x -> case x of {}) + (%~) SCI SCW = Disproved (\ x -> case x of {}) + (%~) SCI SCX = Disproved (\ x -> case x of {}) + (%~) SCI SCY = Disproved (\ x -> case x of {}) + (%~) SCI SCZ = Disproved (\ x -> case x of {}) + (%~) SCJ SCA = Disproved (\ x -> case x of {}) + (%~) SCJ SCB = Disproved (\ x -> case x of {}) + (%~) SCJ SCC = Disproved (\ x -> case x of {}) + (%~) SCJ SCD = Disproved (\ x -> case x of {}) + (%~) SCJ SCE = Disproved (\ x -> case x of {}) + (%~) SCJ SCF = Disproved (\ x -> case x of {}) + (%~) SCJ SCG = Disproved (\ x -> case x of {}) + (%~) SCJ SCH = Disproved (\ x -> case x of {}) + (%~) SCJ SCI = Disproved (\ x -> case x of {}) + (%~) SCJ SCJ = Proved Refl + (%~) SCJ SCK = Disproved (\ x -> case x of {}) + (%~) SCJ SCL = Disproved (\ x -> case x of {}) + (%~) SCJ SCM = Disproved (\ x -> case x of {}) + (%~) SCJ SCN = Disproved (\ x -> case x of {}) + (%~) SCJ SCO = Disproved (\ x -> case x of {}) + (%~) SCJ SCP = Disproved (\ x -> case x of {}) + (%~) SCJ SCQ = Disproved (\ x -> case x of {}) + (%~) SCJ SCR = Disproved (\ x -> case x of {}) + (%~) SCJ SCS = Disproved (\ x -> case x of {}) + (%~) SCJ SCT = Disproved (\ x -> case x of {}) + (%~) SCJ SCU = Disproved (\ x -> case x of {}) + (%~) SCJ SCV = Disproved (\ x -> case x of {}) + (%~) SCJ SCW = Disproved (\ x -> case x of {}) + (%~) SCJ SCX = Disproved (\ x -> case x of {}) + (%~) SCJ SCY = Disproved (\ x -> case x of {}) + (%~) SCJ SCZ = Disproved (\ x -> case x of {}) + (%~) SCK SCA = Disproved (\ x -> case x of {}) + (%~) SCK SCB = Disproved (\ x -> case x of {}) + (%~) SCK SCC = Disproved (\ x -> case x of {}) + (%~) SCK SCD = Disproved (\ x -> case x of {}) + (%~) SCK SCE = Disproved (\ x -> case x of {}) + (%~) SCK SCF = Disproved (\ x -> case x of {}) + (%~) SCK SCG = Disproved (\ x -> case x of {}) + (%~) SCK SCH = Disproved (\ x -> case x of {}) + (%~) SCK SCI = Disproved (\ x -> case x of {}) + (%~) SCK SCJ = Disproved (\ x -> case x of {}) + (%~) SCK SCK = Proved Refl + (%~) SCK SCL = Disproved (\ x -> case x of {}) + (%~) SCK SCM = Disproved (\ x -> case x of {}) + (%~) SCK SCN = Disproved (\ x -> case x of {}) + (%~) SCK SCO = Disproved (\ x -> case x of {}) + (%~) SCK SCP = Disproved (\ x -> case x of {}) + (%~) SCK SCQ = Disproved (\ x -> case x of {}) + (%~) SCK SCR = Disproved (\ x -> case x of {}) + (%~) SCK SCS = Disproved (\ x -> case x of {}) + (%~) SCK SCT = Disproved (\ x -> case x of {}) + (%~) SCK SCU = Disproved (\ x -> case x of {}) + (%~) SCK SCV = Disproved (\ x -> case x of {}) + (%~) SCK SCW = Disproved (\ x -> case x of {}) + (%~) SCK SCX = Disproved (\ x -> case x of {}) + (%~) SCK SCY = Disproved (\ x -> case x of {}) + (%~) SCK SCZ = Disproved (\ x -> case x of {}) + (%~) SCL SCA = Disproved (\ x -> case x of {}) + (%~) SCL SCB = Disproved (\ x -> case x of {}) + (%~) SCL SCC = Disproved (\ x -> case x of {}) + (%~) SCL SCD = Disproved (\ x -> case x of {}) + (%~) SCL SCE = Disproved (\ x -> case x of {}) + (%~) SCL SCF = Disproved (\ x -> case x of {}) + (%~) SCL SCG = Disproved (\ x -> case x of {}) + (%~) SCL SCH = Disproved (\ x -> case x of {}) + (%~) SCL SCI = Disproved (\ x -> case x of {}) + (%~) SCL SCJ = Disproved (\ x -> case x of {}) + (%~) SCL SCK = Disproved (\ x -> case x of {}) + (%~) SCL SCL = Proved Refl + (%~) SCL SCM = Disproved (\ x -> case x of {}) + (%~) SCL SCN = Disproved (\ x -> case x of {}) + (%~) SCL SCO = Disproved (\ x -> case x of {}) + (%~) SCL SCP = Disproved (\ x -> case x of {}) + (%~) SCL SCQ = Disproved (\ x -> case x of {}) + (%~) SCL SCR = Disproved (\ x -> case x of {}) + (%~) SCL SCS = Disproved (\ x -> case x of {}) + (%~) SCL SCT = Disproved (\ x -> case x of {}) + (%~) SCL SCU = Disproved (\ x -> case x of {}) + (%~) SCL SCV = Disproved (\ x -> case x of {}) + (%~) SCL SCW = Disproved (\ x -> case x of {}) + (%~) SCL SCX = Disproved (\ x -> case x of {}) + (%~) SCL SCY = Disproved (\ x -> case x of {}) + (%~) SCL SCZ = Disproved (\ x -> case x of {}) + (%~) SCM SCA = Disproved (\ x -> case x of {}) + (%~) SCM SCB = Disproved (\ x -> case x of {}) + (%~) SCM SCC = Disproved (\ x -> case x of {}) + (%~) SCM SCD = Disproved (\ x -> case x of {}) + (%~) SCM SCE = Disproved (\ x -> case x of {}) + (%~) SCM SCF = Disproved (\ x -> case x of {}) + (%~) SCM SCG = Disproved (\ x -> case x of {}) + (%~) SCM SCH = Disproved (\ x -> case x of {}) + (%~) SCM SCI = Disproved (\ x -> case x of {}) + (%~) SCM SCJ = Disproved (\ x -> case x of {}) + (%~) SCM SCK = Disproved (\ x -> case x of {}) + (%~) SCM SCL = Disproved (\ x -> case x of {}) + (%~) SCM SCM = Proved Refl + (%~) SCM SCN = Disproved (\ x -> case x of {}) + (%~) SCM SCO = Disproved (\ x -> case x of {}) + (%~) SCM SCP = Disproved (\ x -> case x of {}) + (%~) SCM SCQ = Disproved (\ x -> case x of {}) + (%~) SCM SCR = Disproved (\ x -> case x of {}) + (%~) SCM SCS = Disproved (\ x -> case x of {}) + (%~) SCM SCT = Disproved (\ x -> case x of {}) + (%~) SCM SCU = Disproved (\ x -> case x of {}) + (%~) SCM SCV = Disproved (\ x -> case x of {}) + (%~) SCM SCW = Disproved (\ x -> case x of {}) + (%~) SCM SCX = Disproved (\ x -> case x of {}) + (%~) SCM SCY = Disproved (\ x -> case x of {}) + (%~) SCM SCZ = Disproved (\ x -> case x of {}) + (%~) SCN SCA = Disproved (\ x -> case x of {}) + (%~) SCN SCB = Disproved (\ x -> case x of {}) + (%~) SCN SCC = Disproved (\ x -> case x of {}) + (%~) SCN SCD = Disproved (\ x -> case x of {}) + (%~) SCN SCE = Disproved (\ x -> case x of {}) + (%~) SCN SCF = Disproved (\ x -> case x of {}) + (%~) SCN SCG = Disproved (\ x -> case x of {}) + (%~) SCN SCH = Disproved (\ x -> case x of {}) + (%~) SCN SCI = Disproved (\ x -> case x of {}) + (%~) SCN SCJ = Disproved (\ x -> case x of {}) + (%~) SCN SCK = Disproved (\ x -> case x of {}) + (%~) SCN SCL = Disproved (\ x -> case x of {}) + (%~) SCN SCM = Disproved (\ x -> case x of {}) + (%~) SCN SCN = Proved Refl + (%~) SCN SCO = Disproved (\ x -> case x of {}) + (%~) SCN SCP = Disproved (\ x -> case x of {}) + (%~) SCN SCQ = Disproved (\ x -> case x of {}) + (%~) SCN SCR = Disproved (\ x -> case x of {}) + (%~) SCN SCS = Disproved (\ x -> case x of {}) + (%~) SCN SCT = Disproved (\ x -> case x of {}) + (%~) SCN SCU = Disproved (\ x -> case x of {}) + (%~) SCN SCV = Disproved (\ x -> case x of {}) + (%~) SCN SCW = Disproved (\ x -> case x of {}) + (%~) SCN SCX = Disproved (\ x -> case x of {}) + (%~) SCN SCY = Disproved (\ x -> case x of {}) + (%~) SCN SCZ = Disproved (\ x -> case x of {}) + (%~) SCO SCA = Disproved (\ x -> case x of {}) + (%~) SCO SCB = Disproved (\ x -> case x of {}) + (%~) SCO SCC = Disproved (\ x -> case x of {}) + (%~) SCO SCD = Disproved (\ x -> case x of {}) + (%~) SCO SCE = Disproved (\ x -> case x of {}) + (%~) SCO SCF = Disproved (\ x -> case x of {}) + (%~) SCO SCG = Disproved (\ x -> case x of {}) + (%~) SCO SCH = Disproved (\ x -> case x of {}) + (%~) SCO SCI = Disproved (\ x -> case x of {}) + (%~) SCO SCJ = Disproved (\ x -> case x of {}) + (%~) SCO SCK = Disproved (\ x -> case x of {}) + (%~) SCO SCL = Disproved (\ x -> case x of {}) + (%~) SCO SCM = Disproved (\ x -> case x of {}) + (%~) SCO SCN = Disproved (\ x -> case x of {}) + (%~) SCO SCO = Proved Refl + (%~) SCO SCP = Disproved (\ x -> case x of {}) + (%~) SCO SCQ = Disproved (\ x -> case x of {}) + (%~) SCO SCR = Disproved (\ x -> case x of {}) + (%~) SCO SCS = Disproved (\ x -> case x of {}) + (%~) SCO SCT = Disproved (\ x -> case x of {}) + (%~) SCO SCU = Disproved (\ x -> case x of {}) + (%~) SCO SCV = Disproved (\ x -> case x of {}) + (%~) SCO SCW = Disproved (\ x -> case x of {}) + (%~) SCO SCX = Disproved (\ x -> case x of {}) + (%~) SCO SCY = Disproved (\ x -> case x of {}) + (%~) SCO SCZ = Disproved (\ x -> case x of {}) + (%~) SCP SCA = Disproved (\ x -> case x of {}) + (%~) SCP SCB = Disproved (\ x -> case x of {}) + (%~) SCP SCC = Disproved (\ x -> case x of {}) + (%~) SCP SCD = Disproved (\ x -> case x of {}) + (%~) SCP SCE = Disproved (\ x -> case x of {}) + (%~) SCP SCF = Disproved (\ x -> case x of {}) + (%~) SCP SCG = Disproved (\ x -> case x of {}) + (%~) SCP SCH = Disproved (\ x -> case x of {}) + (%~) SCP SCI = Disproved (\ x -> case x of {}) + (%~) SCP SCJ = Disproved (\ x -> case x of {}) + (%~) SCP SCK = Disproved (\ x -> case x of {}) + (%~) SCP SCL = Disproved (\ x -> case x of {}) + (%~) SCP SCM = Disproved (\ x -> case x of {}) + (%~) SCP SCN = Disproved (\ x -> case x of {}) + (%~) SCP SCO = Disproved (\ x -> case x of {}) + (%~) SCP SCP = Proved Refl + (%~) SCP SCQ = Disproved (\ x -> case x of {}) + (%~) SCP SCR = Disproved (\ x -> case x of {}) + (%~) SCP SCS = Disproved (\ x -> case x of {}) + (%~) SCP SCT = Disproved (\ x -> case x of {}) + (%~) SCP SCU = Disproved (\ x -> case x of {}) + (%~) SCP SCV = Disproved (\ x -> case x of {}) + (%~) SCP SCW = Disproved (\ x -> case x of {}) + (%~) SCP SCX = Disproved (\ x -> case x of {}) + (%~) SCP SCY = Disproved (\ x -> case x of {}) + (%~) SCP SCZ = Disproved (\ x -> case x of {}) + (%~) SCQ SCA = Disproved (\ x -> case x of {}) + (%~) SCQ SCB = Disproved (\ x -> case x of {}) + (%~) SCQ SCC = Disproved (\ x -> case x of {}) + (%~) SCQ SCD = Disproved (\ x -> case x of {}) + (%~) SCQ SCE = Disproved (\ x -> case x of {}) + (%~) SCQ SCF = Disproved (\ x -> case x of {}) + (%~) SCQ SCG = Disproved (\ x -> case x of {}) + (%~) SCQ SCH = Disproved (\ x -> case x of {}) + (%~) SCQ SCI = Disproved (\ x -> case x of {}) + (%~) SCQ SCJ = Disproved (\ x -> case x of {}) + (%~) SCQ SCK = Disproved (\ x -> case x of {}) + (%~) SCQ SCL = Disproved (\ x -> case x of {}) + (%~) SCQ SCM = Disproved (\ x -> case x of {}) + (%~) SCQ SCN = Disproved (\ x -> case x of {}) + (%~) SCQ SCO = Disproved (\ x -> case x of {}) + (%~) SCQ SCP = Disproved (\ x -> case x of {}) + (%~) SCQ SCQ = Proved Refl + (%~) SCQ SCR = Disproved (\ x -> case x of {}) + (%~) SCQ SCS = Disproved (\ x -> case x of {}) + (%~) SCQ SCT = Disproved (\ x -> case x of {}) + (%~) SCQ SCU = Disproved (\ x -> case x of {}) + (%~) SCQ SCV = Disproved (\ x -> case x of {}) + (%~) SCQ SCW = Disproved (\ x -> case x of {}) + (%~) SCQ SCX = Disproved (\ x -> case x of {}) + (%~) SCQ SCY = Disproved (\ x -> case x of {}) + (%~) SCQ SCZ = Disproved (\ x -> case x of {}) + (%~) SCR SCA = Disproved (\ x -> case x of {}) + (%~) SCR SCB = Disproved (\ x -> case x of {}) + (%~) SCR SCC = Disproved (\ x -> case x of {}) + (%~) SCR SCD = Disproved (\ x -> case x of {}) + (%~) SCR SCE = Disproved (\ x -> case x of {}) + (%~) SCR SCF = Disproved (\ x -> case x of {}) + (%~) SCR SCG = Disproved (\ x -> case x of {}) + (%~) SCR SCH = Disproved (\ x -> case x of {}) + (%~) SCR SCI = Disproved (\ x -> case x of {}) + (%~) SCR SCJ = Disproved (\ x -> case x of {}) + (%~) SCR SCK = Disproved (\ x -> case x of {}) + (%~) SCR SCL = Disproved (\ x -> case x of {}) + (%~) SCR SCM = Disproved (\ x -> case x of {}) + (%~) SCR SCN = Disproved (\ x -> case x of {}) + (%~) SCR SCO = Disproved (\ x -> case x of {}) + (%~) SCR SCP = Disproved (\ x -> case x of {}) + (%~) SCR SCQ = Disproved (\ x -> case x of {}) + (%~) SCR SCR = Proved Refl + (%~) SCR SCS = Disproved (\ x -> case x of {}) + (%~) SCR SCT = Disproved (\ x -> case x of {}) + (%~) SCR SCU = Disproved (\ x -> case x of {}) + (%~) SCR SCV = Disproved (\ x -> case x of {}) + (%~) SCR SCW = Disproved (\ x -> case x of {}) + (%~) SCR SCX = Disproved (\ x -> case x of {}) + (%~) SCR SCY = Disproved (\ x -> case x of {}) + (%~) SCR SCZ = Disproved (\ x -> case x of {}) + (%~) SCS SCA = Disproved (\ x -> case x of {}) + (%~) SCS SCB = Disproved (\ x -> case x of {}) + (%~) SCS SCC = Disproved (\ x -> case x of {}) + (%~) SCS SCD = Disproved (\ x -> case x of {}) + (%~) SCS SCE = Disproved (\ x -> case x of {}) + (%~) SCS SCF = Disproved (\ x -> case x of {}) + (%~) SCS SCG = Disproved (\ x -> case x of {}) + (%~) SCS SCH = Disproved (\ x -> case x of {}) + (%~) SCS SCI = Disproved (\ x -> case x of {}) + (%~) SCS SCJ = Disproved (\ x -> case x of {}) + (%~) SCS SCK = Disproved (\ x -> case x of {}) + (%~) SCS SCL = Disproved (\ x -> case x of {}) + (%~) SCS SCM = Disproved (\ x -> case x of {}) + (%~) SCS SCN = Disproved (\ x -> case x of {}) + (%~) SCS SCO = Disproved (\ x -> case x of {}) + (%~) SCS SCP = Disproved (\ x -> case x of {}) + (%~) SCS SCQ = Disproved (\ x -> case x of {}) + (%~) SCS SCR = Disproved (\ x -> case x of {}) + (%~) SCS SCS = Proved Refl + (%~) SCS SCT = Disproved (\ x -> case x of {}) + (%~) SCS SCU = Disproved (\ x -> case x of {}) + (%~) SCS SCV = Disproved (\ x -> case x of {}) + (%~) SCS SCW = Disproved (\ x -> case x of {}) + (%~) SCS SCX = Disproved (\ x -> case x of {}) + (%~) SCS SCY = Disproved (\ x -> case x of {}) + (%~) SCS SCZ = Disproved (\ x -> case x of {}) + (%~) SCT SCA = Disproved (\ x -> case x of {}) + (%~) SCT SCB = Disproved (\ x -> case x of {}) + (%~) SCT SCC = Disproved (\ x -> case x of {}) + (%~) SCT SCD = Disproved (\ x -> case x of {}) + (%~) SCT SCE = Disproved (\ x -> case x of {}) + (%~) SCT SCF = Disproved (\ x -> case x of {}) + (%~) SCT SCG = Disproved (\ x -> case x of {}) + (%~) SCT SCH = Disproved (\ x -> case x of {}) + (%~) SCT SCI = Disproved (\ x -> case x of {}) + (%~) SCT SCJ = Disproved (\ x -> case x of {}) + (%~) SCT SCK = Disproved (\ x -> case x of {}) + (%~) SCT SCL = Disproved (\ x -> case x of {}) + (%~) SCT SCM = Disproved (\ x -> case x of {}) + (%~) SCT SCN = Disproved (\ x -> case x of {}) + (%~) SCT SCO = Disproved (\ x -> case x of {}) + (%~) SCT SCP = Disproved (\ x -> case x of {}) + (%~) SCT SCQ = Disproved (\ x -> case x of {}) + (%~) SCT SCR = Disproved (\ x -> case x of {}) + (%~) SCT SCS = Disproved (\ x -> case x of {}) + (%~) SCT SCT = Proved Refl + (%~) SCT SCU = Disproved (\ x -> case x of {}) + (%~) SCT SCV = Disproved (\ x -> case x of {}) + (%~) SCT SCW = Disproved (\ x -> case x of {}) + (%~) SCT SCX = Disproved (\ x -> case x of {}) + (%~) SCT SCY = Disproved (\ x -> case x of {}) + (%~) SCT SCZ = Disproved (\ x -> case x of {}) + (%~) SCU SCA = Disproved (\ x -> case x of {}) + (%~) SCU SCB = Disproved (\ x -> case x of {}) + (%~) SCU SCC = Disproved (\ x -> case x of {}) + (%~) SCU SCD = Disproved (\ x -> case x of {}) + (%~) SCU SCE = Disproved (\ x -> case x of {}) + (%~) SCU SCF = Disproved (\ x -> case x of {}) + (%~) SCU SCG = Disproved (\ x -> case x of {}) + (%~) SCU SCH = Disproved (\ x -> case x of {}) + (%~) SCU SCI = Disproved (\ x -> case x of {}) + (%~) SCU SCJ = Disproved (\ x -> case x of {}) + (%~) SCU SCK = Disproved (\ x -> case x of {}) + (%~) SCU SCL = Disproved (\ x -> case x of {}) + (%~) SCU SCM = Disproved (\ x -> case x of {}) + (%~) SCU SCN = Disproved (\ x -> case x of {}) + (%~) SCU SCO = Disproved (\ x -> case x of {}) + (%~) SCU SCP = Disproved (\ x -> case x of {}) + (%~) SCU SCQ = Disproved (\ x -> case x of {}) + (%~) SCU SCR = Disproved (\ x -> case x of {}) + (%~) SCU SCS = Disproved (\ x -> case x of {}) + (%~) SCU SCT = Disproved (\ x -> case x of {}) + (%~) SCU SCU = Proved Refl + (%~) SCU SCV = Disproved (\ x -> case x of {}) + (%~) SCU SCW = Disproved (\ x -> case x of {}) + (%~) SCU SCX = Disproved (\ x -> case x of {}) + (%~) SCU SCY = Disproved (\ x -> case x of {}) + (%~) SCU SCZ = Disproved (\ x -> case x of {}) + (%~) SCV SCA = Disproved (\ x -> case x of {}) + (%~) SCV SCB = Disproved (\ x -> case x of {}) + (%~) SCV SCC = Disproved (\ x -> case x of {}) + (%~) SCV SCD = Disproved (\ x -> case x of {}) + (%~) SCV SCE = Disproved (\ x -> case x of {}) + (%~) SCV SCF = Disproved (\ x -> case x of {}) + (%~) SCV SCG = Disproved (\ x -> case x of {}) + (%~) SCV SCH = Disproved (\ x -> case x of {}) + (%~) SCV SCI = Disproved (\ x -> case x of {}) + (%~) SCV SCJ = Disproved (\ x -> case x of {}) + (%~) SCV SCK = Disproved (\ x -> case x of {}) + (%~) SCV SCL = Disproved (\ x -> case x of {}) + (%~) SCV SCM = Disproved (\ x -> case x of {}) + (%~) SCV SCN = Disproved (\ x -> case x of {}) + (%~) SCV SCO = Disproved (\ x -> case x of {}) + (%~) SCV SCP = Disproved (\ x -> case x of {}) + (%~) SCV SCQ = Disproved (\ x -> case x of {}) + (%~) SCV SCR = Disproved (\ x -> case x of {}) + (%~) SCV SCS = Disproved (\ x -> case x of {}) + (%~) SCV SCT = Disproved (\ x -> case x of {}) + (%~) SCV SCU = Disproved (\ x -> case x of {}) + (%~) SCV SCV = Proved Refl + (%~) SCV SCW = Disproved (\ x -> case x of {}) + (%~) SCV SCX = Disproved (\ x -> case x of {}) + (%~) SCV SCY = Disproved (\ x -> case x of {}) + (%~) SCV SCZ = Disproved (\ x -> case x of {}) + (%~) SCW SCA = Disproved (\ x -> case x of {}) + (%~) SCW SCB = Disproved (\ x -> case x of {}) + (%~) SCW SCC = Disproved (\ x -> case x of {}) + (%~) SCW SCD = Disproved (\ x -> case x of {}) + (%~) SCW SCE = Disproved (\ x -> case x of {}) + (%~) SCW SCF = Disproved (\ x -> case x of {}) + (%~) SCW SCG = Disproved (\ x -> case x of {}) + (%~) SCW SCH = Disproved (\ x -> case x of {}) + (%~) SCW SCI = Disproved (\ x -> case x of {}) + (%~) SCW SCJ = Disproved (\ x -> case x of {}) + (%~) SCW SCK = Disproved (\ x -> case x of {}) + (%~) SCW SCL = Disproved (\ x -> case x of {}) + (%~) SCW SCM = Disproved (\ x -> case x of {}) + (%~) SCW SCN = Disproved (\ x -> case x of {}) + (%~) SCW SCO = Disproved (\ x -> case x of {}) + (%~) SCW SCP = Disproved (\ x -> case x of {}) + (%~) SCW SCQ = Disproved (\ x -> case x of {}) + (%~) SCW SCR = Disproved (\ x -> case x of {}) + (%~) SCW SCS = Disproved (\ x -> case x of {}) + (%~) SCW SCT = Disproved (\ x -> case x of {}) + (%~) SCW SCU = Disproved (\ x -> case x of {}) + (%~) SCW SCV = Disproved (\ x -> case x of {}) + (%~) SCW SCW = Proved Refl + (%~) SCW SCX = Disproved (\ x -> case x of {}) + (%~) SCW SCY = Disproved (\ x -> case x of {}) + (%~) SCW SCZ = Disproved (\ x -> case x of {}) + (%~) SCX SCA = Disproved (\ x -> case x of {}) + (%~) SCX SCB = Disproved (\ x -> case x of {}) + (%~) SCX SCC = Disproved (\ x -> case x of {}) + (%~) SCX SCD = Disproved (\ x -> case x of {}) + (%~) SCX SCE = Disproved (\ x -> case x of {}) + (%~) SCX SCF = Disproved (\ x -> case x of {}) + (%~) SCX SCG = Disproved (\ x -> case x of {}) + (%~) SCX SCH = Disproved (\ x -> case x of {}) + (%~) SCX SCI = Disproved (\ x -> case x of {}) + (%~) SCX SCJ = Disproved (\ x -> case x of {}) + (%~) SCX SCK = Disproved (\ x -> case x of {}) + (%~) SCX SCL = Disproved (\ x -> case x of {}) + (%~) SCX SCM = Disproved (\ x -> case x of {}) + (%~) SCX SCN = Disproved (\ x -> case x of {}) + (%~) SCX SCO = Disproved (\ x -> case x of {}) + (%~) SCX SCP = Disproved (\ x -> case x of {}) + (%~) SCX SCQ = Disproved (\ x -> case x of {}) + (%~) SCX SCR = Disproved (\ x -> case x of {}) + (%~) SCX SCS = Disproved (\ x -> case x of {}) + (%~) SCX SCT = Disproved (\ x -> case x of {}) + (%~) SCX SCU = Disproved (\ x -> case x of {}) + (%~) SCX SCV = Disproved (\ x -> case x of {}) + (%~) SCX SCW = Disproved (\ x -> case x of {}) + (%~) SCX SCX = Proved Refl + (%~) SCX SCY = Disproved (\ x -> case x of {}) + (%~) SCX SCZ = Disproved (\ x -> case x of {}) + (%~) SCY SCA = Disproved (\ x -> case x of {}) + (%~) SCY SCB = Disproved (\ x -> case x of {}) + (%~) SCY SCC = Disproved (\ x -> case x of {}) + (%~) SCY SCD = Disproved (\ x -> case x of {}) + (%~) SCY SCE = Disproved (\ x -> case x of {}) + (%~) SCY SCF = Disproved (\ x -> case x of {}) + (%~) SCY SCG = Disproved (\ x -> case x of {}) + (%~) SCY SCH = Disproved (\ x -> case x of {}) + (%~) SCY SCI = Disproved (\ x -> case x of {}) + (%~) SCY SCJ = Disproved (\ x -> case x of {}) + (%~) SCY SCK = Disproved (\ x -> case x of {}) + (%~) SCY SCL = Disproved (\ x -> case x of {}) + (%~) SCY SCM = Disproved (\ x -> case x of {}) + (%~) SCY SCN = Disproved (\ x -> case x of {}) + (%~) SCY SCO = Disproved (\ x -> case x of {}) + (%~) SCY SCP = Disproved (\ x -> case x of {}) + (%~) SCY SCQ = Disproved (\ x -> case x of {}) + (%~) SCY SCR = Disproved (\ x -> case x of {}) + (%~) SCY SCS = Disproved (\ x -> case x of {}) + (%~) SCY SCT = Disproved (\ x -> case x of {}) + (%~) SCY SCU = Disproved (\ x -> case x of {}) + (%~) SCY SCV = Disproved (\ x -> case x of {}) + (%~) SCY SCW = Disproved (\ x -> case x of {}) + (%~) SCY SCX = Disproved (\ x -> case x of {}) + (%~) SCY SCY = Proved Refl + (%~) SCY SCZ = Disproved (\ x -> case x of {}) + (%~) SCZ SCA = Disproved (\ x -> case x of {}) + (%~) SCZ SCB = Disproved (\ x -> case x of {}) + (%~) SCZ SCC = Disproved (\ x -> case x of {}) + (%~) SCZ SCD = Disproved (\ x -> case x of {}) + (%~) SCZ SCE = Disproved (\ x -> case x of {}) + (%~) SCZ SCF = Disproved (\ x -> case x of {}) + (%~) SCZ SCG = Disproved (\ x -> case x of {}) + (%~) SCZ SCH = Disproved (\ x -> case x of {}) + (%~) SCZ SCI = Disproved (\ x -> case x of {}) + (%~) SCZ SCJ = Disproved (\ x -> case x of {}) + (%~) SCZ SCK = Disproved (\ x -> case x of {}) + (%~) SCZ SCL = Disproved (\ x -> case x of {}) + (%~) SCZ SCM = Disproved (\ x -> case x of {}) + (%~) SCZ SCN = Disproved (\ x -> case x of {}) + (%~) SCZ SCO = Disproved (\ x -> case x of {}) + (%~) SCZ SCP = Disproved (\ x -> case x of {}) + (%~) SCZ SCQ = Disproved (\ x -> case x of {}) + (%~) SCZ SCR = Disproved (\ x -> case x of {}) + (%~) SCZ SCS = Disproved (\ x -> case x of {}) + (%~) SCZ SCT = Disproved (\ x -> case x of {}) + (%~) SCZ SCU = Disproved (\ x -> case x of {}) + (%~) SCZ SCV = Disproved (\ x -> case x of {}) + (%~) SCZ SCW = Disproved (\ x -> case x of {}) + (%~) SCZ SCX = Disproved (\ x -> case x of {}) + (%~) SCZ SCY = Disproved (\ x -> case x of {}) + (%~) SCZ SCZ = Proved Refl + instance Data.Type.Equality.TestEquality (SAChar :: AChar + -> Type) where + Data.Type.Equality.testEquality + = Data.Singletons.Decide.decideEquality + instance Data.Type.Coercion.TestCoercion (SAChar :: AChar + -> Type) where + Data.Type.Coercion.testCoercion + = Data.Singletons.Decide.decideCoercion + deriving instance (Data.Singletons.ShowSing.ShowSing U, + Data.Singletons.ShowSing.ShowSing Nat) => + Show (SU (z :: U)) + deriving instance Show (SAChar (z :: AChar)) + instance SingI BOOL where + sing = SBOOL + instance SingI STRING where + sing = SSTRING + instance SingI NAT where + sing = SNAT + instance (SingI n, SingI n) => + SingI (VEC (n :: U) (n :: Nat)) where + sing = (SVEC sing) sing + instance SingI n => SingI1 (VEC (n :: U)) where + liftSing = SVEC sing + instance SingI2 VEC where + liftSing2 = SVEC + instance SingI (VECSym0 :: (~>) U ((~>) Nat U)) where + sing = (singFun2 @VECSym0) SVEC + instance SingI d => SingI (VECSym1 (d :: U) :: (~>) Nat U) where + sing = (singFun1 @(VECSym1 (d :: U))) (SVEC (sing @d)) + instance SingI1 (VECSym1 :: U -> (~>) Nat U) where + liftSing (s :: Sing (d :: U)) + = (singFun1 @(VECSym1 (d :: U))) (SVEC s) + instance SingI CA where + sing = SCA + instance SingI CB where + sing = SCB + instance SingI CC where + sing = SCC + instance SingI CD where + sing = SCD + instance SingI CE where + sing = SCE + instance SingI CF where + sing = SCF + instance SingI CG where + sing = SCG + instance SingI CH where + sing = SCH + instance SingI CI where + sing = SCI + instance SingI CJ where + sing = SCJ + instance SingI CK where + sing = SCK + instance SingI CL where + sing = SCL + instance SingI CM where + sing = SCM + instance SingI CN where + sing = SCN + instance SingI CO where + sing = SCO + instance SingI CP where + sing = SCP + instance SingI CQ where + sing = SCQ + instance SingI CR where + sing = SCR + instance SingI CS where + sing = SCS + instance SingI CT where + sing = SCT + instance SingI CU where + sing = SCU + instance SingI CV where + sing = SCV + instance SingI CW where + sing = SCW + instance SingI CX where + sing = SCX + instance SingI CY where + sing = SCY + instance SingI CZ where + sing = SCZ + instance (SingI n, SingI n) => + SingI (Attr (n :: [AChar]) (n :: U)) where + sing = (SAttr sing) sing + instance SingI n => SingI1 (Attr (n :: [AChar])) where + liftSing = SAttr sing + instance SingI2 Attr where + liftSing2 = SAttr + instance SingI (AttrSym0 :: (~>) [AChar] ((~>) U Attribute)) where + sing = (singFun2 @AttrSym0) SAttr + instance SingI d => + SingI (AttrSym1 (d :: [AChar]) :: (~>) U Attribute) where + sing = (singFun1 @(AttrSym1 (d :: [AChar]))) (SAttr (sing @d)) + instance SingI1 (AttrSym1 :: [AChar] -> (~>) U Attribute) where + liftSing (s :: Sing (d :: [AChar])) + = (singFun1 @(AttrSym1 (d :: [AChar]))) (SAttr s) + instance SingI n => SingI (Sch (n :: [Attribute])) where + sing = SSch sing + instance SingI1 Sch where + liftSing = SSch instance SingI (SchSym0 :: (~>) [Attribute] Schema) where sing = (singFun1 @SchSym0) SSch GradingClient/Database.hs:0:0:: Splicing declarations diff --git a/tests/compile-and-dump/GradingClient/Database.hs b/tests/compile-and-dump/GradingClient/Database.hs --- a/tests/compile-and-dump/GradingClient/Database.hs +++ b/tests/compile-and-dump/GradingClient/Database.hs @@ -25,7 +25,7 @@ import Control.Monad import Control.Monad.Except ( throwError ) import Data.Kind (Type) -import Data.List hiding ( tail ) +import qualified Data.List as List import Data.Singletons.Base.TH import Prelude hiding ( tail, id ) import Prelude.Singletons hiding ( Lookup, sLookup, LookupSym0, LookupSym1, LookupSym2 ) @@ -434,11 +434,11 @@ query (Union ra rb) = do rowsa <- query ra rowsb <- query rb - return $ unionBy eqRow rowsa rowsb + return $ List.unionBy eqRow rowsa rowsb query (Diff ra rb) = do rowsa <- query ra rowsb <- query rb - return $ deleteFirstsBy eqRow rowsa rowsb + return $ List.deleteFirstsBy eqRow rowsa rowsb query (Product ra rb) = do rowsa <- query ra rowsb <- query rb diff --git a/tests/compile-and-dump/InsertionSort/InsertionSortImp.golden b/tests/compile-and-dump/InsertionSort/InsertionSortImp.golden --- a/tests/compile-and-dump/InsertionSort/InsertionSortImp.golden +++ b/tests/compile-and-dump/InsertionSort/InsertionSortImp.golden @@ -27,12 +27,13 @@ fromSing (SSucc b) = Succ (fromSing b) toSing Zero = SomeSing SZero toSing (Succ (b :: Demote Nat)) - = case toSing b :: SomeSing Nat of { - SomeSing c -> SomeSing (SSucc c) } + = case toSing b :: SomeSing Nat of SomeSing c -> SomeSing (SSucc c) instance SingI Zero where sing = SZero instance SingI n => SingI (Succ (n :: Nat)) where sing = SSucc sing + instance SingI1 Succ where + liftSing = SSucc instance SingI (SuccSym0 :: (~>) Nat Nat) where sing = (singFun1 @SuccSym0) SSucc InsertionSort/InsertionSortImp.hs:(0,0)-(0,0): Splicing declarations @@ -164,14 +165,14 @@ Leq ('Succ _) 'Zero = FalseSym0 Leq ('Succ a) ('Succ b) = Apply (Apply LeqSym0 a) b sInsertionSort :: - forall (t :: [Nat]). - Sing t -> Sing (Apply InsertionSortSym0 t :: [Nat]) + forall (t :: [Nat]). Sing t + -> Sing (Apply InsertionSortSym0 t :: [Nat]) sInsert :: - forall (t :: Nat) (t :: [Nat]). - Sing t -> Sing t -> Sing (Apply (Apply InsertSym0 t) t :: [Nat]) + forall (t :: Nat) (t :: [Nat]). Sing t + -> Sing t -> Sing (Apply (Apply InsertSym0 t) t :: [Nat]) sLeq :: - forall (t :: Nat) (t :: Nat). - Sing t -> Sing t -> Sing (Apply (Apply LeqSym0 t) t :: Bool) + forall (t :: Nat) (t :: Nat). Sing t + -> Sing t -> Sing (Apply (Apply LeqSym0 t) t :: Bool) sInsertionSort SNil = SNil sInsertionSort (SCons (sH :: Sing h) (sT :: Sing t)) = (applySing ((applySing ((singFun2 @InsertSym0) sInsert)) sH)) @@ -205,8 +206,14 @@ instance SingI d => SingI (InsertSym1 (d :: Nat) :: (~>) [Nat] [Nat]) where sing = (singFun1 @(InsertSym1 (d :: Nat))) (sInsert (sing @d)) + instance SingI1 (InsertSym1 :: Nat -> (~>) [Nat] [Nat]) where + liftSing (s :: Sing (d :: Nat)) + = (singFun1 @(InsertSym1 (d :: Nat))) (sInsert s) instance SingI (LeqSym0 :: (~>) Nat ((~>) Nat Bool)) where sing = (singFun2 @LeqSym0) sLeq instance SingI d => SingI (LeqSym1 (d :: Nat) :: (~>) Nat Bool) where sing = (singFun1 @(LeqSym1 (d :: Nat))) (sLeq (sing @d)) + instance SingI1 (LeqSym1 :: Nat -> (~>) Nat Bool) where + liftSing (s :: Sing (d :: Nat)) + = (singFun1 @(LeqSym1 (d :: Nat))) (sLeq s) diff --git a/tests/compile-and-dump/Promote/GenDefunSymbols.golden b/tests/compile-and-dump/Promote/GenDefunSymbols.golden --- a/tests/compile-and-dump/Promote/GenDefunSymbols.golden +++ b/tests/compile-and-dump/Promote/GenDefunSymbols.golden @@ -1,8 +1,8 @@ Promote/GenDefunSymbols.hs:0:0:: Splicing declarations genDefunSymbols [''LiftMaybe, ''NatT, ''(:+)] ======> - type LiftMaybeSym0 :: forall (a :: Type) (b :: Type). - (~>) ((~>) a b) ((~>) (Maybe a) (Maybe b)) + type LiftMaybeSym0 :: forall (a :: Type) + (b :: Type). (~>) ((~>) a b) ((~>) (Maybe a) (Maybe b)) data LiftMaybeSym0 :: (~>) ((~>) a b) ((~>) (Maybe a) (Maybe b)) where LiftMaybeSym0KindInference :: Data.Singletons.SameKind (Apply LiftMaybeSym0 arg) (LiftMaybeSym1 arg) => @@ -11,8 +11,8 @@ instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings LiftMaybeSym0 where Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings = snd (((,) LiftMaybeSym0KindInference) ()) - type LiftMaybeSym1 :: forall (a :: Type) (b :: Type). - (~>) a b -> (~>) (Maybe a) (Maybe b) + type LiftMaybeSym1 :: forall (a :: Type) (b :: Type). (~>) a b + -> (~>) (Maybe a) (Maybe b) data LiftMaybeSym1 (a0123456789876543210 :: (~>) a b) :: (~>) (Maybe a) (Maybe b) where LiftMaybeSym1KindInference :: Data.Singletons.SameKind (Apply (LiftMaybeSym1 a0123456789876543210) arg) (LiftMaybeSym2 a0123456789876543210 arg) => @@ -21,8 +21,8 @@ instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings (LiftMaybeSym1 a0123456789876543210) where Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings = snd (((,) LiftMaybeSym1KindInference) ()) - type LiftMaybeSym2 :: forall (a :: Type) (b :: Type). - (~>) a b -> Maybe a -> Maybe b + type LiftMaybeSym2 :: forall (a :: Type) (b :: Type). (~>) a b + -> Maybe a -> Maybe b type family LiftMaybeSym2 (a0123456789876543210 :: (~>) a b) (a0123456789876543210 :: Maybe a) :: Maybe b where LiftMaybeSym2 a0123456789876543210 a0123456789876543210 = LiftMaybe a0123456789876543210 a0123456789876543210 type ZeroSym0 :: NatT @@ -40,8 +40,8 @@ type SuccSym1 :: NatT -> NatT type family SuccSym1 (a0123456789876543210 :: NatT) :: NatT where SuccSym1 a0123456789876543210 = 'Succ a0123456789876543210 - type (:+@#@$) :: (~>) Nat ((~>) Nat Nat) - data (:+@#@$) :: (~>) Nat ((~>) Nat Nat) + type (:+@#@$) :: (~>) Natural ((~>) Natural Natural) + data (:+@#@$) :: (~>) Natural ((~>) Natural Natural) where (::+@#@$###) :: Data.Singletons.SameKind (Apply (:+@#@$) arg) ((:+@#@$$) arg) => (:+@#@$) a0123456789876543210 @@ -49,8 +49,8 @@ instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings (:+@#@$) where Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings = snd (((,) (::+@#@$###)) ()) - type (:+@#@$$) :: Nat -> (~>) Nat Nat - data (:+@#@$$) (a0123456789876543210 :: Nat) :: (~>) Nat Nat + type (:+@#@$$) :: Natural -> (~>) Natural Natural + data (:+@#@$$) (a0123456789876543210 :: Natural) :: (~>) Natural Natural where (::+@#@$$###) :: Data.Singletons.SameKind (Apply ((:+@#@$$) a0123456789876543210) arg) ((:+@#@$$$) a0123456789876543210 arg) => (:+@#@$$) a0123456789876543210 a0123456789876543210 @@ -58,6 +58,6 @@ instance Data.Singletons.TH.SuppressUnusedWarnings.SuppressUnusedWarnings ((:+@#@$$) a0123456789876543210) where Data.Singletons.TH.SuppressUnusedWarnings.suppressUnusedWarnings = snd (((,) (::+@#@$$###)) ()) - type (:+@#@$$$) :: Nat -> Nat -> Nat - type family (:+@#@$$$) (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where + type (:+@#@$$$) :: Natural -> Natural -> Natural + type family (:+@#@$$$) (a0123456789876543210 :: Natural) (a0123456789876543210 :: Natural) :: Natural where (:+@#@$$$) a0123456789876543210 a0123456789876543210 = (:+) a0123456789876543210 a0123456789876543210 diff --git a/tests/compile-and-dump/Promote/Newtypes.golden b/tests/compile-and-dump/Promote/Newtypes.golden --- a/tests/compile-and-dump/Promote/Newtypes.golden +++ b/tests/compile-and-dump/Promote/Newtypes.golden @@ -2,7 +2,7 @@ promote [d| newtype Foo = Foo Nat - deriving Eq + deriving (Eq) newtype Bar = Bar {unBar :: Nat} |] ======> newtype Foo diff --git a/tests/compile-and-dump/Promote/Prelude.golden b/tests/compile-and-dump/Promote/Prelude.golden --- a/tests/compile-and-dump/Promote/Prelude.golden +++ b/tests/compile-and-dump/Promote/Prelude.golden @@ -1,21 +1,21 @@ Promote/Prelude.hs:(0,0)-(0,0): Splicing declarations promoteOnly - [d| odd :: Nat -> Bool + [d| odd :: Natural -> Bool odd 0 = False odd n = not . odd $ n - 1 |] ======> - type OddSym0 :: (~>) Nat Bool - data OddSym0 :: (~>) Nat Bool + type OddSym0 :: (~>) Natural Bool + data OddSym0 :: (~>) Natural Bool where OddSym0KindInference :: SameKind (Apply OddSym0 arg) (OddSym1 arg) => OddSym0 a0123456789876543210 type instance Apply OddSym0 a0123456789876543210 = Odd a0123456789876543210 instance SuppressUnusedWarnings OddSym0 where suppressUnusedWarnings = snd (((,) OddSym0KindInference) ()) - type OddSym1 :: Nat -> Bool - type family OddSym1 (a0123456789876543210 :: Nat) :: Bool where + type OddSym1 :: Natural -> Bool + type family OddSym1 (a0123456789876543210 :: Natural) :: Bool where OddSym1 a0123456789876543210 = Odd a0123456789876543210 - type Odd :: Nat -> Bool - type family Odd (a :: Nat) :: Bool where + type Odd :: Natural -> Bool + type family Odd (a :: Natural) :: Bool where Odd 0 = FalseSym0 Odd n = Apply (Apply ($@#@$) (Apply (Apply (.@#@$) NotSym0) OddSym0)) (Apply (Apply (-@#@$) n) (FromInteger 1)) diff --git a/tests/compile-and-dump/Promote/Prelude.hs b/tests/compile-and-dump/Promote/Prelude.hs --- a/tests/compile-and-dump/Promote/Prelude.hs +++ b/tests/compile-and-dump/Promote/Prelude.hs @@ -102,7 +102,7 @@ replicateTest2b = Proxy $(promoteOnly [d| - odd :: Nat -> Bool + odd :: Natural -> Bool odd 0 = False odd n = not . odd $ n - 1 |]) diff --git a/tests/compile-and-dump/Singletons/AsPattern.golden b/tests/compile-and-dump/Singletons/AsPattern.golden --- a/tests/compile-and-dump/Singletons/AsPattern.golden +++ b/tests/compile-and-dump/Singletons/AsPattern.golden @@ -253,17 +253,17 @@ sFoo :: forall (t :: [Nat]). Sing t -> Sing (Apply FooSym0 t :: [Nat]) sTup :: - forall (t :: (Nat, Nat)). - Sing t -> Sing (Apply TupSym0 t :: (Nat, Nat)) + forall (t :: (Nat, Nat)). Sing t + -> Sing (Apply TupSym0 t :: (Nat, Nat)) sBaz_ :: - forall (t :: Maybe Baz). - Sing t -> Sing (Apply Baz_Sym0 t :: Maybe Baz) + forall (t :: Maybe Baz). Sing t + -> Sing (Apply Baz_Sym0 t :: Maybe Baz) sBar :: - forall (t :: Maybe Nat). - Sing t -> Sing (Apply BarSym0 t :: Maybe Nat) + forall (t :: Maybe Nat). Sing t + -> Sing (Apply BarSym0 t :: Maybe Nat) sMaybePlus :: - forall (t :: Maybe Nat). - Sing t -> Sing (Apply MaybePlusSym0 t :: Maybe Nat) + forall (t :: Maybe Nat). Sing t + -> Sing (Apply MaybePlusSym0 t :: Maybe Nat) sFoo SNil = let sP :: Sing @_ Let0123456789876543210PSym0 @@ -373,19 +373,34 @@ = case (((,,) (toSing b :: SomeSing Nat)) (toSing b :: SomeSing Nat)) (toSing b :: SomeSing Nat) - of { + of (,,) (SomeSing c) (SomeSing c) (SomeSing c) - -> SomeSing (((SBaz c) c) c) } + -> SomeSing (((SBaz c) c) c) instance (SingI n, SingI n, SingI n) => SingI (Baz (n :: Nat) (n :: Nat) (n :: Nat)) where sing = ((SBaz sing) sing) sing + instance (SingI n, SingI n) => + SingI1 (Baz (n :: Nat) (n :: Nat)) where + liftSing = (SBaz sing) sing + instance SingI n => SingI2 (Baz (n :: Nat)) where + liftSing2 = SBaz sing instance SingI (BazSym0 :: (~>) Nat ((~>) Nat ((~>) Nat Baz))) where sing = (singFun3 @BazSym0) SBaz instance SingI d => SingI (BazSym1 (d :: Nat) :: (~>) Nat ((~>) Nat Baz)) where sing = (singFun2 @(BazSym1 (d :: Nat))) (SBaz (sing @d)) + instance SingI1 (BazSym1 :: Nat -> (~>) Nat ((~>) Nat Baz)) where + liftSing (s :: Sing (d :: Nat)) + = (singFun2 @(BazSym1 (d :: Nat))) (SBaz s) instance (SingI d, SingI d) => SingI (BazSym2 (d :: Nat) (d :: Nat) :: (~>) Nat Baz) where sing = (singFun1 @(BazSym2 (d :: Nat) (d :: Nat))) ((SBaz (sing @d)) (sing @d)) + instance SingI d => + SingI1 (BazSym2 (d :: Nat) :: Nat -> (~>) Nat Baz) where + liftSing (s :: Sing (d :: Nat)) + = (singFun1 @(BazSym2 (d :: Nat) (d :: Nat))) ((SBaz (sing @d)) s) + instance SingI2 (BazSym2 :: Nat -> Nat -> (~>) Nat Baz) where + liftSing2 (s :: Sing (d :: Nat)) (s :: Sing (d :: Nat)) + = (singFun1 @(BazSym2 (d :: Nat) (d :: Nat))) ((SBaz s) s) diff --git a/tests/compile-and-dump/Singletons/BoundedDeriving.golden b/tests/compile-and-dump/Singletons/BoundedDeriving.golden --- a/tests/compile-and-dump/Singletons/BoundedDeriving.golden +++ b/tests/compile-and-dump/Singletons/BoundedDeriving.golden @@ -2,13 +2,13 @@ singletons [d| data Foo1 = Foo1 - deriving Bounded + deriving (Bounded) data Foo2 = A | B | C | D | E - deriving Bounded + deriving (Bounded) data Foo3 a = Foo3 a - deriving Bounded + deriving (Bounded) data Foo4 (a :: Type) (b :: Type) = Foo41 | Foo42 deriving Bounded @@ -60,12 +60,12 @@ type Foo3Sym1 :: forall a. a -> Foo3 a type family Foo3Sym1 (a0123456789876543210 :: a) :: Foo3 a where Foo3Sym1 a0123456789876543210 = Foo3 a0123456789876543210 - type Foo41Sym0 :: forall (a :: Type) (b :: Type). - Foo4 (a :: Type) (b :: Type) + type Foo41Sym0 :: forall (a :: Type) + (b :: Type). Foo4 (a :: Type) (b :: Type) type family Foo41Sym0 :: Foo4 (a :: Type) (b :: Type) where Foo41Sym0 = Foo41 - type Foo42Sym0 :: forall (a :: Type) (b :: Type). - Foo4 (a :: Type) (b :: Type) + type Foo42Sym0 :: forall (a :: Type) + (b :: Type). Foo4 (a :: Type) (b :: Type) type family Foo42Sym0 :: Foo4 (a :: Type) (b :: Type) where Foo42Sym0 = Foo42 type PairSym0 :: (~>) Bool ((~>) Bool Pair) @@ -196,8 +196,7 @@ type Demote (Foo3 a) = Foo3 (Demote a) fromSing (SFoo3 b) = Foo3 (fromSing b) toSing (Foo3 (b :: Demote a)) - = case toSing b :: SomeSing a of { - SomeSing c -> SomeSing (SFoo3 c) } + = case toSing b :: SomeSing a of SomeSing c -> SomeSing (SFoo3 c) data SFoo4 :: forall (a :: Type) (b :: Type). Foo4 a b -> Type where SFoo41 :: forall (a :: Type) (b :: Type). @@ -222,8 +221,8 @@ toSing (Pair (b :: Demote Bool) (b :: Demote Bool)) = case ((,) (toSing b :: SomeSing Bool)) (toSing b :: SomeSing Bool) - of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SPair c) c) } + of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SPair c) c) instance SBounded Foo1 where sMinBound :: Sing (MinBoundSym0 :: Foo1) sMaxBound :: Sing (MaxBoundSym0 :: Foo1) @@ -267,6 +266,8 @@ sing = SE instance SingI n => SingI (Foo3 (n :: a)) where sing = SFoo3 sing + instance SingI1 Foo3 where + liftSing = SFoo3 instance SingI (Foo3Sym0 :: (~>) a (Foo3 a)) where sing = (singFun1 @Foo3Sym0) SFoo3 instance SingI Foo41 where @@ -276,8 +277,15 @@ instance (SingI n, SingI n) => SingI (Pair (n :: Bool) (n :: Bool)) where sing = (SPair sing) sing + instance SingI n => SingI1 (Pair (n :: Bool)) where + liftSing = SPair sing + instance SingI2 Pair where + liftSing2 = SPair instance SingI (PairSym0 :: (~>) Bool ((~>) Bool Pair)) where sing = (singFun2 @PairSym0) SPair instance SingI d => SingI (PairSym1 (d :: Bool) :: (~>) Bool Pair) where sing = (singFun1 @(PairSym1 (d :: Bool))) (SPair (sing @d)) + instance SingI1 (PairSym1 :: Bool -> (~>) Bool Pair) where + liftSing (s :: Sing (d :: Bool)) + = (singFun1 @(PairSym1 (d :: Bool))) (SPair s) diff --git a/tests/compile-and-dump/Singletons/BoxUnBox.golden b/tests/compile-and-dump/Singletons/BoxUnBox.golden --- a/tests/compile-and-dump/Singletons/BoxUnBox.golden +++ b/tests/compile-and-dump/Singletons/BoxUnBox.golden @@ -46,9 +46,10 @@ type Demote (Box a) = Box (Demote a) fromSing (SFBox b) = FBox (fromSing b) toSing (FBox (b :: Demote a)) - = case toSing b :: SomeSing a of { - SomeSing c -> SomeSing (SFBox c) } + = case toSing b :: SomeSing a of SomeSing c -> SomeSing (SFBox c) instance SingI n => SingI (FBox (n :: a)) where sing = SFBox sing + instance SingI1 FBox where + liftSing = SFBox instance SingI (FBoxSym0 :: (~>) a (Box a)) where sing = (singFun1 @FBoxSym0) SFBox diff --git a/tests/compile-and-dump/Singletons/CaseExpressions.golden b/tests/compile-and-dump/Singletons/CaseExpressions.golden --- a/tests/compile-and-dump/Singletons/CaseExpressions.golden +++ b/tests/compile-and-dump/Singletons/CaseExpressions.golden @@ -6,18 +6,18 @@ Just y -> y Nothing -> d foo2 :: a -> Maybe a -> a - foo2 d _ = case (Just d) of { Just y -> y } + foo2 d _ = case (Just d) of Just y -> y foo3 :: a -> b -> a - foo3 a b = case (a, b) of { (p, _) -> p } + foo3 a b = case (a, b) of (p, _) -> p foo4 :: forall a. a -> a foo4 x - = case x of { + = case x of y -> let z :: a z = y - in z } + in z foo5 :: a -> a - foo5 x = case x of { y -> (\ _ -> x) y } |] + foo5 x = case x of y -> (\ _ -> x) y |] ======> foo1 :: a -> Maybe a -> a foo1 d x @@ -25,18 +25,18 @@ Just y -> y Nothing -> d foo2 :: a -> Maybe a -> a - foo2 d _ = case Just d of { Just y -> y } + foo2 d _ = case Just d of Just y -> y foo3 :: a -> b -> a - foo3 a b = case (a, b) of { (p, _) -> p } + foo3 a b = case (a, b) of (p, _) -> p foo4 :: forall a. a -> a foo4 x - = case x of { + = case x of y -> let z :: a z = y - in z } + in z foo5 :: a -> a - foo5 x = case x of { y -> (\ _ -> x) y } + foo5 x = case x of y -> (\ _ -> x) y type family Case_0123456789876543210 arg_0123456789876543210 y x t where Case_0123456789876543210 arg_0123456789876543210 y x _ = x type family Lambda_0123456789876543210 y x arg_0123456789876543210 where @@ -236,35 +236,35 @@ sFoo5 :: forall a (t :: a). Sing t -> Sing (Apply Foo5Sym0 t :: a) sFoo4 :: forall a (t :: a). Sing t -> Sing (Apply Foo4Sym0 t :: a) sFoo3 :: - forall a b (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a) + forall a b (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a) sFoo2 :: - forall a (t :: a) (t :: Maybe a). - Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a) + forall a (t :: a) (t :: Maybe a). Sing t + -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a) sFoo1 :: - forall a (t :: a) (t :: Maybe a). - Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a) + forall a (t :: a) (t :: Maybe a). Sing t + -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a) sFoo5 (sX :: Sing x) = (id @(Sing (Case_0123456789876543210 x x :: a))) - (case sX of { + (case sX of (sY :: Sing y) -> (applySing ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 y) x)) (\ sArg_0123456789876543210 - -> case sArg_0123456789876543210 of { + -> case sArg_0123456789876543210 of (_ :: Sing arg_0123456789876543210) -> (id @(Sing (Case_0123456789876543210 arg_0123456789876543210 y x arg_0123456789876543210))) - (case sArg_0123456789876543210 of { _ -> sX }) }))) - sY }) + (case sArg_0123456789876543210 of _ -> sX)))) + sY) sFoo4 (sX :: Sing x) = (id @(Sing (Case_0123456789876543210 x x :: a))) - (case sX of { + (case sX of (sY :: Sing y) -> let sZ :: Sing (Let0123456789876543210ZSym2 y x :: a) sZ = sY - in sZ }) + in sZ) sFoo3 (sA :: Sing a) (sB :: Sing b) = let sScrutinee_0123456789876543210 :: @@ -274,8 +274,8 @@ in (id @(Sing (Case_0123456789876543210 a b (Let0123456789876543210Scrutinee_0123456789876543210Sym2 a b) :: a))) - (case sScrutinee_0123456789876543210 of { - STuple2 (sP :: Sing p) _ -> sP }) + (case sScrutinee_0123456789876543210 of + STuple2 (sP :: Sing p) _ -> sP) sFoo2 (sD :: Sing d) _ = let sScrutinee_0123456789876543210 :: @@ -285,8 +285,7 @@ in (id @(Sing (Case_0123456789876543210 d (Let0123456789876543210Scrutinee_0123456789876543210Sym1 d) :: a))) - (case sScrutinee_0123456789876543210 of { - SJust (sY :: Sing y) -> sY }) + (case sScrutinee_0123456789876543210 of SJust (sY :: Sing y) -> sY) sFoo1 (sD :: Sing d) (sX :: Sing x) = (id @(Sing (Case_0123456789876543210 d x x :: a))) (case sX of @@ -300,13 +299,22 @@ sing = (singFun2 @Foo3Sym0) sFoo3 instance SingI d => SingI (Foo3Sym1 (d :: a) :: (~>) b a) where sing = (singFun1 @(Foo3Sym1 (d :: a))) (sFoo3 (sing @d)) + instance SingI1 (Foo3Sym1 :: a -> (~>) b a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Foo3Sym1 (d :: a))) (sFoo3 s) instance SingI (Foo2Sym0 :: (~>) a ((~>) (Maybe a) a)) where sing = (singFun2 @Foo2Sym0) sFoo2 instance SingI d => SingI (Foo2Sym1 (d :: a) :: (~>) (Maybe a) a) where sing = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 (sing @d)) + instance SingI1 (Foo2Sym1 :: a -> (~>) (Maybe a) a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 s) instance SingI (Foo1Sym0 :: (~>) a ((~>) (Maybe a) a)) where sing = (singFun2 @Foo1Sym0) sFoo1 instance SingI d => SingI (Foo1Sym1 (d :: a) :: (~>) (Maybe a) a) where sing = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 (sing @d)) + instance SingI1 (Foo1Sym1 :: a -> (~>) (Maybe a) a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 s) diff --git a/tests/compile-and-dump/Singletons/Classes.golden b/tests/compile-and-dump/Singletons/Classes.golden --- a/tests/compile-and-dump/Singletons/Classes.golden +++ b/tests/compile-and-dump/Singletons/Classes.golden @@ -184,8 +184,8 @@ type family TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Ordering where TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 class PMyOrd a where - type Mycompare (arg :: a) (arg :: a) :: Ordering - type (<=>) (arg :: a) (arg :: a) :: Ordering + type family Mycompare (arg :: a) (arg :: a) :: Ordering + type family (<=>) (arg :: a) (arg :: a) :: Ordering type (<=>) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a type Mycompare_0123456789876543210 :: Nat -> Nat -> Ordering type family Mycompare_0123456789876543210 (a :: Nat) (a :: Nat) :: Ordering where @@ -298,12 +298,11 @@ instance PEq Foo2 where type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a sFooCompare :: - forall (t :: Foo) (t :: Foo). - Sing t - -> Sing t -> Sing (Apply (Apply FooCompareSym0 t) t :: Ordering) + forall (t :: Foo) (t :: Foo). Sing t + -> Sing t -> Sing (Apply (Apply FooCompareSym0 t) t :: Ordering) sConst :: - forall a b (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply ConstSym0 t) t :: a) + forall a b (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply ConstSym0 t) t :: a) sFooCompare SA SA = SEQ sFooCompare SA SB = SLT sFooCompare SB SB = SGT @@ -315,10 +314,16 @@ SingI (FooCompareSym1 (d :: Foo) :: (~>) Foo Ordering) where sing = (singFun1 @(FooCompareSym1 (d :: Foo))) (sFooCompare (sing @d)) + instance SingI1 (FooCompareSym1 :: Foo -> (~>) Foo Ordering) where + liftSing (s :: Sing (d :: Foo)) + = (singFun1 @(FooCompareSym1 (d :: Foo))) (sFooCompare s) instance SingI (ConstSym0 :: (~>) a ((~>) b a)) where sing = (singFun2 @ConstSym0) sConst instance SingI d => SingI (ConstSym1 (d :: a) :: (~>) b a) where sing = (singFun1 @(ConstSym1 (d :: a))) (sConst (sing @d)) + instance SingI1 (ConstSym1 :: a -> (~>) b a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(ConstSym1 (d :: a))) (sConst s) data SFoo :: Foo -> GHC.Types.Type where SA :: SFoo (A :: Foo) @@ -343,18 +348,17 @@ toSing G = SomeSing SG class SMyOrd a where sMycompare :: - forall (t :: a) (t :: a). - Sing t - -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) + forall (t :: a) (t :: a). Sing t + -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) (%<=>) :: - forall (t :: a) (t :: a). - Sing t -> Sing t -> Sing (Apply (Apply (<=>@#@$) t) t :: Ordering) + forall (t :: a) (t :: a). Sing t + -> Sing t -> Sing (Apply (Apply (<=>@#@$) t) t :: Ordering) infix 4 %<=> default (%<=>) :: - forall (t :: a) (t :: a). - ((Apply (Apply (<=>@#@$) t) t :: Ordering) - ~ Apply (Apply TFHelper_0123456789876543210Sym0 t) t) => - Sing t -> Sing t -> Sing (Apply (Apply (<=>@#@$) t) t :: Ordering) + forall (t :: a) + (t :: a). ((Apply (Apply (<=>@#@$) t) t :: Ordering) + ~ Apply (Apply TFHelper_0123456789876543210Sym0 t) t) => + Sing t -> Sing t -> Sing (Apply (Apply (<=>@#@$) t) t :: Ordering) (%<=>) (sA_0123456789876543210 :: Sing a_0123456789876543210) (sA_0123456789876543210 :: Sing a_0123456789876543210) @@ -364,9 +368,9 @@ sA_0123456789876543210 instance SMyOrd Nat where sMycompare :: - forall (t :: Nat) (t :: Nat). - Sing t - -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) + forall (t :: Nat) (t :: Nat). Sing t + -> Sing t + -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) sMycompare SZero SZero = SEQ sMycompare SZero (SSucc _) = SLT sMycompare (SSucc _) SZero = SGT @@ -376,17 +380,16 @@ sN instance SMyOrd () where sMycompare :: - forall (t :: ()) (t :: ()). - Sing t - -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) + forall (t :: ()) (t :: ()). Sing t + -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) sMycompare _ (sA_0123456789876543210 :: Sing a_0123456789876543210) = (applySing ((applySing ((singFun2 @ConstSym0) sConst)) SEQ)) sA_0123456789876543210 instance SMyOrd Foo where sMycompare :: - forall (t :: Foo) (t :: Foo). - Sing t - -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) + forall (t :: Foo) (t :: Foo). Sing t + -> Sing t + -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) sMycompare (sA_0123456789876543210 :: Sing a_0123456789876543210) (sA_0123456789876543210 :: Sing a_0123456789876543210) @@ -396,11 +399,10 @@ sA_0123456789876543210 instance SEq Foo2 where (%==) :: - forall (t1 :: Foo2) (t2 :: Foo2). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun Foo2 ((~>) Foo2 Bool) - -> GHC.Types.Type) t1) t2) + forall (t1 :: Foo2) (t2 :: Foo2). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun Foo2 ((~>) Foo2 Bool) + -> GHC.Types.Type) t1) t2) (%==) SF SF = STrue (%==) SG SG = STrue (%==) SF SG = SFalse @@ -420,11 +422,19 @@ SingI (MycompareSym1 (d :: a) :: (~>) a Ordering) where sing = (singFun1 @(MycompareSym1 (d :: a))) (sMycompare (sing @d)) instance SMyOrd a => + SingI1 (MycompareSym1 :: a -> (~>) a Ordering) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(MycompareSym1 (d :: a))) (sMycompare s) + instance SMyOrd a => SingI ((<=>@#@$) :: (~>) a ((~>) a Ordering)) where sing = (singFun2 @(<=>@#@$)) (%<=>) instance (SMyOrd a, SingI d) => SingI ((<=>@#@$$) (d :: a) :: (~>) a Ordering) where sing = (singFun1 @((<=>@#@$$) (d :: a))) ((%<=>) (sing @d)) + instance SMyOrd a => + SingI1 ((<=>@#@$$) :: a -> (~>) a Ordering) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @((<=>@#@$$) (d :: a))) ((%<=>) s) Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations promote [d| instance Ord Foo2 where @@ -572,15 +582,14 @@ fromSing (SSucc' b) = Succ' (fromSing b) toSing Zero' = SomeSing SZero' toSing (Succ' (b :: Demote Nat')) - = case toSing b :: SomeSing Nat' of { - SomeSing c -> SomeSing (SSucc' c) } + = case toSing b :: SomeSing Nat' of + SomeSing c -> SomeSing (SSucc' c) instance SMyOrd Nat' where sMycompare :: - forall (t :: Nat') (t :: Nat'). - Sing t - -> Sing t - -> Sing (Apply (Apply (MycompareSym0 :: TyFun Nat' ((~>) Nat' Ordering) - -> GHC.Types.Type) t) t) + forall (t :: Nat') (t :: Nat'). Sing t + -> Sing t + -> Sing (Apply (Apply (MycompareSym0 :: TyFun Nat' ((~>) Nat' Ordering) + -> GHC.Types.Type) t) t) sMycompare SZero' SZero' = SEQ sMycompare SZero' (SSucc' _) = SLT sMycompare (SSucc' _) SZero' = SGT @@ -592,5 +601,7 @@ sing = SZero' instance SingI n => SingI (Succ' (n :: Nat')) where sing = SSucc' sing + instance SingI1 Succ' where + liftSing = SSucc' instance SingI (Succ'Sym0 :: (~>) Nat' Nat') where sing = (singFun1 @Succ'Sym0) SSucc' diff --git a/tests/compile-and-dump/Singletons/Classes2.golden b/tests/compile-and-dump/Singletons/Classes2.golden --- a/tests/compile-and-dump/Singletons/Classes2.golden +++ b/tests/compile-and-dump/Singletons/Classes2.golden @@ -71,15 +71,14 @@ fromSing (SSuccFoo b) = SuccFoo (fromSing b) toSing ZeroFoo = SomeSing SZeroFoo toSing (SuccFoo (b :: Demote NatFoo)) - = case toSing b :: SomeSing NatFoo of { - SomeSing c -> SomeSing (SSuccFoo c) } + = case toSing b :: SomeSing NatFoo of + SomeSing c -> SomeSing (SSuccFoo c) instance SMyOrd NatFoo where sMycompare :: - forall (t1 :: NatFoo) (t2 :: NatFoo). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (MycompareSym0 :: TyFun NatFoo ((~>) NatFoo Ordering) - -> GHC.Types.Type) t1) t2) + forall (t1 :: NatFoo) (t2 :: NatFoo). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (MycompareSym0 :: TyFun NatFoo ((~>) NatFoo Ordering) + -> GHC.Types.Type) t1) t2) sMycompare SZeroFoo SZeroFoo = SEQ sMycompare SZeroFoo (SSuccFoo _) = SLT sMycompare (SSuccFoo _) SZeroFoo = SGT @@ -91,5 +90,7 @@ sing = SZeroFoo instance SingI n => SingI (SuccFoo (n :: NatFoo)) where sing = SSuccFoo sing + instance SingI1 SuccFoo where + liftSing = SSuccFoo instance SingI (SuccFooSym0 :: (~>) NatFoo NatFoo) where sing = (singFun1 @SuccFooSym0) SSuccFoo diff --git a/tests/compile-and-dump/Singletons/Contains.golden b/tests/compile-and-dump/Singletons/Contains.golden --- a/tests/compile-and-dump/Singletons/Contains.golden +++ b/tests/compile-and-dump/Singletons/Contains.golden @@ -31,9 +31,9 @@ Contains _ '[] = FalseSym0 Contains elt ('(:) h t) = Apply (Apply (||@#@$) (Apply (Apply (==@#@$) elt) h)) (Apply (Apply ContainsSym0 elt) t) sContains :: - forall a (t :: a) (t :: [a]). - SEq a => - Sing t -> Sing t -> Sing (Apply (Apply ContainsSym0 t) t :: Bool) + forall a (t :: a) (t :: [a]). SEq a => + Sing t + -> Sing t -> Sing (Apply (Apply ContainsSym0 t) t :: Bool) sContains _ SNil = SFalse sContains (sElt :: Sing elt) (SCons (sH :: Sing h) (sT :: Sing t)) = (applySing @@ -48,3 +48,6 @@ instance (SEq a, SingI d) => SingI (ContainsSym1 (d :: a) :: (~>) [a] Bool) where sing = (singFun1 @(ContainsSym1 (d :: a))) (sContains (sing @d)) + instance SEq a => SingI1 (ContainsSym1 :: a -> (~>) [a] Bool) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(ContainsSym1 (d :: a))) (sContains s) diff --git a/tests/compile-and-dump/Singletons/DataValues.golden b/tests/compile-and-dump/Singletons/DataValues.golden --- a/tests/compile-and-dump/Singletons/DataValues.golden +++ b/tests/compile-and-dump/Singletons/DataValues.golden @@ -51,12 +51,12 @@ Complex = Apply (Apply PairSym0 (Apply (Apply PairSym0 (Apply JustSym0 ZeroSym0)) ZeroSym0)) FalseSym0 type family Pr where Pr = Apply (Apply PairSym0 (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:@#@$) ZeroSym0) NilSym0) - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural -> Pair a b -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: Pair a b) (a :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Pair a b) (a :: Symbol) :: Symbol where ShowsPrec_0123456789876543210 p_0123456789876543210 (Pair arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Pair ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) (Pair a b) ((~>) Symbol Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) (Pair a b) ((~>) Symbol Symbol)) + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Pair a b) ((~>) Symbol Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Pair a b) ((~>) Symbol Symbol)) where ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => ShowsPrec_0123456789876543210Sym0 a0123456789876543210 @@ -64,9 +64,9 @@ instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> (~>) (Pair a b) ((~>) Symbol Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) (Pair a b) ((~>) Symbol Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) (Pair a b) ((~>) Symbol Symbol) where ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -74,9 +74,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural -> Pair a b -> (~>) Symbol Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Pair a b) :: (~>) Symbol Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Pair a b) :: (~>) Symbol Symbol where ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -84,9 +84,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural -> Pair a b -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Pair a b) (a0123456789876543210 :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Pair a b) (a0123456789876543210 :: Symbol) :: Symbol where ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow (Pair a b) where type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a @@ -131,16 +131,17 @@ type Demote (Pair a b) = Pair (Demote a) (Demote b) fromSing (SPair b b) = (Pair (fromSing b)) (fromSing b) toSing (Pair (b :: Demote a) (b :: Demote b)) - = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SPair c) c) } + = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SPair c) c) instance (SShow a, SShow b) => SShow (Pair a b) where sShowsPrec :: - forall (t1 :: GHC.Types.Nat) (t2 :: Pair a b) (t3 :: Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (Pair a b) ((~>) Symbol Symbol)) - -> GHC.Types.Type) t1) t2) t3) + forall (t1 :: GHC.Num.Natural.Natural) + (t2 :: Pair a b) + (t3 :: Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) (Pair a b) ((~>) Symbol Symbol)) + -> GHC.Types.Type) t1) t2) t3) sShowsPrec (sP_0123456789876543210 :: Sing p_0123456789876543210) (SPair (sArg_0123456789876543210 :: Sing arg_0123456789876543210) @@ -175,8 +176,15 @@ Show (SPair (z :: Pair a b)) instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where sing = (SPair sing) sing + instance SingI n => SingI1 (Pair (n :: a)) where + liftSing = SPair sing + instance SingI2 Pair where + liftSing2 = SPair instance SingI (PairSym0 :: (~>) a ((~>) b (Pair a b))) where sing = (singFun2 @PairSym0) SPair instance SingI d => SingI (PairSym1 (d :: a) :: (~>) b (Pair a b)) where sing = (singFun1 @(PairSym1 (d :: a))) (SPair (sing @d)) + instance SingI1 (PairSym1 :: a -> (~>) b (Pair a b)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(PairSym1 (d :: a))) (SPair s) diff --git a/tests/compile-and-dump/Singletons/Empty.golden b/tests/compile-and-dump/Singletons/Empty.golden --- a/tests/compile-and-dump/Singletons/Empty.golden +++ b/tests/compile-and-dump/Singletons/Empty.golden @@ -6,5 +6,5 @@ type instance Sing @Empty = SEmpty instance SingKind Empty where type Demote Empty = Empty - fromSing x = case x of - toSing x = SomeSing (case x of) + fromSing x = case x of {} + toSing x = SomeSing (case x of {}) diff --git a/tests/compile-and-dump/Singletons/EmptyShowDeriving.golden b/tests/compile-and-dump/Singletons/EmptyShowDeriving.golden --- a/tests/compile-and-dump/Singletons/EmptyShowDeriving.golden +++ b/tests/compile-and-dump/Singletons/EmptyShowDeriving.golden @@ -7,12 +7,12 @@ data Foo deriving instance Show Foo type family Case_0123456789876543210 v_0123456789876543210 a_0123456789876543210 t where - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural -> Foo -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: Foo) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Foo) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where ShowsPrec_0123456789876543210 _ v_0123456789876543210 a_0123456789876543210 = Apply (Case_0123456789876543210 v_0123456789876543210 a_0123456789876543210 v_0123456789876543210) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol)) where ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => ShowsPrec_0123456789876543210Sym0 a0123456789876543210 @@ -20,9 +20,9 @@ instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> (~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol) where ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -30,9 +30,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural -> Foo -> (~>) GHC.Types.Symbol GHC.Types.Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo) :: (~>) GHC.Types.Symbol GHC.Types.Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo) :: (~>) GHC.Types.Symbol GHC.Types.Symbol where ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -40,9 +40,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural -> Foo -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow Foo where type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a @@ -50,16 +50,17 @@ type instance Sing @Foo = SFoo instance SingKind Foo where type Demote Foo = Foo - fromSing x = case x of - toSing x = SomeSing (case x of) + fromSing x = case x of {} + toSing x = SomeSing (case x of {}) instance SShow Foo where sShowsPrec :: - forall (t1 :: GHC.Types.Nat) (t2 :: Foo) (t3 :: GHC.Types.Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - -> GHC.Types.Type) t1) t2) t3) + forall (t1 :: GHC.Num.Natural.Natural) + (t2 :: Foo) + (t3 :: GHC.Types.Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + -> GHC.Types.Type) t1) t2) t3) sShowsPrec _ (sV_0123456789876543210 :: Sing v_0123456789876543210) @@ -67,6 +68,6 @@ = (applySing ((id @(Sing (Case_0123456789876543210 v_0123456789876543210 a_0123456789876543210 v_0123456789876543210))) - (case sV_0123456789876543210 of))) + (case sV_0123456789876543210 of {}))) sA_0123456789876543210 deriving instance Show (SFoo (z :: Foo)) diff --git a/tests/compile-and-dump/Singletons/EnumDeriving.golden b/tests/compile-and-dump/Singletons/EnumDeriving.golden --- a/tests/compile-and-dump/Singletons/EnumDeriving.golden +++ b/tests/compile-and-dump/Singletons/EnumDeriving.golden @@ -33,11 +33,11 @@ type family Case_0123456789876543210 n t where Case_0123456789876543210 n 'True = BarSym0 Case_0123456789876543210 n 'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 1)) - type ToEnum_0123456789876543210 :: GHC.Types.Nat -> Foo - type family ToEnum_0123456789876543210 (a :: GHC.Types.Nat) :: Foo where + type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural -> Foo + type family ToEnum_0123456789876543210 (a :: GHC.Num.Natural.Natural) :: Foo where ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0)) - type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat Foo - data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat Foo + type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural Foo + data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural Foo where ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) => ToEnum_0123456789876543210Sym0 a0123456789876543210 @@ -45,16 +45,17 @@ instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ()) - type ToEnum_0123456789876543210Sym1 :: GHC.Types.Nat -> Foo - type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: Foo where + type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural + -> Foo + type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: Foo where ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 - type FromEnum_0123456789876543210 :: Foo -> GHC.Types.Nat - type family FromEnum_0123456789876543210 (a :: Foo) :: GHC.Types.Nat where + type FromEnum_0123456789876543210 :: Foo -> GHC.Num.Natural.Natural + type family FromEnum_0123456789876543210 (a :: Foo) :: GHC.Num.Natural.Natural where FromEnum_0123456789876543210 Bar = FromInteger 0 FromEnum_0123456789876543210 Baz = FromInteger 1 FromEnum_0123456789876543210 Bum = FromInteger 2 - type FromEnum_0123456789876543210Sym0 :: (~>) Foo GHC.Types.Nat - data FromEnum_0123456789876543210Sym0 :: (~>) Foo GHC.Types.Nat + type FromEnum_0123456789876543210Sym0 :: (~>) Foo GHC.Num.Natural.Natural + data FromEnum_0123456789876543210Sym0 :: (~>) Foo GHC.Num.Natural.Natural where FromEnum_0123456789876543210Sym0KindInference :: SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) => FromEnum_0123456789876543210Sym0 a0123456789876543210 @@ -62,8 +63,9 @@ instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ()) - type FromEnum_0123456789876543210Sym1 :: Foo -> GHC.Types.Nat - type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: Foo) :: GHC.Types.Nat where + type FromEnum_0123456789876543210Sym1 :: Foo + -> GHC.Num.Natural.Natural + type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: Foo) :: GHC.Num.Natural.Natural where FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210 instance PEnum Foo where type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a @@ -95,15 +97,13 @@ toSing Q2 = SomeSing SQ2 instance SEnum Foo where sToEnum :: - forall (t :: GHC.Types.Nat). - Sing t - -> Sing (Apply (Data.Singletons.Base.Enum.ToEnumSym0 :: TyFun GHC.Types.Nat Foo - -> GHC.Types.Type) t) + forall (t :: GHC.Num.Natural.Natural). Sing t + -> Sing (Apply (Data.Singletons.Base.Enum.ToEnumSym0 :: TyFun GHC.Num.Natural.Natural Foo + -> GHC.Types.Type) t) sFromEnum :: - forall (t :: Foo). - Sing t - -> Sing (Apply (Data.Singletons.Base.Enum.FromEnumSym0 :: TyFun Foo GHC.Types.Nat - -> GHC.Types.Type) t) + forall (t :: Foo). Sing t + -> Sing (Apply (Data.Singletons.Base.Enum.FromEnumSym0 :: TyFun Foo GHC.Num.Natural.Natural + -> GHC.Types.Type) t) sToEnum (sN :: Sing n) = (id @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0))))) @@ -151,11 +151,11 @@ type family Case_0123456789876543210 n t where Case_0123456789876543210 n 'True = Q1Sym0 Case_0123456789876543210 n 'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 1)) - type ToEnum_0123456789876543210 :: GHC.Types.Nat -> Quux - type family ToEnum_0123456789876543210 (a :: GHC.Types.Nat) :: Quux where + type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural -> Quux + type family ToEnum_0123456789876543210 (a :: GHC.Num.Natural.Natural) :: Quux where ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0)) - type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat Quux - data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat Quux + type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural Quux + data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural Quux where ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) => ToEnum_0123456789876543210Sym0 a0123456789876543210 @@ -163,15 +163,17 @@ instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ()) - type ToEnum_0123456789876543210Sym1 :: GHC.Types.Nat -> Quux - type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: Quux where + type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural + -> Quux + type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: Quux where ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 - type FromEnum_0123456789876543210 :: Quux -> GHC.Types.Nat - type family FromEnum_0123456789876543210 (a :: Quux) :: GHC.Types.Nat where + type FromEnum_0123456789876543210 :: Quux + -> GHC.Num.Natural.Natural + type family FromEnum_0123456789876543210 (a :: Quux) :: GHC.Num.Natural.Natural where FromEnum_0123456789876543210 'Q1 = FromInteger 0 FromEnum_0123456789876543210 'Q2 = FromInteger 1 - type FromEnum_0123456789876543210Sym0 :: (~>) Quux GHC.Types.Nat - data FromEnum_0123456789876543210Sym0 :: (~>) Quux GHC.Types.Nat + type FromEnum_0123456789876543210Sym0 :: (~>) Quux GHC.Num.Natural.Natural + data FromEnum_0123456789876543210Sym0 :: (~>) Quux GHC.Num.Natural.Natural where FromEnum_0123456789876543210Sym0KindInference :: SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) => FromEnum_0123456789876543210Sym0 a0123456789876543210 @@ -179,23 +181,22 @@ instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ()) - type FromEnum_0123456789876543210Sym1 :: Quux -> GHC.Types.Nat - type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: Quux) :: GHC.Types.Nat where + type FromEnum_0123456789876543210Sym1 :: Quux + -> GHC.Num.Natural.Natural + type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: Quux) :: GHC.Num.Natural.Natural where FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210 instance PEnum Quux where type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a instance SEnum Quux where sToEnum :: - forall (t :: GHC.Types.Nat). - Sing t - -> Sing (Apply (Data.Singletons.Base.Enum.ToEnumSym0 :: TyFun GHC.Types.Nat Quux - -> GHC.Types.Type) t) + forall (t :: GHC.Num.Natural.Natural). Sing t + -> Sing (Apply (Data.Singletons.Base.Enum.ToEnumSym0 :: TyFun GHC.Num.Natural.Natural Quux + -> GHC.Types.Type) t) sFromEnum :: - forall (t :: Quux). - Sing t - -> Sing (Apply (Data.Singletons.Base.Enum.FromEnumSym0 :: TyFun Quux GHC.Types.Nat - -> GHC.Types.Type) t) + forall (t :: Quux). Sing t + -> Sing (Apply (Data.Singletons.Base.Enum.FromEnumSym0 :: TyFun Quux GHC.Num.Natural.Natural + -> GHC.Types.Type) t) sToEnum (sN :: Sing n) = (id @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0))))) diff --git a/tests/compile-and-dump/Singletons/EqInstances.golden b/tests/compile-and-dump/Singletons/EqInstances.golden --- a/tests/compile-and-dump/Singletons/EqInstances.golden +++ b/tests/compile-and-dump/Singletons/EqInstances.golden @@ -32,11 +32,10 @@ type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a instance SEq Foo => SEq Foo where (%==) :: - forall (t1 :: Foo) (t2 :: Foo). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun Foo ((~>) Foo Bool) - -> GHC.Types.Type) t1) t2) + forall (t1 :: Foo) (t2 :: Foo). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun Foo ((~>) Foo Bool) + -> GHC.Types.Type) t1) t2) (%==) SFLeaf SFLeaf = STrue (%==) SFLeaf ((:%+:) _ _) = SFalse (%==) ((:%+:) _ _) SFLeaf = SFalse @@ -81,9 +80,8 @@ type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a instance SEq Empty where (%==) :: - forall (t1 :: Empty) (t2 :: Empty). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun Empty ((~>) Empty Bool) - -> GHC.Types.Type) t1) t2) + forall (t1 :: Empty) (t2 :: Empty). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun Empty ((~>) Empty Bool) + -> GHC.Types.Type) t1) t2) (%==) _ _ = STrue diff --git a/tests/compile-and-dump/Singletons/Fixity.golden b/tests/compile-and-dump/Singletons/Fixity.golden --- a/tests/compile-and-dump/Singletons/Fixity.golden +++ b/tests/compile-and-dump/Singletons/Fixity.golden @@ -63,20 +63,23 @@ (<=>@#@$$$) a0123456789876543210 a0123456789876543210 = (<=>) a0123456789876543210 a0123456789876543210 infix 4 <=>@#@$$$ class PMyOrd a where - type (<=>) (arg :: a) (arg :: a) :: Ordering + type family (<=>) (arg :: a) (arg :: a) :: Ordering infix 4 %==== (%====) :: - forall a (t :: a) (t :: a). - Sing t -> Sing t -> Sing (Apply (Apply (====@#@$) t) t :: a) + forall a (t :: a) (t :: a). Sing t + -> Sing t -> Sing (Apply (Apply (====@#@$) t) t :: a) (%====) (sA :: Sing a) _ = sA instance SingI ((====@#@$) :: (~>) a ((~>) a a)) where sing = (singFun2 @(====@#@$)) (%====) instance SingI d => SingI ((====@#@$$) (d :: a) :: (~>) a a) where sing = (singFun1 @((====@#@$$) (d :: a))) ((%====) (sing @d)) + instance SingI1 ((====@#@$$) :: a -> (~>) a a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @((====@#@$$) (d :: a))) ((%====) s) class SMyOrd a where (%<=>) :: - forall (t :: a) (t :: a). - Sing t -> Sing t -> Sing (Apply (Apply (<=>@#@$) t) t :: Ordering) + forall (t :: a) (t :: a). Sing t + -> Sing t -> Sing (Apply (Apply (<=>@#@$) t) t :: Ordering) infix 4 %<=> instance SMyOrd a => SingI ((<=>@#@$) :: (~>) a ((~>) a Ordering)) where @@ -84,3 +87,7 @@ instance (SMyOrd a, SingI d) => SingI ((<=>@#@$$) (d :: a) :: (~>) a Ordering) where sing = (singFun1 @((<=>@#@$$) (d :: a))) ((%<=>) (sing @d)) + instance SMyOrd a => + SingI1 ((<=>@#@$$) :: a -> (~>) a Ordering) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @((<=>@#@$$) (d :: a))) ((%<=>) s) diff --git a/tests/compile-and-dump/Singletons/FunDeps.golden b/tests/compile-and-dump/Singletons/FunDeps.golden --- a/tests/compile-and-dump/Singletons/FunDeps.golden +++ b/tests/compile-and-dump/Singletons/FunDeps.golden @@ -6,7 +6,7 @@ meth :: a -> a l2r :: a -> b - instance FD Bool Nat where + instance FD Bool Natural where meth = not l2r False = 0 l2r True = 1 |] @@ -14,7 +14,7 @@ class FD a b | a -> b where meth :: a -> a l2r :: a -> b - instance FD Bool Nat where + instance FD Bool Natural where meth = not l2r False = 0 l2r True = 1 @@ -46,8 +46,8 @@ type family L2rSym1 (a0123456789876543210 :: a) :: b where L2rSym1 a0123456789876543210 = L2r a0123456789876543210 class PFD a b | a -> b where - type Meth (arg :: a) :: a - type L2r (arg :: a) :: b + type family Meth (arg :: a) :: a + type family L2r (arg :: a) :: b type Meth_0123456789876543210 :: Bool -> Bool type family Meth_0123456789876543210 (a :: Bool) :: Bool where Meth_0123456789876543210 a_0123456789876543210 = Apply NotSym0 a_0123456789876543210 @@ -63,12 +63,12 @@ type Meth_0123456789876543210Sym1 :: Bool -> Bool type family Meth_0123456789876543210Sym1 (a0123456789876543210 :: Bool) :: Bool where Meth_0123456789876543210Sym1 a0123456789876543210 = Meth_0123456789876543210 a0123456789876543210 - type L2r_0123456789876543210 :: Bool -> Nat - type family L2r_0123456789876543210 (a :: Bool) :: Nat where + type L2r_0123456789876543210 :: Bool -> Natural + type family L2r_0123456789876543210 (a :: Bool) :: Natural where L2r_0123456789876543210 'False = FromInteger 0 L2r_0123456789876543210 'True = FromInteger 1 - type L2r_0123456789876543210Sym0 :: (~>) Bool Nat - data L2r_0123456789876543210Sym0 :: (~>) Bool Nat + type L2r_0123456789876543210Sym0 :: (~>) Bool Natural + data L2r_0123456789876543210Sym0 :: (~>) Bool Natural where L2r_0123456789876543210Sym0KindInference :: SameKind (Apply L2r_0123456789876543210Sym0 arg) (L2r_0123456789876543210Sym1 arg) => L2r_0123456789876543210Sym0 a0123456789876543210 @@ -76,10 +76,10 @@ instance SuppressUnusedWarnings L2r_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) L2r_0123456789876543210Sym0KindInference) ()) - type L2r_0123456789876543210Sym1 :: Bool -> Nat - type family L2r_0123456789876543210Sym1 (a0123456789876543210 :: Bool) :: Nat where + type L2r_0123456789876543210Sym1 :: Bool -> Natural + type family L2r_0123456789876543210Sym1 (a0123456789876543210 :: Bool) :: Natural where L2r_0123456789876543210Sym1 a0123456789876543210 = L2r_0123456789876543210 a0123456789876543210 - instance PFD Bool Nat where + instance PFD Bool Natural where type Meth a = Apply Meth_0123456789876543210Sym0 a type L2r a = Apply L2r_0123456789876543210Sym0 a sT1 :: Sing @_ T1Sym0 @@ -87,10 +87,11 @@ class SFD a b | a -> b where sMeth :: forall (t :: a). Sing t -> Sing (Apply MethSym0 t :: a) sL2r :: forall (t :: a). Sing t -> Sing (Apply L2rSym0 t :: b) - instance SFD Bool Nat where + instance SFD Bool Natural where sMeth :: forall (t :: Bool). Sing t -> Sing (Apply MethSym0 t :: Bool) - sL2r :: forall (t :: Bool). Sing t -> Sing (Apply L2rSym0 t :: Nat) + sL2r :: + forall (t :: Bool). Sing t -> Sing (Apply L2rSym0 t :: Natural) sMeth (sA_0123456789876543210 :: Sing a_0123456789876543210) = (applySing ((singFun1 @NotSym0) sNot)) sA_0123456789876543210 sL2r SFalse = sFromInteger (sing :: Sing 0) diff --git a/tests/compile-and-dump/Singletons/FunDeps.hs b/tests/compile-and-dump/Singletons/FunDeps.hs --- a/tests/compile-and-dump/Singletons/FunDeps.hs +++ b/tests/compile-and-dump/Singletons/FunDeps.hs @@ -11,7 +11,7 @@ meth :: a -> a l2r :: a -> b - instance FD Bool Nat where + instance FD Bool Natural where meth = not l2r False = 0 l2r True = 1 diff --git a/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden b/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden --- a/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden +++ b/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden @@ -9,8 +9,8 @@ = MkT1 x a (Maybe a) (Maybe (Maybe a)) | MkT2 (Maybe x) deriving (Functor, Foldable, Traversable) data Empty (a :: Type) deriving (Functor, Foldable, Traversable) - type MkT1Sym0 :: forall x a. - (~>) x ((~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))) + type MkT1Sym0 :: forall x + a. (~>) x ((~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))) data MkT1Sym0 :: (~>) x ((~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))) where MkT1Sym0KindInference :: SameKind (Apply MkT1Sym0 arg) (MkT1Sym1 arg) => @@ -18,8 +18,8 @@ type instance Apply MkT1Sym0 a0123456789876543210 = MkT1Sym1 a0123456789876543210 instance SuppressUnusedWarnings MkT1Sym0 where suppressUnusedWarnings = snd (((,) MkT1Sym0KindInference) ()) - type MkT1Sym1 :: forall x a. - x -> (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) + type MkT1Sym1 :: forall x a. x + -> (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) data MkT1Sym1 (a0123456789876543210 :: x) :: (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) where MkT1Sym1KindInference :: SameKind (Apply (MkT1Sym1 a0123456789876543210) arg) (MkT1Sym2 a0123456789876543210 arg) => @@ -27,8 +27,8 @@ type instance Apply (MkT1Sym1 a0123456789876543210) a0123456789876543210 = MkT1Sym2 a0123456789876543210 a0123456789876543210 instance SuppressUnusedWarnings (MkT1Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) MkT1Sym1KindInference) ()) - type MkT1Sym2 :: forall x a. - x -> a -> (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)) + type MkT1Sym2 :: forall x a. x + -> a -> (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)) data MkT1Sym2 (a0123456789876543210 :: x) (a0123456789876543210 :: a) :: (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)) where MkT1Sym2KindInference :: SameKind (Apply (MkT1Sym2 a0123456789876543210 a0123456789876543210) arg) (MkT1Sym3 a0123456789876543210 a0123456789876543210 arg) => @@ -36,8 +36,8 @@ type instance Apply (MkT1Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = MkT1Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance SuppressUnusedWarnings (MkT1Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) MkT1Sym2KindInference) ()) - type MkT1Sym3 :: forall x a. - x -> a -> Maybe a -> (~>) (Maybe (Maybe a)) (T x a) + type MkT1Sym3 :: forall x a. x + -> a -> Maybe a -> (~>) (Maybe (Maybe a)) (T x a) data MkT1Sym3 (a0123456789876543210 :: x) (a0123456789876543210 :: a) (a0123456789876543210 :: Maybe a) :: (~>) (Maybe (Maybe a)) (T x a) where MkT1Sym3KindInference :: SameKind (Apply (MkT1Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) arg) (MkT1Sym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 arg) => @@ -45,8 +45,8 @@ type instance Apply (MkT1Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) a0123456789876543210 = MkT1 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance SuppressUnusedWarnings (MkT1Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) MkT1Sym3KindInference) ()) - type MkT1Sym4 :: forall x a. - x -> a -> Maybe a -> Maybe (Maybe a) -> T x a + type MkT1Sym4 :: forall x a. x + -> a -> Maybe a -> Maybe (Maybe a) -> T x a type family MkT1Sym4 (a0123456789876543210 :: x) (a0123456789876543210 :: a) (a0123456789876543210 :: Maybe a) (a0123456789876543210 :: Maybe (Maybe a)) :: T x a where MkT1Sym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = MkT1 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 type MkT2Sym0 :: forall x a. (~>) (Maybe x) (T x a) @@ -974,31 +974,32 @@ ((((,,,) (toSing b :: SomeSing x)) (toSing b :: SomeSing a)) (toSing b :: SomeSing (Maybe a))) (toSing b :: SomeSing (Maybe (Maybe a))) - of { + of (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) - -> SomeSing ((((SMkT1 c) c) c) c) } + -> SomeSing ((((SMkT1 c) c) c) c) toSing (MkT2 (b :: Demote (Maybe x))) - = case toSing b :: SomeSing (Maybe x) of { - SomeSing c -> SomeSing (SMkT2 c) } + = case toSing b :: SomeSing (Maybe x) of + SomeSing c -> SomeSing (SMkT2 c) data SEmpty :: forall (a :: Type). Empty a -> Type type instance Sing @(Empty a) = SEmpty instance SingKind a => SingKind (Empty a) where type Demote (Empty a) = Empty (Demote a) - fromSing x = case x of - toSing x = SomeSing (case x of) + fromSing x = case x of {} + toSing x = SomeSing (case x of {}) instance SFunctor (T x) where sFmap :: - forall (a :: Type) (b :: Type) (t1 :: (~>) a b) (t2 :: T x a). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (FmapSym0 :: TyFun ((~>) a b) ((~>) (T x a) (T x b)) - -> Type) t1) t2) + forall (a :: Type) + (b :: Type) + (t1 :: (~>) a b) + (t2 :: T x a). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (FmapSym0 :: TyFun ((~>) a b) ((~>) (T x a) (T x b)) + -> Type) t1) t2) (%<$) :: - forall (a :: Type) (b :: Type) (t1 :: a) (t2 :: T x b). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((<$@#@$) :: TyFun a ((~>) (T x b) (T x a)) - -> Type) t1) t2) + forall (a :: Type) (b :: Type) (t1 :: a) (t2 :: T x b). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((<$@#@$) :: TyFun a ((~>) (T x b) (T x a)) + -> Type) t1) t2) sFmap (_sf_0123456789876543210 :: Sing _f_0123456789876543210) (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210) @@ -1013,9 +1014,9 @@ ((singFun1 @(Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (\ sN_0123456789876543210 - -> case sN_0123456789876543210 of { + -> case sN_0123456789876543210 of (_ :: Sing n_0123456789876543210) - -> sN_0123456789876543210 }))) + -> sN_0123456789876543210))) sA_0123456789876543210))) ((applySing _sf_0123456789876543210) sA_0123456789876543210))) ((applySing @@ -1034,8 +1035,8 @@ ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210)) (\ sN_0123456789876543210 - -> case sN_0123456789876543210 of { - (_ :: Sing n_0123456789876543210) -> sN_0123456789876543210 }))) + -> case sN_0123456789876543210 of + (_ :: Sing n_0123456789876543210) -> sN_0123456789876543210))) sA_0123456789876543210) (%<$) (_sz_0123456789876543210 :: Sing _z_0123456789876543210) @@ -1051,16 +1052,16 @@ ((singFun1 @(Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (\ sN_0123456789876543210 - -> case sN_0123456789876543210 of { + -> case sN_0123456789876543210 of (_ :: Sing n_0123456789876543210) - -> sN_0123456789876543210 }))) + -> sN_0123456789876543210))) sA_0123456789876543210))) ((applySing ((singFun1 @(Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (\ sN_0123456789876543210 - -> case sN_0123456789876543210 of { - (_ :: Sing n_0123456789876543210) -> _sz_0123456789876543210 }))) + -> case sN_0123456789876543210 of + (_ :: Sing n_0123456789876543210) -> _sz_0123456789876543210))) sA_0123456789876543210))) ((applySing ((applySing ((singFun2 @(<$@#@$)) (%<$))) _sz_0123456789876543210)) @@ -1078,28 +1079,29 @@ ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 _z_0123456789876543210) a_0123456789876543210)) (\ sN_0123456789876543210 - -> case sN_0123456789876543210 of { - (_ :: Sing n_0123456789876543210) -> sN_0123456789876543210 }))) + -> case sN_0123456789876543210 of + (_ :: Sing n_0123456789876543210) -> sN_0123456789876543210))) sA_0123456789876543210) instance SFoldable (T x) where sFoldMap :: - forall (a :: Type) (m :: Type) (t1 :: (~>) a m) (t2 :: T x a). - SMonoid m => - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (FoldMapSym0 :: TyFun ((~>) a m) ((~>) (T x a) m) - -> Type) t1) t2) + forall (a :: Type) + (m :: Type) + (t1 :: (~>) a m) + (t2 :: T x a). SMonoid m => + Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (FoldMapSym0 :: TyFun ((~>) a m) ((~>) (T x a) m) + -> Type) t1) t2) sFoldr :: forall (a :: Type) (b :: Type) (t1 :: (~>) a ((~>) b b)) (t2 :: b) - (t3 :: T x a). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (FoldrSym0 :: TyFun ((~>) a ((~>) b b)) ((~>) b ((~>) (T x a) b)) - -> Type) t1) t2) t3) + (t3 :: T x a). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (FoldrSym0 :: TyFun ((~>) a ((~>) b b)) ((~>) b ((~>) (T x a) b)) + -> Type) t1) t2) t3) sFoldMap (_sf_0123456789876543210 :: Sing _f_0123456789876543210) (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210) @@ -1112,8 +1114,8 @@ ((singFun1 @(Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (\ sN_0123456789876543210 - -> case sN_0123456789876543210 of { - (_ :: Sing n_0123456789876543210) -> sMempty }))) + -> case sN_0123456789876543210 of + (_ :: Sing n_0123456789876543210) -> sMempty))) sA_0123456789876543210))) ((applySing ((applySing ((singFun2 @MappendSym0) sMappend)) @@ -1136,8 +1138,8 @@ ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210)) (\ sN_0123456789876543210 - -> case sN_0123456789876543210 of { - (_ :: Sing n_0123456789876543210) -> sMempty }))) + -> case sN_0123456789876543210 of + (_ :: Sing n_0123456789876543210) -> sMempty))) sA_0123456789876543210 sFoldr (_sf_0123456789876543210 :: Sing _f_0123456789876543210) @@ -1151,10 +1153,10 @@ ((singFun2 @(Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (\ sN1_0123456789876543210 sN2_0123456789876543210 - -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of { + -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of (,) (_ :: Sing n1_0123456789876543210) (_ :: Sing n2_0123456789876543210) - -> sN2_0123456789876543210 }))) + -> sN2_0123456789876543210))) sA_0123456789876543210)) ((applySing ((applySing _sf_0123456789876543210) sA_0123456789876543210)) @@ -1163,7 +1165,7 @@ ((singFun2 @(Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (\ sN1_0123456789876543210 sN2_0123456789876543210 - -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of { + -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of (,) (_ :: Sing n1_0123456789876543210) (_ :: Sing n2_0123456789876543210) -> (applySing @@ -1171,14 +1173,14 @@ ((applySing ((singFun3 @FoldrSym0) sFoldr)) _sf_0123456789876543210)) sN2_0123456789876543210)) - sN1_0123456789876543210 }))) + sN1_0123456789876543210))) sA_0123456789876543210)) ((applySing ((applySing ((singFun2 @(Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (\ sN1_0123456789876543210 sN2_0123456789876543210 - -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of { + -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of (,) (_ :: Sing n1_0123456789876543210) (_ :: Sing n2_0123456789876543210) -> (applySing @@ -1191,7 +1193,7 @@ -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 - of { + of (,) (_ :: Sing n1_0123456789876543210) (_ :: Sing n2_0123456789876543210) -> (applySing @@ -1202,9 +1204,9 @@ sFoldr)) _sf_0123456789876543210)) sN2_0123456789876543210)) - sN1_0123456789876543210 })))) + sN1_0123456789876543210)))) sN2_0123456789876543210)) - sN1_0123456789876543210 }))) + sN1_0123456789876543210))) sA_0123456789876543210)) _sz_0123456789876543210))) sFoldr @@ -1216,10 +1218,10 @@ ((singFun2 @(Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210)) (\ sN1_0123456789876543210 sN2_0123456789876543210 - -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of { + -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of (,) (_ :: Sing n1_0123456789876543210) (_ :: Sing n2_0123456789876543210) - -> sN2_0123456789876543210 }))) + -> sN2_0123456789876543210))) sA_0123456789876543210)) _sz_0123456789876543210 instance STraversable (T x) where @@ -1228,12 +1230,11 @@ (f :: Type -> Type) (b :: Type) (t1 :: (~>) a (f b)) - (t2 :: T x a). - SApplicative f => - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (TraverseSym0 :: TyFun ((~>) a (f b)) ((~>) (T x a) (f (T x b))) - -> Type) t1) t2) + (t2 :: T x a). SApplicative f => + Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (TraverseSym0 :: TyFun ((~>) a (f b)) ((~>) (T x a) (f (T x b))) + -> Type) t1) t2) sTraverse (_sf_0123456789876543210 :: Sing _f_0123456789876543210) (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210) @@ -1268,33 +1269,36 @@ ((applySing ((singFun1 @PureSym0) sPure)) sA_0123456789876543210) instance SFunctor Empty where sFmap :: - forall (a :: Type) (b :: Type) (t1 :: (~>) a b) (t2 :: Empty a). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (FmapSym0 :: TyFun ((~>) a b) ((~>) (Empty a) (Empty b)) - -> Type) t1) t2) + forall (a :: Type) + (b :: Type) + (t1 :: (~>) a b) + (t2 :: Empty a). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (FmapSym0 :: TyFun ((~>) a b) ((~>) (Empty a) (Empty b)) + -> Type) t1) t2) (%<$) :: - forall (a :: Type) (b :: Type) (t1 :: a) (t2 :: Empty b). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((<$@#@$) :: TyFun a ((~>) (Empty b) (Empty a)) - -> Type) t1) t2) + forall (a :: Type) (b :: Type) (t1 :: a) (t2 :: Empty b). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((<$@#@$) :: TyFun a ((~>) (Empty b) (Empty a)) + -> Type) t1) t2) sFmap _ (sV_0123456789876543210 :: Sing v_0123456789876543210) = (id @(Sing (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210))) - (case sV_0123456789876543210 of) + (case sV_0123456789876543210 of {}) (%<$) _ (sV_0123456789876543210 :: Sing v_0123456789876543210) = (id @(Sing (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210))) - (case sV_0123456789876543210 of) + (case sV_0123456789876543210 of {}) instance SFoldable Empty where sFoldMap :: - forall (a :: Type) (m :: Type) (t1 :: (~>) a m) (t2 :: Empty a). - SMonoid m => - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (FoldMapSym0 :: TyFun ((~>) a m) ((~>) (Empty a) m) - -> Type) t1) t2) + forall (a :: Type) + (m :: Type) + (t1 :: (~>) a m) + (t2 :: Empty a). SMonoid m => + Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (FoldMapSym0 :: TyFun ((~>) a m) ((~>) (Empty a) m) + -> Type) t1) t2) sFoldMap _ _ = sMempty instance STraversable Empty where sTraverse :: @@ -1302,36 +1306,68 @@ (f :: Type -> Type) (b :: Type) (t1 :: (~>) a (f b)) - (t2 :: Empty a). - SApplicative f => - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (TraverseSym0 :: TyFun ((~>) a (f b)) ((~>) (Empty a) (f (Empty b))) - -> Type) t1) t2) + (t2 :: Empty a). SApplicative f => + Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (TraverseSym0 :: TyFun ((~>) a (f b)) ((~>) (Empty a) (f (Empty b))) + -> Type) t1) t2) sTraverse _ (sV_0123456789876543210 :: Sing v_0123456789876543210) = (applySing ((singFun1 @PureSym0) sPure)) ((id @(Sing (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210))) - (case sV_0123456789876543210 of)) + (case sV_0123456789876543210 of {})) instance (SingI n, SingI n, SingI n, SingI n) => SingI (MkT1 (n :: x) (n :: a) (n :: Maybe a) (n :: Maybe (Maybe a))) where sing = (((SMkT1 sing) sing) sing) sing + instance (SingI n, SingI n, SingI n) => + SingI1 (MkT1 (n :: x) (n :: a) (n :: Maybe a)) where + liftSing = ((SMkT1 sing) sing) sing + instance (SingI n, SingI n) => + SingI2 (MkT1 (n :: x) (n :: a)) where + liftSing2 = (SMkT1 sing) sing instance SingI (MkT1Sym0 :: (~>) x ((~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))))) where sing = (singFun4 @MkT1Sym0) SMkT1 instance SingI d => SingI (MkT1Sym1 (d :: x) :: (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))) where sing = (singFun3 @(MkT1Sym1 (d :: x))) (SMkT1 (sing @d)) + instance SingI1 (MkT1Sym1 :: x + -> (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))) where + liftSing (s :: Sing (d :: x)) + = (singFun3 @(MkT1Sym1 (d :: x))) (SMkT1 s) instance (SingI d, SingI d) => SingI (MkT1Sym2 (d :: x) (d :: a) :: (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) where sing = (singFun2 @(MkT1Sym2 (d :: x) (d :: a))) ((SMkT1 (sing @d)) (sing @d)) + instance SingI d => + SingI1 (MkT1Sym2 (d :: x) :: a + -> (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) where + liftSing (s :: Sing (d :: a)) + = (singFun2 @(MkT1Sym2 (d :: x) (d :: a))) ((SMkT1 (sing @d)) s) + instance SingI2 (MkT1Sym2 :: x + -> a -> (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) where + liftSing2 (s :: Sing (d :: x)) (s :: Sing (d :: a)) + = (singFun2 @(MkT1Sym2 (d :: x) (d :: a))) ((SMkT1 s) s) instance (SingI d, SingI d, SingI d) => SingI (MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a) :: (~>) (Maybe (Maybe a)) (T x a)) where sing = (singFun1 @(MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a))) (((SMkT1 (sing @d)) (sing @d)) (sing @d)) + instance (SingI d, SingI d) => + SingI1 (MkT1Sym3 (d :: x) (d :: a) :: Maybe a + -> (~>) (Maybe (Maybe a)) (T x a)) where + liftSing (s :: Sing (d :: Maybe a)) + = (singFun1 @(MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a))) + (((SMkT1 (sing @d)) (sing @d)) s) + instance SingI d => + SingI2 (MkT1Sym3 (d :: x) :: a + -> Maybe a -> (~>) (Maybe (Maybe a)) (T x a)) where + liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: Maybe a)) + = (singFun1 @(MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a))) + (((SMkT1 (sing @d)) s) s) instance SingI n => SingI (MkT2 (n :: Maybe x)) where sing = SMkT2 sing + instance SingI1 MkT2 where + liftSing = SMkT2 instance SingI (MkT2Sym0 :: (~>) (Maybe x) (T x a)) where sing = (singFun1 @MkT2Sym0) SMkT2 diff --git a/tests/compile-and-dump/Singletons/HigherOrder.golden b/tests/compile-and-dump/Singletons/HigherOrder.golden --- a/tests/compile-and-dump/Singletons/HigherOrder.golden +++ b/tests/compile-and-dump/Singletons/HigherOrder.golden @@ -295,32 +295,31 @@ Map _ '[] = NilSym0 Map f ('(:) h t) = Apply (Apply (:@#@$) (Apply f h)) (Apply (Apply MapSym0 f) t) sEtad :: - forall (t :: [Nat]) (t :: [Bool]). - Sing t -> Sing t -> Sing (Apply (Apply EtadSym0 t) t :: [Nat]) + forall (t :: [Nat]) (t :: [Bool]). Sing t + -> Sing t -> Sing (Apply (Apply EtadSym0 t) t :: [Nat]) sSplunge :: - forall (t :: [Nat]) (t :: [Bool]). - Sing t -> Sing t -> Sing (Apply (Apply SplungeSym0 t) t :: [Nat]) + forall (t :: [Nat]) (t :: [Bool]). Sing t + -> Sing t -> Sing (Apply (Apply SplungeSym0 t) t :: [Nat]) sFoo :: forall a b (t :: (~>) ((~>) a b) ((~>) a b)) (t :: (~>) a b) - (t :: a). - Sing t - -> Sing t - -> Sing t -> Sing (Apply (Apply (Apply FooSym0 t) t) t :: b) + (t :: a). Sing t + -> Sing t + -> Sing t -> Sing (Apply (Apply (Apply FooSym0 t) t) t :: b) sZipWith :: - forall a b c (t :: (~>) a ((~>) b c)) (t :: [a]) (t :: [b]). - Sing t - -> Sing t - -> Sing t -> Sing (Apply (Apply (Apply ZipWithSym0 t) t) t :: [c]) + forall a b c (t :: (~>) a ((~>) b c)) (t :: [a]) (t :: [b]). Sing t + -> Sing t + -> Sing t + -> Sing (Apply (Apply (Apply ZipWithSym0 t) t) t :: [c]) sLiftMaybe :: - forall a b (t :: (~>) a b) (t :: Maybe a). - Sing t - -> Sing t -> Sing (Apply (Apply LiftMaybeSym0 t) t :: Maybe b) + forall a b (t :: (~>) a b) (t :: Maybe a). Sing t + -> Sing t + -> Sing (Apply (Apply LiftMaybeSym0 t) t :: Maybe b) sMap :: - forall a b (t :: (~>) a b) (t :: [a]). - Sing t -> Sing t -> Sing (Apply (Apply MapSym0 t) t :: [b]) + forall a b (t :: (~>) a b) (t :: [a]). Sing t + -> Sing t -> Sing (Apply (Apply MapSym0 t) t :: [b]) sEtad (sA_0123456789876543210 :: Sing a_0123456789876543210) (sA_0123456789876543210 :: Sing a_0123456789876543210) @@ -330,7 +329,7 @@ ((singFun2 @(Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210)) (\ sN sB - -> case ((,) sN) sB of { + -> case ((,) sN) sB of (,) (_ :: Sing n) (_ :: Sing b) -> (id @(Sing (Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 b))) @@ -338,7 +337,7 @@ STrue -> (applySing ((singFun1 @SuccSym0) SSucc)) ((applySing ((singFun1 @SuccSym0) SSucc)) sN) - SFalse -> sN) })))) + SFalse -> sN))))) sA_0123456789876543210)) sA_0123456789876543210 sSplunge (sNs :: Sing ns) (sBs :: Sing bs) @@ -347,14 +346,14 @@ ((applySing ((singFun3 @ZipWithSym0) sZipWith)) ((singFun2 @(Apply (Apply Lambda_0123456789876543210Sym0 ns) bs)) (\ sN sB - -> case ((,) sN) sB of { + -> case ((,) sN) sB of (,) (_ :: Sing n) (_ :: Sing b) -> (id @(Sing (Case_0123456789876543210 n b ns bs b))) (case sB of STrue -> (applySing ((singFun1 @SuccSym0) SSucc)) ((applySing ((singFun1 @SuccSym0) SSucc)) sN) - SFalse -> sN) })))) + SFalse -> sN))))) sNs)) sBs sFoo (sF :: Sing f) (sG :: Sing g) (sA :: Sing a) @@ -386,11 +385,17 @@ instance SingI d => SingI (EtadSym1 (d :: [Nat]) :: (~>) [Bool] [Nat]) where sing = (singFun1 @(EtadSym1 (d :: [Nat]))) (sEtad (sing @d)) + instance SingI1 (EtadSym1 :: [Nat] -> (~>) [Bool] [Nat]) where + liftSing (s :: Sing (d :: [Nat])) + = (singFun1 @(EtadSym1 (d :: [Nat]))) (sEtad s) instance SingI (SplungeSym0 :: (~>) [Nat] ((~>) [Bool] [Nat])) where sing = (singFun2 @SplungeSym0) sSplunge instance SingI d => SingI (SplungeSym1 (d :: [Nat]) :: (~>) [Bool] [Nat]) where sing = (singFun1 @(SplungeSym1 (d :: [Nat]))) (sSplunge (sing @d)) + instance SingI1 (SplungeSym1 :: [Nat] -> (~>) [Bool] [Nat]) where + liftSing (s :: Sing (d :: [Nat])) + = (singFun1 @(SplungeSym1 (d :: [Nat]))) (sSplunge s) instance SingI (FooSym0 :: (~>) ((~>) ((~>) a b) ((~>) a b)) ((~>) ((~>) a b) ((~>) a b))) where sing = (singFun3 @FooSym0) sFoo instance SingI d => @@ -398,12 +403,31 @@ sing = (singFun2 @(FooSym1 (d :: (~>) ((~>) a b) ((~>) a b)))) (sFoo (sing @d)) + instance SingI1 (FooSym1 :: (~>) ((~>) a b) ((~>) a b) + -> (~>) ((~>) a b) ((~>) a b)) where + liftSing (s :: Sing (d :: (~>) ((~>) a b) ((~>) a b))) + = (singFun2 @(FooSym1 (d :: (~>) ((~>) a b) ((~>) a b)))) (sFoo s) instance (SingI d, SingI d) => SingI (FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) (d :: (~>) a b) :: (~>) a b) where sing = (singFun1 @(FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) (d :: (~>) a b))) ((sFoo (sing @d)) (sing @d)) + instance SingI d => + SingI1 (FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) :: (~>) a b + -> (~>) a b) where + liftSing (s :: Sing (d :: (~>) a b)) + = (singFun1 + @(FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) (d :: (~>) a b))) + ((sFoo (sing @d)) s) + instance SingI2 (FooSym2 :: (~>) ((~>) a b) ((~>) a b) + -> (~>) a b -> (~>) a b) where + liftSing2 + (s :: Sing (d :: (~>) ((~>) a b) ((~>) a b))) + (s :: Sing (d :: (~>) a b)) + = (singFun1 + @(FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) (d :: (~>) a b))) + ((sFoo s) s) instance SingI (ZipWithSym0 :: (~>) ((~>) a ((~>) b c)) ((~>) [a] ((~>) [b] [c]))) where sing = (singFun3 @ZipWithSym0) sZipWith instance SingI d => @@ -411,11 +435,28 @@ sing = (singFun2 @(ZipWithSym1 (d :: (~>) a ((~>) b c)))) (sZipWith (sing @d)) + instance SingI1 (ZipWithSym1 :: (~>) a ((~>) b c) + -> (~>) [a] ((~>) [b] [c])) where + liftSing (s :: Sing (d :: (~>) a ((~>) b c))) + = (singFun2 @(ZipWithSym1 (d :: (~>) a ((~>) b c)))) (sZipWith s) instance (SingI d, SingI d) => SingI (ZipWithSym2 (d :: (~>) a ((~>) b c)) (d :: [a]) :: (~>) [b] [c]) where sing = (singFun1 @(ZipWithSym2 (d :: (~>) a ((~>) b c)) (d :: [a]))) ((sZipWith (sing @d)) (sing @d)) + instance SingI d => + SingI1 (ZipWithSym2 (d :: (~>) a ((~>) b c)) :: [a] + -> (~>) [b] [c]) where + liftSing (s :: Sing (d :: [a])) + = (singFun1 @(ZipWithSym2 (d :: (~>) a ((~>) b c)) (d :: [a]))) + ((sZipWith (sing @d)) s) + instance SingI2 (ZipWithSym2 :: (~>) a ((~>) b c) + -> [a] -> (~>) [b] [c]) where + liftSing2 + (s :: Sing (d :: (~>) a ((~>) b c))) + (s :: Sing (d :: [a])) + = (singFun1 @(ZipWithSym2 (d :: (~>) a ((~>) b c)) (d :: [a]))) + ((sZipWith s) s) instance SingI (LiftMaybeSym0 :: (~>) ((~>) a b) ((~>) (Maybe a) (Maybe b))) where sing = (singFun2 @LiftMaybeSym0) sLiftMaybe instance SingI d => @@ -423,11 +464,18 @@ sing = (singFun1 @(LiftMaybeSym1 (d :: (~>) a b))) (sLiftMaybe (sing @d)) + instance SingI1 (LiftMaybeSym1 :: (~>) a b + -> (~>) (Maybe a) (Maybe b)) where + liftSing (s :: Sing (d :: (~>) a b)) + = (singFun1 @(LiftMaybeSym1 (d :: (~>) a b))) (sLiftMaybe s) instance SingI (MapSym0 :: (~>) ((~>) a b) ((~>) [a] [b])) where sing = (singFun2 @MapSym0) sMap instance SingI d => SingI (MapSym1 (d :: (~>) a b) :: (~>) [a] [b]) where sing = (singFun1 @(MapSym1 (d :: (~>) a b))) (sMap (sing @d)) + instance SingI1 (MapSym1 :: (~>) a b -> (~>) [a] [b]) where + liftSing (s :: Sing (d :: (~>) a b)) + = (singFun1 @(MapSym1 (d :: (~>) a b))) (sMap s) data SEither :: forall a b. Either a b -> GHC.Types.Type where SLeft :: forall a b (n :: a). @@ -440,16 +488,18 @@ fromSing (SLeft b) = Left (fromSing b) fromSing (SRight b) = Right (fromSing b) toSing (Left (b :: Demote a)) - = case toSing b :: SomeSing a of { - SomeSing c -> SomeSing (SLeft c) } + = case toSing b :: SomeSing a of SomeSing c -> SomeSing (SLeft c) toSing (Right (b :: Demote b)) - = case toSing b :: SomeSing b of { - SomeSing c -> SomeSing (SRight c) } + = case toSing b :: SomeSing b of SomeSing c -> SomeSing (SRight c) instance SingI n => SingI (Left (n :: a)) where sing = SLeft sing + instance SingI1 Left where + liftSing = SLeft instance SingI (LeftSym0 :: (~>) a (Either a b)) where sing = (singFun1 @LeftSym0) SLeft instance SingI n => SingI (Right (n :: b)) where sing = SRight sing + instance SingI1 Right where + liftSing = SRight instance SingI (RightSym0 :: (~>) b (Either a b)) where sing = (singFun1 @RightSym0) SRight diff --git a/tests/compile-and-dump/Singletons/LambdaCase.golden b/tests/compile-and-dump/Singletons/LambdaCase.golden --- a/tests/compile-and-dump/Singletons/LambdaCase.golden +++ b/tests/compile-and-dump/Singletons/LambdaCase.golden @@ -180,60 +180,68 @@ type family Foo1 (a :: a) (a :: Maybe a) :: a where Foo1 d x = Apply (Apply (Apply Lambda_0123456789876543210Sym0 d) x) x sFoo3 :: - forall a b (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a) + forall a b (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a) sFoo2 :: - forall a (t :: a) (t :: Maybe a). - Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a) + forall a (t :: a) (t :: Maybe a). Sing t + -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a) sFoo1 :: - forall a (t :: a) (t :: Maybe a). - Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a) + forall a (t :: a) (t :: Maybe a). Sing t + -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a) sFoo3 (sA :: Sing a) (sB :: Sing b) = (applySing ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 a) b)) (\ sX_0123456789876543210 - -> case sX_0123456789876543210 of { + -> case sX_0123456789876543210 of (_ :: Sing x_0123456789876543210) -> (id @(Sing (Case_0123456789876543210 x_0123456789876543210 a b x_0123456789876543210))) - (case sX_0123456789876543210 of { - STuple2 (sP :: Sing p) _ -> sP }) }))) + (case sX_0123456789876543210 of STuple2 (sP :: Sing p) _ -> sP)))) ((applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sA)) sB) sFoo2 (sD :: Sing d) _ = (applySing ((singFun1 @(Apply Lambda_0123456789876543210Sym0 d)) (\ sX_0123456789876543210 - -> case sX_0123456789876543210 of { + -> case sX_0123456789876543210 of (_ :: Sing x_0123456789876543210) -> (id @(Sing (Case_0123456789876543210 x_0123456789876543210 d x_0123456789876543210))) (case sX_0123456789876543210 of SJust (sY :: Sing y) -> sY - SNothing -> sD) }))) + SNothing -> sD)))) ((applySing ((singFun1 @JustSym0) SJust)) sD) sFoo1 (sD :: Sing d) (sX :: Sing x) = (applySing ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 d) x)) (\ sX_0123456789876543210 - -> case sX_0123456789876543210 of { + -> case sX_0123456789876543210 of (_ :: Sing x_0123456789876543210) -> (id @(Sing (Case_0123456789876543210 x_0123456789876543210 d x x_0123456789876543210))) (case sX_0123456789876543210 of SJust (sY :: Sing y) -> sY - SNothing -> sD) }))) + SNothing -> sD)))) sX instance SingI (Foo3Sym0 :: (~>) a ((~>) b a)) where sing = (singFun2 @Foo3Sym0) sFoo3 instance SingI d => SingI (Foo3Sym1 (d :: a) :: (~>) b a) where sing = (singFun1 @(Foo3Sym1 (d :: a))) (sFoo3 (sing @d)) + instance SingI1 (Foo3Sym1 :: a -> (~>) b a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Foo3Sym1 (d :: a))) (sFoo3 s) instance SingI (Foo2Sym0 :: (~>) a ((~>) (Maybe a) a)) where sing = (singFun2 @Foo2Sym0) sFoo2 instance SingI d => SingI (Foo2Sym1 (d :: a) :: (~>) (Maybe a) a) where sing = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 (sing @d)) + instance SingI1 (Foo2Sym1 :: a -> (~>) (Maybe a) a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 s) instance SingI (Foo1Sym0 :: (~>) a ((~>) (Maybe a) a)) where sing = (singFun2 @Foo1Sym0) sFoo1 instance SingI d => SingI (Foo1Sym1 (d :: a) :: (~>) (Maybe a) a) where sing = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 (sing @d)) + instance SingI1 (Foo1Sym1 :: a -> (~>) (Maybe a) a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 s) diff --git a/tests/compile-and-dump/Singletons/Lambdas.golden b/tests/compile-and-dump/Singletons/Lambdas.golden --- a/tests/compile-and-dump/Singletons/Lambdas.golden +++ b/tests/compile-and-dump/Singletons/Lambdas.golden @@ -561,73 +561,71 @@ sFoo8 :: forall a b (t :: Foo a b). Sing t -> Sing (Apply Foo8Sym0 t :: a) sFoo7 :: - forall a b (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo7Sym0 t) t :: b) + forall a b (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply Foo7Sym0 t) t :: b) sFoo6 :: - forall a b (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo6Sym0 t) t :: a) + forall a b (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply Foo6Sym0 t) t :: a) sFoo5 :: - forall a b (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo5Sym0 t) t :: b) + forall a b (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply Foo5Sym0 t) t :: b) sFoo4 :: - forall a b c (t :: a) (t :: b) (t :: c). - Sing t - -> Sing t - -> Sing t -> Sing (Apply (Apply (Apply Foo4Sym0 t) t) t :: a) + forall a b c (t :: a) (t :: b) (t :: c). Sing t + -> Sing t + -> Sing t + -> Sing (Apply (Apply (Apply Foo4Sym0 t) t) t :: a) sFoo3 :: forall a (t :: a). Sing t -> Sing (Apply Foo3Sym0 t :: a) sFoo2 :: - forall a b (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a) + forall a b (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a) sFoo1 :: - forall a b (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a) + forall a b (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a) sFoo0 :: - forall a b (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo0Sym0 t) t :: a) + forall a b (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply Foo0Sym0 t) t :: a) sFoo8 (sX :: Sing x) = (applySing ((singFun1 @(Apply Lambda_0123456789876543210Sym0 x)) (\ sArg_0123456789876543210 - -> case sArg_0123456789876543210 of { + -> case sArg_0123456789876543210 of (_ :: Sing arg_0123456789876543210) -> (id @(Sing (Case_0123456789876543210 arg_0123456789876543210 x arg_0123456789876543210))) - (case sArg_0123456789876543210 of { - SFoo (sA :: Sing a) _ -> sA }) }))) + (case sArg_0123456789876543210 of SFoo (sA :: Sing a) _ -> sA)))) sX sFoo7 (sX :: Sing x) (sY :: Sing y) = (applySing ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 x) y)) (\ sArg_0123456789876543210 - -> case sArg_0123456789876543210 of { + -> case sArg_0123456789876543210 of (_ :: Sing arg_0123456789876543210) -> (id @(Sing (Case_0123456789876543210 arg_0123456789876543210 x y arg_0123456789876543210))) - (case sArg_0123456789876543210 of { - STuple2 _ (sB :: Sing b) -> sB }) }))) + (case sArg_0123456789876543210 of + STuple2 _ (sB :: Sing b) -> sB)))) ((applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sX)) sY) sFoo6 (sA :: Sing a) (sB :: Sing b) = (applySing ((applySing ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 a) b)) (\ sX - -> case sX of { + -> case sX of (_ :: Sing x) -> (singFun1 @(Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) a) b)) (\ sArg_0123456789876543210 - -> case sArg_0123456789876543210 of { + -> case sArg_0123456789876543210 of (_ :: Sing arg_0123456789876543210) -> (id @(Sing (Case_0123456789876543210 arg_0123456789876543210 x a b arg_0123456789876543210))) - (case sArg_0123456789876543210 of { - _ -> sX }) }) }))) + (case sArg_0123456789876543210 of _ -> sX))))) sA)) sB sFoo5 (sX :: Sing x) (sY :: Sing y) = (applySing ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 x) y)) - (\ sX -> case sX of { (_ :: Sing x) -> sX }))) + (\ sX -> case sX of (_ :: Sing x) -> sX))) sY sFoo4 (sX :: Sing x) (sY :: Sing y) (sZ :: Sing z) = (applySing @@ -635,9 +633,7 @@ ((singFun2 @(Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) z)) (\ sArg_0123456789876543210 sArg_0123456789876543210 - -> case - ((,) sArg_0123456789876543210) sArg_0123456789876543210 - of { + -> case ((,) sArg_0123456789876543210) sArg_0123456789876543210 of (,) (_ :: Sing arg_0123456789876543210) (_ :: Sing arg_0123456789876543210) -> (id @@ -647,24 +643,24 @@ ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sArg_0123456789876543210)) sArg_0123456789876543210 - of { - STuple2 _ _ -> sX }) }))) + of + STuple2 _ _ -> sX)))) sY)) sZ sFoo3 (sX :: Sing x) = (applySing ((singFun1 @(Apply Lambda_0123456789876543210Sym0 x)) - (\ sY -> case sY of { (_ :: Sing y) -> sY }))) + (\ sY -> case sY of (_ :: Sing y) -> sY))) sX sFoo2 (sX :: Sing x) (sY :: Sing y) = (applySing ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 x) y)) (\ sArg_0123456789876543210 - -> case sArg_0123456789876543210 of { + -> case sArg_0123456789876543210 of (_ :: Sing arg_0123456789876543210) -> (id @(Sing (Case_0123456789876543210 arg_0123456789876543210 x y arg_0123456789876543210))) - (case sArg_0123456789876543210 of { _ -> sX }) }))) + (case sArg_0123456789876543210 of _ -> sX)))) sY sFoo1 (sX :: Sing x) @@ -673,11 +669,11 @@ ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 x) a_0123456789876543210)) (\ sArg_0123456789876543210 - -> case sArg_0123456789876543210 of { + -> case sArg_0123456789876543210 of (_ :: Sing arg_0123456789876543210) -> (id @(Sing (Case_0123456789876543210 arg_0123456789876543210 x a_0123456789876543210 arg_0123456789876543210))) - (case sArg_0123456789876543210 of { _ -> sX }) }))) + (case sArg_0123456789876543210 of _ -> sX)))) sA_0123456789876543210 sFoo0 (sA_0123456789876543210 :: Sing a_0123456789876543210) @@ -687,7 +683,7 @@ ((singFun2 @(Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210)) (\ sX sY - -> case ((,) sX) sY of { (,) (_ :: Sing x) (_ :: Sing y) -> sX }))) + -> case ((,) sX) sY of (,) (_ :: Sing x) (_ :: Sing y) -> sX))) sA_0123456789876543210)) sA_0123456789876543210 instance SingI (Foo8Sym0 :: (~>) (Foo a b) a) where @@ -696,38 +692,66 @@ sing = (singFun2 @Foo7Sym0) sFoo7 instance SingI d => SingI (Foo7Sym1 (d :: a) :: (~>) b b) where sing = (singFun1 @(Foo7Sym1 (d :: a))) (sFoo7 (sing @d)) + instance SingI1 (Foo7Sym1 :: a -> (~>) b b) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Foo7Sym1 (d :: a))) (sFoo7 s) instance SingI (Foo6Sym0 :: (~>) a ((~>) b a)) where sing = (singFun2 @Foo6Sym0) sFoo6 instance SingI d => SingI (Foo6Sym1 (d :: a) :: (~>) b a) where sing = (singFun1 @(Foo6Sym1 (d :: a))) (sFoo6 (sing @d)) + instance SingI1 (Foo6Sym1 :: a -> (~>) b a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Foo6Sym1 (d :: a))) (sFoo6 s) instance SingI (Foo5Sym0 :: (~>) a ((~>) b b)) where sing = (singFun2 @Foo5Sym0) sFoo5 instance SingI d => SingI (Foo5Sym1 (d :: a) :: (~>) b b) where sing = (singFun1 @(Foo5Sym1 (d :: a))) (sFoo5 (sing @d)) + instance SingI1 (Foo5Sym1 :: a -> (~>) b b) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Foo5Sym1 (d :: a))) (sFoo5 s) instance SingI (Foo4Sym0 :: (~>) a ((~>) b ((~>) c a))) where sing = (singFun3 @Foo4Sym0) sFoo4 instance SingI d => SingI (Foo4Sym1 (d :: a) :: (~>) b ((~>) c a)) where sing = (singFun2 @(Foo4Sym1 (d :: a))) (sFoo4 (sing @d)) + instance SingI1 (Foo4Sym1 :: a -> (~>) b ((~>) c a)) where + liftSing (s :: Sing (d :: a)) + = (singFun2 @(Foo4Sym1 (d :: a))) (sFoo4 s) instance (SingI d, SingI d) => SingI (Foo4Sym2 (d :: a) (d :: b) :: (~>) c a) where sing = (singFun1 @(Foo4Sym2 (d :: a) (d :: b))) ((sFoo4 (sing @d)) (sing @d)) + instance SingI d => + SingI1 (Foo4Sym2 (d :: a) :: b -> (~>) c a) where + liftSing (s :: Sing (d :: b)) + = (singFun1 @(Foo4Sym2 (d :: a) (d :: b))) ((sFoo4 (sing @d)) s) + instance SingI2 (Foo4Sym2 :: a -> b -> (~>) c a) where + liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b)) + = (singFun1 @(Foo4Sym2 (d :: a) (d :: b))) ((sFoo4 s) s) instance SingI (Foo3Sym0 :: (~>) a a) where sing = (singFun1 @Foo3Sym0) sFoo3 instance SingI (Foo2Sym0 :: (~>) a ((~>) b a)) where sing = (singFun2 @Foo2Sym0) sFoo2 instance SingI d => SingI (Foo2Sym1 (d :: a) :: (~>) b a) where sing = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 (sing @d)) + instance SingI1 (Foo2Sym1 :: a -> (~>) b a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 s) instance SingI (Foo1Sym0 :: (~>) a ((~>) b a)) where sing = (singFun2 @Foo1Sym0) sFoo1 instance SingI d => SingI (Foo1Sym1 (d :: a) :: (~>) b a) where sing = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 (sing @d)) + instance SingI1 (Foo1Sym1 :: a -> (~>) b a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 s) instance SingI (Foo0Sym0 :: (~>) a ((~>) b a)) where sing = (singFun2 @Foo0Sym0) sFoo0 instance SingI d => SingI (Foo0Sym1 (d :: a) :: (~>) b a) where sing = (singFun1 @(Foo0Sym1 (d :: a))) (sFoo0 (sing @d)) + instance SingI1 (Foo0Sym1 :: a -> (~>) b a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Foo0Sym1 (d :: a))) (sFoo0 s) data SFoo :: forall a b. Foo a b -> GHC.Types.Type where SFoo :: forall a b (n :: a) (n :: b). @@ -737,12 +761,19 @@ type Demote (Foo a b) = Foo (Demote a) (Demote b) fromSing (SFoo b b) = (Foo (fromSing b)) (fromSing b) toSing (Foo (b :: Demote a) (b :: Demote b)) - = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SFoo c) c) } + = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SFoo c) c) instance (SingI n, SingI n) => SingI (Foo (n :: a) (n :: b)) where sing = (SFoo sing) sing + instance SingI n => SingI1 (Foo (n :: a)) where + liftSing = SFoo sing + instance SingI2 Foo where + liftSing2 = SFoo instance SingI (FooSym0 :: (~>) a ((~>) b (Foo a b))) where sing = (singFun2 @FooSym0) SFoo instance SingI d => SingI (FooSym1 (d :: a) :: (~>) b (Foo a b)) where sing = (singFun1 @(FooSym1 (d :: a))) (SFoo (sing @d)) + instance SingI1 (FooSym1 :: a -> (~>) b (Foo a b)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(FooSym1 (d :: a))) (SFoo s) diff --git a/tests/compile-and-dump/Singletons/LambdasComprehensive.golden b/tests/compile-and-dump/Singletons/LambdasComprehensive.golden --- a/tests/compile-and-dump/Singletons/LambdasComprehensive.golden +++ b/tests/compile-and-dump/Singletons/LambdasComprehensive.golden @@ -58,14 +58,14 @@ ((applySing ((singFun2 @MapSym0) sMap)) ((singFun1 @Lambda_0123456789876543210Sym0) (\ sX - -> case sX of { + -> case sX of (_ :: Sing x) -> (applySing ((applySing ((applySing ((singFun3 @Either_Sym0) sEither_)) ((singFun1 @PredSym0) sPred))) ((singFun1 @SuccSym0) SSucc))) - sX })))) + sX)))) ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) ((applySing ((singFun1 @LeftSym0) SLeft)) SZero))) diff --git a/tests/compile-and-dump/Singletons/LetStatements.golden b/tests/compile-and-dump/Singletons/LetStatements.golden --- a/tests/compile-and-dump/Singletons/LetStatements.golden +++ b/tests/compile-and-dump/Singletons/LetStatements.golden @@ -801,15 +801,15 @@ sZ = (id @(Sing (Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x)))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of STuple2 _ (sY_0123456789876543210 :: Sing y_0123456789876543210) - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sY = (id @(Sing (Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x)))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of STuple2 (sY_0123456789876543210 :: Sing y_0123456789876543210) _ - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sX_0123456789876543210 = (applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) @@ -825,10 +825,9 @@ sFoo12 (sX :: Sing x) = let (%+) :: - forall (t :: Nat) (t :: Nat). - Sing t - -> Sing t - -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat) + forall (t :: Nat) (t :: Nat). Sing t + -> Sing t + -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat) (%+) SZero (sM :: Sing m) = sM (%+) (SSucc (sN :: Sing n)) (sM :: Sing m) = (applySing ((singFun1 @SuccSym0) SSucc)) @@ -846,10 +845,9 @@ = let sZ :: Sing (Let0123456789876543210ZSym1 x :: Nat) (%+) :: - forall (t :: Nat) (t :: Nat). - Sing t - -> Sing t - -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat) + forall (t :: Nat) (t :: Nat). Sing t + -> Sing t + -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat) sZ = sX (%+) SZero (sM :: Sing m) = sM (%+) (SSucc (sN :: Sing n)) (sM :: Sing m) @@ -866,10 +864,9 @@ sFoo10 (sX :: Sing x) = let (%+) :: - forall (t :: Nat) (t :: Nat). - Sing t - -> Sing t - -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat) + forall (t :: Nat) (t :: Nat). Sing t + -> Sing t + -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat) (%+) SZero (sM :: Sing m) = sM (%+) (SSucc (sN :: Sing n)) (sM :: Sing m) = (applySing ((singFun1 @SuccSym0) SSucc)) @@ -885,13 +882,13 @@ sFoo9 (sX :: Sing x) = let sZ :: - forall (t :: Nat). - Sing t -> Sing (Apply (Let0123456789876543210ZSym1 x) t :: Nat) + forall (t :: Nat). Sing t + -> Sing (Apply (Let0123456789876543210ZSym1 x) t :: Nat) sZ (sA_0123456789876543210 :: Sing a_0123456789876543210) = (applySing ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) x)) - (\ sX -> case sX of { (_ :: Sing x) -> sX }))) + (\ sX -> case sX of (_ :: Sing x) -> sX))) sA_0123456789876543210 in (applySing ((singFun1 @(Let0123456789876543210ZSym1 x)) sZ)) sX sFoo8 (sX :: Sing x) @@ -900,7 +897,7 @@ sZ = (applySing ((singFun1 @(Apply Lambda_0123456789876543210Sym0 x)) - (\ sX -> case sX of { (_ :: Sing x) -> sX }))) + (\ sX -> case sX of (_ :: Sing x) -> sX))) SZero in sZ sFoo7 (sX :: Sing x) @@ -911,8 +908,8 @@ sFoo6 (sX :: Sing x) = let sF :: - forall (t :: Nat). - Sing t -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat) + forall (t :: Nat). Sing t + -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat) sF (sY :: Sing y) = (applySing ((singFun1 @SuccSym0) SSucc)) sY in let sZ :: Sing (Let0123456789876543210ZSym1 x :: Nat) @@ -922,8 +919,8 @@ sFoo5 (sX :: Sing x) = let sF :: - forall (t :: Nat). - Sing t -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat) + forall (t :: Nat). Sing t + -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat) sF (sY :: Sing y) = let sZ :: Sing (Let0123456789876543210ZSym2 y x :: Nat) @@ -933,8 +930,8 @@ sFoo4 (sX :: Sing x) = let sF :: - forall (t :: Nat). - Sing t -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat) + forall (t :: Nat). Sing t + -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat) sF (sY :: Sing y) = (applySing ((singFun1 @SuccSym0) SSucc)) sY in (applySing ((singFun1 @(Let0123456789876543210FSym1 x)) sF)) sX sFoo3 (sX :: Sing x) diff --git a/tests/compile-and-dump/Singletons/Maybe.golden b/tests/compile-and-dump/Singletons/Maybe.golden --- a/tests/compile-and-dump/Singletons/Maybe.golden +++ b/tests/compile-and-dump/Singletons/Maybe.golden @@ -51,13 +51,13 @@ TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 instance PEq (Maybe a) where type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural -> Maybe a -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: Maybe a) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Maybe a) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where ShowsPrec_0123456789876543210 _ Nothing a_0123456789876543210 = Apply (Apply ShowStringSym0 "Nothing") a_0123456789876543210 ShowsPrec_0123456789876543210 p_0123456789876543210 (Just arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Just ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) where ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => ShowsPrec_0123456789876543210Sym0 a0123456789876543210 @@ -65,9 +65,9 @@ instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> (~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol) where ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -75,9 +75,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural -> Maybe a -> (~>) GHC.Types.Symbol GHC.Types.Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Maybe a) :: (~>) GHC.Types.Symbol GHC.Types.Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Maybe a) :: (~>) GHC.Types.Symbol GHC.Types.Symbol where ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -85,9 +85,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural -> Maybe a -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Maybe a) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Maybe a) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow (Maybe a) where type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a @@ -102,15 +102,13 @@ fromSing (SJust b) = Just (fromSing b) toSing Nothing = SomeSing SNothing toSing (Just (b :: Demote a)) - = case toSing b :: SomeSing a of { - SomeSing c -> SomeSing (SJust c) } + = case toSing b :: SomeSing a of SomeSing c -> SomeSing (SJust c) instance SEq a => SEq (Maybe a) where (%==) :: - forall (t1 :: Maybe a) (t2 :: Maybe a). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun (Maybe a) ((~>) (Maybe a) Bool) - -> GHC.Types.Type) t1) t2) + forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun (Maybe a) ((~>) (Maybe a) Bool) + -> GHC.Types.Type) t1) t2) (%==) SNothing SNothing = STrue (%==) SNothing (SJust _) = SFalse (%==) (SJust _) SNothing = SFalse @@ -122,14 +120,13 @@ sB_0123456789876543210 instance SShow a => SShow (Maybe a) where sShowsPrec :: - forall (t1 :: GHC.Types.Nat) + forall (t1 :: GHC.Num.Natural.Natural) (t2 :: Maybe a) - (t3 :: GHC.Types.Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - -> GHC.Types.Type) t1) t2) t3) + (t3 :: GHC.Types.Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + -> GHC.Types.Type) t1) t2) t3) sShowsPrec _ SNothing @@ -159,13 +156,13 @@ sA_0123456789876543210 instance SDecide a => SDecide (Maybe a) where (%~) SNothing SNothing = Proved Refl - (%~) SNothing (SJust _) = Disproved (\ x -> case x of) - (%~) (SJust _) SNothing = Disproved (\ x -> case x of) + (%~) SNothing (SJust _) = Disproved (\ x -> case x of {}) + (%~) (SJust _) SNothing = Disproved (\ x -> case x of {}) (%~) (SJust a) (SJust b) = case ((%~) a) b of Proved Refl -> Proved Refl Disproved contra - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) instance SDecide a => Data.Type.Equality.TestEquality (SMaybe :: Maybe a -> GHC.Types.Type) where @@ -182,5 +179,7 @@ sing = SNothing instance SingI n => SingI (Just (n :: a)) where sing = SJust sing + instance SingI1 Just where + liftSing = SJust instance SingI (JustSym0 :: (~>) a (Maybe a)) where sing = (singFun1 @JustSym0) SJust diff --git a/tests/compile-and-dump/Singletons/Nat.golden b/tests/compile-and-dump/Singletons/Nat.golden --- a/tests/compile-and-dump/Singletons/Nat.golden +++ b/tests/compile-and-dump/Singletons/Nat.golden @@ -105,13 +105,13 @@ TFHelper_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210 instance PEq Nat where type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural -> Nat -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: Nat) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Nat) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where ShowsPrec_0123456789876543210 _ Zero a_0123456789876543210 = Apply (Apply ShowStringSym0 "Zero") a_0123456789876543210 ShowsPrec_0123456789876543210 p_0123456789876543210 (Succ arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Succ ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol)) where ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => ShowsPrec_0123456789876543210Sym0 a0123456789876543210 @@ -119,9 +119,9 @@ instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> (~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol) where ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -129,9 +129,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural -> Nat -> (~>) GHC.Types.Symbol GHC.Types.Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Nat) :: (~>) GHC.Types.Symbol GHC.Types.Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Nat) :: (~>) GHC.Types.Symbol GHC.Types.Symbol where ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -139,9 +139,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural -> Nat -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Nat) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Nat) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow Nat where type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a @@ -177,8 +177,8 @@ sPred :: forall (t :: Nat). Sing t -> Sing (Apply PredSym0 t :: Nat) sPlus :: - forall (t :: Nat) (t :: Nat). - Sing t -> Sing t -> Sing (Apply (Apply PlusSym0 t) t :: Nat) + forall (t :: Nat) (t :: Nat). Sing t + -> Sing t -> Sing (Apply (Apply PlusSym0 t) t :: Nat) sPred SZero = SZero sPred (SSucc (sN :: Sing n)) = sN sPlus SZero (sM :: Sing m) = sM @@ -192,6 +192,9 @@ instance SingI d => SingI (PlusSym1 (d :: Nat) :: (~>) Nat Nat) where sing = (singFun1 @(PlusSym1 (d :: Nat))) (sPlus (sing @d)) + instance SingI1 (PlusSym1 :: Nat -> (~>) Nat Nat) where + liftSing (s :: Sing (d :: Nat)) + = (singFun1 @(PlusSym1 (d :: Nat))) (sPlus s) data SNat :: Nat -> GHC.Types.Type where SZero :: SNat (Zero :: Nat) @@ -203,15 +206,13 @@ fromSing (SSucc b) = Succ (fromSing b) toSing Zero = SomeSing SZero toSing (Succ (b :: Demote Nat)) - = case toSing b :: SomeSing Nat of { - SomeSing c -> SomeSing (SSucc c) } + = case toSing b :: SomeSing Nat of SomeSing c -> SomeSing (SSucc c) instance SEq Nat => SEq Nat where (%==) :: - forall (t1 :: Nat) (t2 :: Nat). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun Nat ((~>) Nat Bool) - -> GHC.Types.Type) t1) t2) + forall (t1 :: Nat) (t2 :: Nat). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun Nat ((~>) Nat Bool) + -> GHC.Types.Type) t1) t2) (%==) SZero SZero = STrue (%==) SZero (SSucc _) = SFalse (%==) (SSucc _) SZero = SFalse @@ -223,12 +224,13 @@ sB_0123456789876543210 instance SShow Nat => SShow Nat where sShowsPrec :: - forall (t1 :: GHC.Types.Nat) (t2 :: Nat) (t3 :: GHC.Types.Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - -> GHC.Types.Type) t1) t2) t3) + forall (t1 :: GHC.Num.Natural.Natural) + (t2 :: Nat) + (t3 :: GHC.Types.Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + -> GHC.Types.Type) t1) t2) t3) sShowsPrec _ SZero @@ -258,11 +260,10 @@ sA_0123456789876543210 instance SOrd Nat => SOrd Nat where sCompare :: - forall (t1 :: Nat) (t2 :: Nat). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat ((~>) Nat Ordering) - -> GHC.Types.Type) t1) t2) + forall (t1 :: Nat) (t2 :: Nat). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat ((~>) Nat Ordering) + -> GHC.Types.Type) t1) t2) sCompare SZero SZero = (applySing ((applySing @@ -289,13 +290,13 @@ sCompare (SSucc _) SZero = SGT instance SDecide Nat => SDecide Nat where (%~) SZero SZero = Proved Refl - (%~) SZero (SSucc _) = Disproved (\ x -> case x of) - (%~) (SSucc _) SZero = Disproved (\ x -> case x of) + (%~) SZero (SSucc _) = Disproved (\ x -> case x of {}) + (%~) (SSucc _) SZero = Disproved (\ x -> case x of {}) (%~) (SSucc a) (SSucc b) = case ((%~) a) b of Proved Refl -> Proved Refl Disproved contra - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) instance SDecide Nat => Data.Type.Equality.TestEquality (SNat :: Nat -> GHC.Types.Type) where @@ -312,5 +313,7 @@ sing = SZero instance SingI n => SingI (Succ (n :: Nat)) where sing = SSucc sing + instance SingI1 Succ where + liftSing = SSucc instance SingI (SuccSym0 :: (~>) Nat Nat) where sing = (singFun1 @SuccSym0) SSucc diff --git a/tests/compile-and-dump/Singletons/NatSymbolReflexive.hs b/tests/compile-and-dump/Singletons/NatSymbolReflexive.hs --- a/tests/compile-and-dump/Singletons/NatSymbolReflexive.hs +++ b/tests/compile-and-dump/Singletons/NatSymbolReflexive.hs @@ -4,7 +4,7 @@ import GHC.TypeLits import Prelude.Singletons -test1 :: forall (a :: Nat). Sing a -> (a == a) :~: True +test1 :: forall (a :: Natural). Sing a -> (a == a) :~: True test1 _ = Refl test2 :: forall (a :: Symbol). Sing a -> (a == a) :~: True diff --git a/tests/compile-and-dump/Singletons/Natural.golden b/tests/compile-and-dump/Singletons/Natural.golden new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/Natural.golden @@ -0,0 +1,78 @@ +Singletons/Natural.hs:(0,0)-(0,0): Splicing declarations + singletons + [d| addAge :: Age -> Age -> Age + addAge (MkAge (x :: Natural)) (MkAge (y :: Natural)) + = MkAge (x + y :: Natural) + + newtype Age = MkAge Natural |] + ======> + newtype Age = MkAge Natural + addAge :: Age -> Age -> Age + addAge (MkAge (x :: Natural)) (MkAge (y :: Natural)) + = MkAge ((x + y) :: Natural) + type MkAgeSym0 :: (~>) Natural Age + data MkAgeSym0 :: (~>) Natural Age + where + MkAgeSym0KindInference :: SameKind (Apply MkAgeSym0 arg) (MkAgeSym1 arg) => + MkAgeSym0 a0123456789876543210 + type instance Apply MkAgeSym0 a0123456789876543210 = MkAge a0123456789876543210 + instance SuppressUnusedWarnings MkAgeSym0 where + suppressUnusedWarnings = snd (((,) MkAgeSym0KindInference) ()) + type MkAgeSym1 :: Natural -> Age + type family MkAgeSym1 (a0123456789876543210 :: Natural) :: Age where + MkAgeSym1 a0123456789876543210 = MkAge a0123456789876543210 + type AddAgeSym0 :: (~>) Age ((~>) Age Age) + data AddAgeSym0 :: (~>) Age ((~>) Age Age) + where + AddAgeSym0KindInference :: SameKind (Apply AddAgeSym0 arg) (AddAgeSym1 arg) => + AddAgeSym0 a0123456789876543210 + type instance Apply AddAgeSym0 a0123456789876543210 = AddAgeSym1 a0123456789876543210 + instance SuppressUnusedWarnings AddAgeSym0 where + suppressUnusedWarnings = snd (((,) AddAgeSym0KindInference) ()) + type AddAgeSym1 :: Age -> (~>) Age Age + data AddAgeSym1 (a0123456789876543210 :: Age) :: (~>) Age Age + where + AddAgeSym1KindInference :: SameKind (Apply (AddAgeSym1 a0123456789876543210) arg) (AddAgeSym2 a0123456789876543210 arg) => + AddAgeSym1 a0123456789876543210 a0123456789876543210 + type instance Apply (AddAgeSym1 a0123456789876543210) a0123456789876543210 = AddAge a0123456789876543210 a0123456789876543210 + instance SuppressUnusedWarnings (AddAgeSym1 a0123456789876543210) where + suppressUnusedWarnings = snd (((,) AddAgeSym1KindInference) ()) + type AddAgeSym2 :: Age -> Age -> Age + type family AddAgeSym2 (a0123456789876543210 :: Age) (a0123456789876543210 :: Age) :: Age where + AddAgeSym2 a0123456789876543210 a0123456789876543210 = AddAge a0123456789876543210 a0123456789876543210 + type AddAge :: Age -> Age -> Age + type family AddAge (a :: Age) (a :: Age) :: Age where + AddAge (MkAge (x :: Natural)) (MkAge (y :: Natural)) = Apply MkAgeSym0 (Apply (Apply (+@#@$) x) y :: Natural) + sAddAge :: + forall (t :: Age) (t :: Age). Sing t + -> Sing t -> Sing (Apply (Apply AddAgeSym0 t) t :: Age) + sAddAge (SMkAge (sX :: Sing x)) (SMkAge (sY :: Sing y)) + = case ((,) (sX :: Sing x)) (sY :: Sing y) of + (,) (_ :: Sing (x :: Natural)) (_ :: Sing (y :: Natural)) + -> (applySing ((singFun1 @MkAgeSym0) SMkAge)) + ((applySing ((applySing ((singFun2 @(+@#@$)) (%+))) sX)) sY :: + Sing (Apply (Apply (+@#@$) x) y :: Natural)) + instance SingI (AddAgeSym0 :: (~>) Age ((~>) Age Age)) where + sing = (singFun2 @AddAgeSym0) sAddAge + instance SingI d => + SingI (AddAgeSym1 (d :: Age) :: (~>) Age Age) where + sing = (singFun1 @(AddAgeSym1 (d :: Age))) (sAddAge (sing @d)) + instance SingI1 (AddAgeSym1 :: Age -> (~>) Age Age) where + liftSing (s :: Sing (d :: Age)) + = (singFun1 @(AddAgeSym1 (d :: Age))) (sAddAge s) + data SAge :: Age -> GHC.Types.Type + where + SMkAge :: forall (n :: Natural). (Sing n) -> SAge (MkAge n :: Age) + type instance Sing @Age = SAge + instance SingKind Age where + type Demote Age = Age + fromSing (SMkAge b) = MkAge (fromSing b) + toSing (MkAge (b :: Demote Natural)) + = case toSing b :: SomeSing Natural of + SomeSing c -> SomeSing (SMkAge c) + instance SingI n => SingI (MkAge (n :: Natural)) where + sing = SMkAge sing + instance SingI1 MkAge where + liftSing = SMkAge + instance SingI (MkAgeSym0 :: (~>) Natural Age) where + sing = (singFun1 @MkAgeSym0) SMkAge diff --git a/tests/compile-and-dump/Singletons/Natural.hs b/tests/compile-and-dump/Singletons/Natural.hs new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/Natural.hs @@ -0,0 +1,13 @@ +module Singletons.Natural where + +import Data.Singletons.TH +import Numeric.Natural (Natural) +import Prelude.Singletons + +$(singletons [d| + newtype Age = MkAge Natural + + addAge :: Age -> Age -> Age + addAge (MkAge (x :: Natural)) (MkAge (y :: Natural)) = + MkAge (x + y :: Natural) + |]) diff --git a/tests/compile-and-dump/Singletons/NegativeLiterals.golden b/tests/compile-and-dump/Singletons/NegativeLiterals.golden --- a/tests/compile-and-dump/Singletons/NegativeLiterals.golden +++ b/tests/compile-and-dump/Singletons/NegativeLiterals.golden @@ -1,15 +1,21 @@ Singletons/NegativeLiterals.hs:(0,0)-(0,0): Splicing declarations singletons - [d| f :: Nat + [d| f :: Natural f = -1 |] ======> - f :: Nat + f :: Natural f = (-1) - type FSym0 :: Nat - type family FSym0 :: Nat where + type FSym0 :: Natural + type family FSym0 :: Natural where FSym0 = F - type F :: Nat - type family F :: Nat where + type F :: Natural + type family F :: Natural where F = Negate (FromInteger 1) - sF :: Sing (FSym0 :: Nat) + sF :: Sing (FSym0 :: Natural) sF = sNegate (sFromInteger (sing :: Sing 1)) + +Singletons/NegativeLiterals.hs:0:0: warning: [-Woverflowed-literals] + Literal -1 is negative but Natural only supports positive numbers + | +7 | $(singletons [d| + | ^^^^^^^^^^^^^^^... diff --git a/tests/compile-and-dump/Singletons/NegativeLiterals.hs b/tests/compile-and-dump/Singletons/NegativeLiterals.hs --- a/tests/compile-and-dump/Singletons/NegativeLiterals.hs +++ b/tests/compile-and-dump/Singletons/NegativeLiterals.hs @@ -2,9 +2,9 @@ module Singletons.NegativeLiterals where import Data.Singletons.Base.TH -import GHC.TypeNats (Nat) +import Numeric.Natural (Natural) $(singletons [d| - f :: Nat + f :: Natural f = -1 |]) diff --git a/tests/compile-and-dump/Singletons/Operators.golden b/tests/compile-and-dump/Singletons/Operators.golden --- a/tests/compile-and-dump/Singletons/Operators.golden +++ b/tests/compile-and-dump/Singletons/Operators.golden @@ -83,8 +83,8 @@ Child FLeaf = FLeafSym0 Child ((:+:) a _) = a (%+) :: - forall (t :: Nat) (t :: Nat). - Sing t -> Sing t -> Sing (Apply (Apply (+@#@$) t) t :: Nat) + forall (t :: Nat) (t :: Nat). Sing t + -> Sing t -> Sing (Apply (Apply (+@#@$) t) t :: Nat) sChild :: forall (t :: Foo). Sing t -> Sing (Apply ChildSym0 t :: Foo) (%+) SZero (sM :: Sing m) = sM @@ -98,6 +98,9 @@ instance SingI d => SingI ((+@#@$$) (d :: Nat) :: (~>) Nat Nat) where sing = (singFun1 @((+@#@$$) (d :: Nat))) ((%+) (sing @d)) + instance SingI1 ((+@#@$$) :: Nat -> (~>) Nat Nat) where + liftSing (s :: Sing (d :: Nat)) + = (singFun1 @((+@#@$$) (d :: Nat))) ((%+) s) instance SingI (ChildSym0 :: (~>) Foo Foo) where sing = (singFun1 @ChildSym0) sChild data SFoo :: Foo -> GHC.Types.Type @@ -114,15 +117,22 @@ toSing ((:+:) (b :: Demote Foo) (b :: Demote Foo)) = case ((,) (toSing b :: SomeSing Foo)) (toSing b :: SomeSing Foo) - of { - (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%+:) c) c) } + of + (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%+:) c) c) instance SingI FLeaf where sing = SFLeaf instance (SingI n, SingI n) => SingI ((:+:) (n :: Foo) (n :: Foo)) where sing = ((:%+:) sing) sing + instance SingI n => SingI1 ((:+:) (n :: Foo)) where + liftSing = (:%+:) sing + instance SingI2 (:+:) where + liftSing2 = (:%+:) instance SingI ((:+:@#@$) :: (~>) Foo ((~>) Foo Foo)) where sing = (singFun2 @(:+:@#@$)) (:%+:) instance SingI d => SingI ((:+:@#@$$) (d :: Foo) :: (~>) Foo Foo) where sing = (singFun1 @((:+:@#@$$) (d :: Foo))) ((:%+:) (sing @d)) + instance SingI1 ((:+:@#@$$) :: Foo -> (~>) Foo Foo) where + liftSing (s :: Sing (d :: Foo)) + = (singFun1 @((:+:@#@$$) (d :: Foo))) ((:%+:) s) diff --git a/tests/compile-and-dump/Singletons/OrdDeriving.golden b/tests/compile-and-dump/Singletons/OrdDeriving.golden --- a/tests/compile-and-dump/Singletons/OrdDeriving.golden +++ b/tests/compile-and-dump/Singletons/OrdDeriving.golden @@ -37,8 +37,10 @@ type SuccSym1 :: Nat -> Nat type family SuccSym1 (a0123456789876543210 :: Nat) :: Nat where SuccSym1 a0123456789876543210 = Succ a0123456789876543210 - type ASym0 :: forall a b c d. - (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) + type ASym0 :: forall a + b + c + d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) data ASym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) where ASym0KindInference :: SameKind (Apply ASym0 arg) (ASym1 arg) => @@ -46,8 +48,8 @@ type instance Apply ASym0 a0123456789876543210 = ASym1 a0123456789876543210 instance SuppressUnusedWarnings ASym0 where suppressUnusedWarnings = snd (((,) ASym0KindInference) ()) - type ASym1 :: forall a b c d. - a -> (~>) b ((~>) c ((~>) d (Foo a b c d))) + type ASym1 :: forall a b c d. a + -> (~>) b ((~>) c ((~>) d (Foo a b c d))) data ASym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d))) where ASym1KindInference :: SameKind (Apply (ASym1 a0123456789876543210) arg) (ASym2 a0123456789876543210 arg) => @@ -55,8 +57,8 @@ type instance Apply (ASym1 a0123456789876543210) a0123456789876543210 = ASym2 a0123456789876543210 a0123456789876543210 instance SuppressUnusedWarnings (ASym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ASym1KindInference) ()) - type ASym2 :: forall a b c d. - a -> b -> (~>) c ((~>) d (Foo a b c d)) + type ASym2 :: forall a b c d. a + -> b -> (~>) c ((~>) d (Foo a b c d)) data ASym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d)) where ASym2KindInference :: SameKind (Apply (ASym2 a0123456789876543210 a0123456789876543210) arg) (ASym3 a0123456789876543210 a0123456789876543210 arg) => @@ -75,8 +77,10 @@ type ASym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d type family ASym4 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where ASym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = A a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - type BSym0 :: forall a b c d. - (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) + type BSym0 :: forall a + b + c + d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) data BSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) where BSym0KindInference :: SameKind (Apply BSym0 arg) (BSym1 arg) => @@ -84,8 +88,8 @@ type instance Apply BSym0 a0123456789876543210 = BSym1 a0123456789876543210 instance SuppressUnusedWarnings BSym0 where suppressUnusedWarnings = snd (((,) BSym0KindInference) ()) - type BSym1 :: forall a b c d. - a -> (~>) b ((~>) c ((~>) d (Foo a b c d))) + type BSym1 :: forall a b c d. a + -> (~>) b ((~>) c ((~>) d (Foo a b c d))) data BSym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d))) where BSym1KindInference :: SameKind (Apply (BSym1 a0123456789876543210) arg) (BSym2 a0123456789876543210 arg) => @@ -93,8 +97,8 @@ type instance Apply (BSym1 a0123456789876543210) a0123456789876543210 = BSym2 a0123456789876543210 a0123456789876543210 instance SuppressUnusedWarnings (BSym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) BSym1KindInference) ()) - type BSym2 :: forall a b c d. - a -> b -> (~>) c ((~>) d (Foo a b c d)) + type BSym2 :: forall a b c d. a + -> b -> (~>) c ((~>) d (Foo a b c d)) data BSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d)) where BSym2KindInference :: SameKind (Apply (BSym2 a0123456789876543210 a0123456789876543210) arg) (BSym3 a0123456789876543210 a0123456789876543210 arg) => @@ -113,8 +117,10 @@ type BSym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d type family BSym4 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where BSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = B a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - type CSym0 :: forall a b c d. - (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) + type CSym0 :: forall a + b + c + d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) data CSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) where CSym0KindInference :: SameKind (Apply CSym0 arg) (CSym1 arg) => @@ -122,8 +128,8 @@ type instance Apply CSym0 a0123456789876543210 = CSym1 a0123456789876543210 instance SuppressUnusedWarnings CSym0 where suppressUnusedWarnings = snd (((,) CSym0KindInference) ()) - type CSym1 :: forall a b c d. - a -> (~>) b ((~>) c ((~>) d (Foo a b c d))) + type CSym1 :: forall a b c d. a + -> (~>) b ((~>) c ((~>) d (Foo a b c d))) data CSym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d))) where CSym1KindInference :: SameKind (Apply (CSym1 a0123456789876543210) arg) (CSym2 a0123456789876543210 arg) => @@ -131,8 +137,8 @@ type instance Apply (CSym1 a0123456789876543210) a0123456789876543210 = CSym2 a0123456789876543210 a0123456789876543210 instance SuppressUnusedWarnings (CSym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) CSym1KindInference) ()) - type CSym2 :: forall a b c d. - a -> b -> (~>) c ((~>) d (Foo a b c d)) + type CSym2 :: forall a b c d. a + -> b -> (~>) c ((~>) d (Foo a b c d)) data CSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d)) where CSym2KindInference :: SameKind (Apply (CSym2 a0123456789876543210 a0123456789876543210) arg) (CSym3 a0123456789876543210 a0123456789876543210 arg) => @@ -151,8 +157,10 @@ type CSym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d type family CSym4 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where CSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = C a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - type DSym0 :: forall a b c d. - (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) + type DSym0 :: forall a + b + c + d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) data DSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) where DSym0KindInference :: SameKind (Apply DSym0 arg) (DSym1 arg) => @@ -160,8 +168,8 @@ type instance Apply DSym0 a0123456789876543210 = DSym1 a0123456789876543210 instance SuppressUnusedWarnings DSym0 where suppressUnusedWarnings = snd (((,) DSym0KindInference) ()) - type DSym1 :: forall a b c d. - a -> (~>) b ((~>) c ((~>) d (Foo a b c d))) + type DSym1 :: forall a b c d. a + -> (~>) b ((~>) c ((~>) d (Foo a b c d))) data DSym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d))) where DSym1KindInference :: SameKind (Apply (DSym1 a0123456789876543210) arg) (DSym2 a0123456789876543210 arg) => @@ -169,8 +177,8 @@ type instance Apply (DSym1 a0123456789876543210) a0123456789876543210 = DSym2 a0123456789876543210 a0123456789876543210 instance SuppressUnusedWarnings (DSym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) DSym1KindInference) ()) - type DSym2 :: forall a b c d. - a -> b -> (~>) c ((~>) d (Foo a b c d)) + type DSym2 :: forall a b c d. a + -> b -> (~>) c ((~>) d (Foo a b c d)) data DSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d)) where DSym2KindInference :: SameKind (Apply (DSym2 a0123456789876543210 a0123456789876543210) arg) (DSym3 a0123456789876543210 a0123456789876543210 arg) => @@ -189,8 +197,10 @@ type DSym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d type family DSym4 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where DSym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = D a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - type ESym0 :: forall a b c d. - (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) + type ESym0 :: forall a + b + c + d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) data ESym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) where ESym0KindInference :: SameKind (Apply ESym0 arg) (ESym1 arg) => @@ -198,8 +208,8 @@ type instance Apply ESym0 a0123456789876543210 = ESym1 a0123456789876543210 instance SuppressUnusedWarnings ESym0 where suppressUnusedWarnings = snd (((,) ESym0KindInference) ()) - type ESym1 :: forall a b c d. - a -> (~>) b ((~>) c ((~>) d (Foo a b c d))) + type ESym1 :: forall a b c d. a + -> (~>) b ((~>) c ((~>) d (Foo a b c d))) data ESym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d))) where ESym1KindInference :: SameKind (Apply (ESym1 a0123456789876543210) arg) (ESym2 a0123456789876543210 arg) => @@ -207,8 +217,8 @@ type instance Apply (ESym1 a0123456789876543210) a0123456789876543210 = ESym2 a0123456789876543210 a0123456789876543210 instance SuppressUnusedWarnings (ESym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ESym1KindInference) ()) - type ESym2 :: forall a b c d. - a -> b -> (~>) c ((~>) d (Foo a b c d)) + type ESym2 :: forall a b c d. a + -> b -> (~>) c ((~>) d (Foo a b c d)) data ESym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d)) where ESym2KindInference :: SameKind (Apply (ESym2 a0123456789876543210 a0123456789876543210) arg) (ESym3 a0123456789876543210 a0123456789876543210 arg) => @@ -227,8 +237,10 @@ type ESym4 :: forall a b c d. a -> b -> c -> d -> Foo a b c d type family ESym4 (a0123456789876543210 :: a) (a0123456789876543210 :: b) (a0123456789876543210 :: c) (a0123456789876543210 :: d) :: Foo a b c d where ESym4 a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 = E a0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 - type FSym0 :: forall a b c d. - (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) + type FSym0 :: forall a + b + c + d. (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) data FSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d)))) where FSym0KindInference :: SameKind (Apply FSym0 arg) (FSym1 arg) => @@ -236,8 +248,8 @@ type instance Apply FSym0 a0123456789876543210 = FSym1 a0123456789876543210 instance SuppressUnusedWarnings FSym0 where suppressUnusedWarnings = snd (((,) FSym0KindInference) ()) - type FSym1 :: forall a b c d. - a -> (~>) b ((~>) c ((~>) d (Foo a b c d))) + type FSym1 :: forall a b c d. a + -> (~>) b ((~>) c ((~>) d (Foo a b c d))) data FSym1 (a0123456789876543210 :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d))) where FSym1KindInference :: SameKind (Apply (FSym1 a0123456789876543210) arg) (FSym2 a0123456789876543210 arg) => @@ -245,8 +257,8 @@ type instance Apply (FSym1 a0123456789876543210) a0123456789876543210 = FSym2 a0123456789876543210 a0123456789876543210 instance SuppressUnusedWarnings (FSym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) FSym1KindInference) ()) - type FSym2 :: forall a b c d. - a -> b -> (~>) c ((~>) d (Foo a b c d)) + type FSym2 :: forall a b c d. a + -> b -> (~>) c ((~>) d (Foo a b c d)) data FSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: (~>) c ((~>) d (Foo a b c d)) where FSym2KindInference :: SameKind (Apply (FSym2 a0123456789876543210 a0123456789876543210) arg) (FSym3 a0123456789876543210 a0123456789876543210 arg) => @@ -462,8 +474,7 @@ fromSing (SSucc b) = Succ (fromSing b) toSing Zero = SomeSing SZero toSing (Succ (b :: Demote Nat)) - = case toSing b :: SomeSing Nat of { - SomeSing c -> SomeSing (SSucc c) } + = case toSing b :: SomeSing Nat of SomeSing c -> SomeSing (SSucc c) data SFoo :: forall a b c d. Foo a b c d -> GHC.Types.Type where SA :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d). @@ -524,61 +535,60 @@ ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b)) (toSing b :: SomeSing c)) (toSing b :: SomeSing d) - of { + of (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) - -> SomeSing ((((SA c) c) c) c) } + -> SomeSing ((((SA c) c) c) c) toSing (B (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d)) = case ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b)) (toSing b :: SomeSing c)) (toSing b :: SomeSing d) - of { + of (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) - -> SomeSing ((((SB c) c) c) c) } + -> SomeSing ((((SB c) c) c) c) toSing (C (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d)) = case ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b)) (toSing b :: SomeSing c)) (toSing b :: SomeSing d) - of { + of (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) - -> SomeSing ((((SC c) c) c) c) } + -> SomeSing ((((SC c) c) c) c) toSing (D (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d)) = case ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b)) (toSing b :: SomeSing c)) (toSing b :: SomeSing d) - of { + of (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) - -> SomeSing ((((SD c) c) c) c) } + -> SomeSing ((((SD c) c) c) c) toSing (E (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d)) = case ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b)) (toSing b :: SomeSing c)) (toSing b :: SomeSing d) - of { + of (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) - -> SomeSing ((((SE c) c) c) c) } + -> SomeSing ((((SE c) c) c) c) toSing (F (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d)) = case ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b)) (toSing b :: SomeSing c)) (toSing b :: SomeSing d) - of { + of (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) - -> SomeSing ((((SF c) c) c) c) } + -> SomeSing ((((SF c) c) c) c) instance SEq Nat => SEq Nat where (%==) :: - forall (t1 :: Nat) (t2 :: Nat). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun Nat ((~>) Nat Bool) - -> GHC.Types.Type) t1) t2) + forall (t1 :: Nat) (t2 :: Nat). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun Nat ((~>) Nat Bool) + -> GHC.Types.Type) t1) t2) (%==) SZero SZero = STrue (%==) SZero (SSucc _) = SFalse (%==) (SSucc _) SZero = SFalse @@ -590,11 +600,10 @@ sB_0123456789876543210 instance SOrd Nat => SOrd Nat where sCompare :: - forall (t1 :: Nat) (t2 :: Nat). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat ((~>) Nat Ordering) - -> GHC.Types.Type) t1) t2) + forall (t1 :: Nat) (t2 :: Nat). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat ((~>) Nat Ordering) + -> GHC.Types.Type) t1) t2) sCompare SZero SZero = (applySing ((applySing @@ -621,11 +630,10 @@ sCompare (SSucc _) SZero = SGT instance (SEq a, SEq b, SEq c, SEq d) => SEq (Foo a b c d) where (%==) :: - forall (t1 :: Foo a b c d) (t2 :: Foo a b c d). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun (Foo a b c d) ((~>) (Foo a b c d) Bool) - -> GHC.Types.Type) t1) t2) + forall (t1 :: Foo a b c d) (t2 :: Foo a b c d). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun (Foo a b c d) ((~>) (Foo a b c d) Bool) + -> GHC.Types.Type) t1) t2) (%==) (SA (sA_0123456789876543210 :: Sing a_0123456789876543210) (sA_0123456789876543210 :: Sing a_0123456789876543210) @@ -821,11 +829,10 @@ instance (SOrd a, SOrd b, SOrd c, SOrd d) => SOrd (Foo a b c d) where sCompare :: - forall (t1 :: Foo a b c d) (t2 :: Foo a b c d). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (CompareSym0 :: TyFun (Foo a b c d) ((~>) (Foo a b c d) Ordering) - -> GHC.Types.Type) t1) t2) + forall (t1 :: Foo a b c d) (t2 :: Foo a b c d). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (CompareSym0 :: TyFun (Foo a b c d) ((~>) (Foo a b c d) Ordering) + -> GHC.Types.Type) t1) t2) sCompare (SA (sA_0123456789876543210 :: Sing a_0123456789876543210) (sA_0123456789876543210 :: Sing a_0123456789876543210) @@ -1092,13 +1099,13 @@ sCompare (SF _ _ _ _) (SE _ _ _ _) = SGT instance SDecide Nat => SDecide Nat where (%~) SZero SZero = Proved Refl - (%~) SZero (SSucc _) = Disproved (\ x -> case x of) - (%~) (SSucc _) SZero = Disproved (\ x -> case x of) + (%~) SZero (SSucc _) = Disproved (\ x -> case x of {}) + (%~) (SSucc _) SZero = Disproved (\ x -> case x of {}) (%~) (SSucc a) (SSucc b) = case ((%~) a) b of Proved Refl -> Proved Refl Disproved contra - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) instance SDecide Nat => Data.Type.Equality.TestEquality (SNat :: Nat -> GHC.Types.Type) where @@ -1118,19 +1125,19 @@ (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl) -> Proved Refl (,,,) (Disproved contra) _ _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ (Disproved contra) _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ _ (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ _ _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - (%~) (SA _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SA _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SA _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SA _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SA _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SB _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) + (%~) (SA _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SA _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SA _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SA _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SA _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SB _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of {}) (%~) (SB a a a a) (SB b b b b) = case ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b) @@ -1138,19 +1145,19 @@ (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl) -> Proved Refl (,,,) (Disproved contra) _ _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ (Disproved contra) _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ _ (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ _ _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - (%~) (SB _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SB _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SB _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SB _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SC _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SC _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) + (%~) (SB _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SB _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SB _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SB _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SC _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SC _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of {}) (%~) (SC a a a a) (SC b b b b) = case ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b) @@ -1158,19 +1165,19 @@ (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl) -> Proved Refl (,,,) (Disproved contra) _ _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ (Disproved contra) _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ _ (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ _ _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - (%~) (SC _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SC _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SC _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SD _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SD _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SD _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) + (%~) (SC _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SC _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SC _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SD _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SD _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SD _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of {}) (%~) (SD a a a a) (SD b b b b) = case ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b) @@ -1178,19 +1185,19 @@ (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl) -> Proved Refl (,,,) (Disproved contra) _ _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ (Disproved contra) _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ _ (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ _ _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - (%~) (SD _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SD _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SE _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SE _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SE _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SE _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) + (%~) (SD _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SD _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SE _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SE _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SE _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SE _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of {}) (%~) (SE a a a a) (SE b b b b) = case ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b) @@ -1198,19 +1205,19 @@ (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl) -> Proved Refl (,,,) (Disproved contra) _ _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ (Disproved contra) _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ _ (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ _ _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - (%~) (SE _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SF _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SF _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SF _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SF _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of) - (%~) (SF _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) + (%~) (SE _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SF _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SF _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SF _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SF _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of {}) + (%~) (SF _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of {}) (%~) (SF a a a a) (SF b b b b) = case ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b) @@ -1218,13 +1225,13 @@ (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl) -> Proved Refl (,,,) (Disproved contra) _ _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ (Disproved contra) _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ _ (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,,,) _ _ _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) instance (SDecide a, SDecide b, SDecide c, SDecide d) => Data.Type.Equality.TestEquality (SFoo :: Foo a b c d -> GHC.Types.Type) where @@ -1239,107 +1246,265 @@ sing = SZero instance SingI n => SingI (Succ (n :: Nat)) where sing = SSucc sing + instance SingI1 Succ where + liftSing = SSucc instance SingI (SuccSym0 :: (~>) Nat Nat) where sing = (singFun1 @SuccSym0) SSucc instance (SingI n, SingI n, SingI n, SingI n) => SingI (A (n :: a) (n :: b) (n :: c) (n :: d)) where sing = (((SA sing) sing) sing) sing + instance (SingI n, SingI n, SingI n) => + SingI1 (A (n :: a) (n :: b) (n :: c)) where + liftSing = ((SA sing) sing) sing + instance (SingI n, SingI n) => SingI2 (A (n :: a) (n :: b)) where + liftSing2 = (SA sing) sing instance SingI (ASym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where sing = (singFun4 @ASym0) SA instance SingI d => SingI (ASym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where sing = (singFun3 @(ASym1 (d :: a))) (SA (sing @d)) + instance SingI1 (ASym1 :: a + -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where + liftSing (s :: Sing (d :: a)) = (singFun3 @(ASym1 (d :: a))) (SA s) instance (SingI d, SingI d) => SingI (ASym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where sing = (singFun2 @(ASym2 (d :: a) (d :: b))) ((SA (sing @d)) (sing @d)) + instance SingI d => + SingI1 (ASym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where + liftSing (s :: Sing (d :: b)) + = (singFun2 @(ASym2 (d :: a) (d :: b))) ((SA (sing @d)) s) + instance SingI2 (ASym2 :: a + -> b -> (~>) c ((~>) d (Foo a b c d))) where + liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b)) + = (singFun2 @(ASym2 (d :: a) (d :: b))) ((SA s) s) instance (SingI d, SingI d, SingI d) => SingI (ASym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where sing = (singFun1 @(ASym3 (d :: a) (d :: b) (d :: c))) (((SA (sing @d)) (sing @d)) (sing @d)) + instance (SingI d, SingI d) => + SingI1 (ASym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where + liftSing (s :: Sing (d :: c)) + = (singFun1 @(ASym3 (d :: a) (d :: b) (d :: c))) + (((SA (sing @d)) (sing @d)) s) + instance SingI d => + SingI2 (ASym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where + liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c)) + = (singFun1 @(ASym3 (d :: a) (d :: b) (d :: c))) + (((SA (sing @d)) s) s) instance (SingI n, SingI n, SingI n, SingI n) => SingI (B (n :: a) (n :: b) (n :: c) (n :: d)) where sing = (((SB sing) sing) sing) sing + instance (SingI n, SingI n, SingI n) => + SingI1 (B (n :: a) (n :: b) (n :: c)) where + liftSing = ((SB sing) sing) sing + instance (SingI n, SingI n) => SingI2 (B (n :: a) (n :: b)) where + liftSing2 = (SB sing) sing instance SingI (BSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where sing = (singFun4 @BSym0) SB instance SingI d => SingI (BSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where sing = (singFun3 @(BSym1 (d :: a))) (SB (sing @d)) + instance SingI1 (BSym1 :: a + -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where + liftSing (s :: Sing (d :: a)) = (singFun3 @(BSym1 (d :: a))) (SB s) instance (SingI d, SingI d) => SingI (BSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where sing = (singFun2 @(BSym2 (d :: a) (d :: b))) ((SB (sing @d)) (sing @d)) + instance SingI d => + SingI1 (BSym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where + liftSing (s :: Sing (d :: b)) + = (singFun2 @(BSym2 (d :: a) (d :: b))) ((SB (sing @d)) s) + instance SingI2 (BSym2 :: a + -> b -> (~>) c ((~>) d (Foo a b c d))) where + liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b)) + = (singFun2 @(BSym2 (d :: a) (d :: b))) ((SB s) s) instance (SingI d, SingI d, SingI d) => SingI (BSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where sing = (singFun1 @(BSym3 (d :: a) (d :: b) (d :: c))) (((SB (sing @d)) (sing @d)) (sing @d)) + instance (SingI d, SingI d) => + SingI1 (BSym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where + liftSing (s :: Sing (d :: c)) + = (singFun1 @(BSym3 (d :: a) (d :: b) (d :: c))) + (((SB (sing @d)) (sing @d)) s) + instance SingI d => + SingI2 (BSym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where + liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c)) + = (singFun1 @(BSym3 (d :: a) (d :: b) (d :: c))) + (((SB (sing @d)) s) s) instance (SingI n, SingI n, SingI n, SingI n) => SingI (C (n :: a) (n :: b) (n :: c) (n :: d)) where sing = (((SC sing) sing) sing) sing + instance (SingI n, SingI n, SingI n) => + SingI1 (C (n :: a) (n :: b) (n :: c)) where + liftSing = ((SC sing) sing) sing + instance (SingI n, SingI n) => SingI2 (C (n :: a) (n :: b)) where + liftSing2 = (SC sing) sing instance SingI (CSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where sing = (singFun4 @CSym0) SC instance SingI d => SingI (CSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where sing = (singFun3 @(CSym1 (d :: a))) (SC (sing @d)) + instance SingI1 (CSym1 :: a + -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where + liftSing (s :: Sing (d :: a)) = (singFun3 @(CSym1 (d :: a))) (SC s) instance (SingI d, SingI d) => SingI (CSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where sing = (singFun2 @(CSym2 (d :: a) (d :: b))) ((SC (sing @d)) (sing @d)) + instance SingI d => + SingI1 (CSym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where + liftSing (s :: Sing (d :: b)) + = (singFun2 @(CSym2 (d :: a) (d :: b))) ((SC (sing @d)) s) + instance SingI2 (CSym2 :: a + -> b -> (~>) c ((~>) d (Foo a b c d))) where + liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b)) + = (singFun2 @(CSym2 (d :: a) (d :: b))) ((SC s) s) instance (SingI d, SingI d, SingI d) => SingI (CSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where sing = (singFun1 @(CSym3 (d :: a) (d :: b) (d :: c))) (((SC (sing @d)) (sing @d)) (sing @d)) + instance (SingI d, SingI d) => + SingI1 (CSym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where + liftSing (s :: Sing (d :: c)) + = (singFun1 @(CSym3 (d :: a) (d :: b) (d :: c))) + (((SC (sing @d)) (sing @d)) s) + instance SingI d => + SingI2 (CSym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where + liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c)) + = (singFun1 @(CSym3 (d :: a) (d :: b) (d :: c))) + (((SC (sing @d)) s) s) instance (SingI n, SingI n, SingI n, SingI n) => SingI (D (n :: a) (n :: b) (n :: c) (n :: d)) where sing = (((SD sing) sing) sing) sing + instance (SingI n, SingI n, SingI n) => + SingI1 (D (n :: a) (n :: b) (n :: c)) where + liftSing = ((SD sing) sing) sing + instance (SingI n, SingI n) => SingI2 (D (n :: a) (n :: b)) where + liftSing2 = (SD sing) sing instance SingI (DSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where sing = (singFun4 @DSym0) SD instance SingI d => SingI (DSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where sing = (singFun3 @(DSym1 (d :: a))) (SD (sing @d)) + instance SingI1 (DSym1 :: a + -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where + liftSing (s :: Sing (d :: a)) = (singFun3 @(DSym1 (d :: a))) (SD s) instance (SingI d, SingI d) => SingI (DSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where sing = (singFun2 @(DSym2 (d :: a) (d :: b))) ((SD (sing @d)) (sing @d)) + instance SingI d => + SingI1 (DSym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where + liftSing (s :: Sing (d :: b)) + = (singFun2 @(DSym2 (d :: a) (d :: b))) ((SD (sing @d)) s) + instance SingI2 (DSym2 :: a + -> b -> (~>) c ((~>) d (Foo a b c d))) where + liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b)) + = (singFun2 @(DSym2 (d :: a) (d :: b))) ((SD s) s) instance (SingI d, SingI d, SingI d) => SingI (DSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where sing = (singFun1 @(DSym3 (d :: a) (d :: b) (d :: c))) (((SD (sing @d)) (sing @d)) (sing @d)) + instance (SingI d, SingI d) => + SingI1 (DSym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where + liftSing (s :: Sing (d :: c)) + = (singFun1 @(DSym3 (d :: a) (d :: b) (d :: c))) + (((SD (sing @d)) (sing @d)) s) + instance SingI d => + SingI2 (DSym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where + liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c)) + = (singFun1 @(DSym3 (d :: a) (d :: b) (d :: c))) + (((SD (sing @d)) s) s) instance (SingI n, SingI n, SingI n, SingI n) => SingI (E (n :: a) (n :: b) (n :: c) (n :: d)) where sing = (((SE sing) sing) sing) sing + instance (SingI n, SingI n, SingI n) => + SingI1 (E (n :: a) (n :: b) (n :: c)) where + liftSing = ((SE sing) sing) sing + instance (SingI n, SingI n) => SingI2 (E (n :: a) (n :: b)) where + liftSing2 = (SE sing) sing instance SingI (ESym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where sing = (singFun4 @ESym0) SE instance SingI d => SingI (ESym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where sing = (singFun3 @(ESym1 (d :: a))) (SE (sing @d)) + instance SingI1 (ESym1 :: a + -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where + liftSing (s :: Sing (d :: a)) = (singFun3 @(ESym1 (d :: a))) (SE s) instance (SingI d, SingI d) => SingI (ESym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where sing = (singFun2 @(ESym2 (d :: a) (d :: b))) ((SE (sing @d)) (sing @d)) + instance SingI d => + SingI1 (ESym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where + liftSing (s :: Sing (d :: b)) + = (singFun2 @(ESym2 (d :: a) (d :: b))) ((SE (sing @d)) s) + instance SingI2 (ESym2 :: a + -> b -> (~>) c ((~>) d (Foo a b c d))) where + liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b)) + = (singFun2 @(ESym2 (d :: a) (d :: b))) ((SE s) s) instance (SingI d, SingI d, SingI d) => SingI (ESym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where sing = (singFun1 @(ESym3 (d :: a) (d :: b) (d :: c))) (((SE (sing @d)) (sing @d)) (sing @d)) + instance (SingI d, SingI d) => + SingI1 (ESym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where + liftSing (s :: Sing (d :: c)) + = (singFun1 @(ESym3 (d :: a) (d :: b) (d :: c))) + (((SE (sing @d)) (sing @d)) s) + instance SingI d => + SingI2 (ESym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where + liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c)) + = (singFun1 @(ESym3 (d :: a) (d :: b) (d :: c))) + (((SE (sing @d)) s) s) instance (SingI n, SingI n, SingI n, SingI n) => SingI (F (n :: a) (n :: b) (n :: c) (n :: d)) where sing = (((SF sing) sing) sing) sing + instance (SingI n, SingI n, SingI n) => + SingI1 (F (n :: a) (n :: b) (n :: c)) where + liftSing = ((SF sing) sing) sing + instance (SingI n, SingI n) => SingI2 (F (n :: a) (n :: b)) where + liftSing2 = (SF sing) sing instance SingI (FSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where sing = (singFun4 @FSym0) SF instance SingI d => SingI (FSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where sing = (singFun3 @(FSym1 (d :: a))) (SF (sing @d)) + instance SingI1 (FSym1 :: a + -> (~>) b ((~>) c ((~>) d (Foo a b c d)))) where + liftSing (s :: Sing (d :: a)) = (singFun3 @(FSym1 (d :: a))) (SF s) instance (SingI d, SingI d) => SingI (FSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where sing = (singFun2 @(FSym2 (d :: a) (d :: b))) ((SF (sing @d)) (sing @d)) + instance SingI d => + SingI1 (FSym2 (d :: a) :: b -> (~>) c ((~>) d (Foo a b c d))) where + liftSing (s :: Sing (d :: b)) + = (singFun2 @(FSym2 (d :: a) (d :: b))) ((SF (sing @d)) s) + instance SingI2 (FSym2 :: a + -> b -> (~>) c ((~>) d (Foo a b c d))) where + liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b)) + = (singFun2 @(FSym2 (d :: a) (d :: b))) ((SF s) s) instance (SingI d, SingI d, SingI d) => SingI (FSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where sing = (singFun1 @(FSym3 (d :: a) (d :: b) (d :: c))) (((SF (sing @d)) (sing @d)) (sing @d)) + instance (SingI d, SingI d) => + SingI1 (FSym3 (d :: a) (d :: b) :: c -> (~>) d (Foo a b c d)) where + liftSing (s :: Sing (d :: c)) + = (singFun1 @(FSym3 (d :: a) (d :: b) (d :: c))) + (((SF (sing @d)) (sing @d)) s) + instance SingI d => + SingI2 (FSym3 (d :: a) :: b -> c -> (~>) d (Foo a b c d)) where + liftSing2 (s :: Sing (d :: b)) (s :: Sing (d :: c)) + = (singFun1 @(FSym3 (d :: a) (d :: b) (d :: c))) + (((SF (sing @d)) s) s) diff --git a/tests/compile-and-dump/Singletons/PatternMatching.golden b/tests/compile-and-dump/Singletons/PatternMatching.golden --- a/tests/compile-and-dump/Singletons/PatternMatching.golden +++ b/tests/compile-and-dump/Singletons/PatternMatching.golden @@ -51,12 +51,12 @@ Complex = Apply (Apply PairSym0 (Apply (Apply PairSym0 (Apply JustSym0 ZeroSym0)) ZeroSym0)) FalseSym0 type family Pr where Pr = Apply (Apply PairSym0 (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:@#@$) ZeroSym0) NilSym0) - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural -> Pair a b -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: Pair a b) (a :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Pair a b) (a :: Symbol) :: Symbol where ShowsPrec_0123456789876543210 p_0123456789876543210 (Pair arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Pair ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) (Pair a b) ((~>) Symbol Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) (Pair a b) ((~>) Symbol Symbol)) + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Pair a b) ((~>) Symbol Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Pair a b) ((~>) Symbol Symbol)) where ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => ShowsPrec_0123456789876543210Sym0 a0123456789876543210 @@ -64,9 +64,9 @@ instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> (~>) (Pair a b) ((~>) Symbol Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) (Pair a b) ((~>) Symbol Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) (Pair a b) ((~>) Symbol Symbol) where ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -74,9 +74,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural -> Pair a b -> (~>) Symbol Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Pair a b) :: (~>) Symbol Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Pair a b) :: (~>) Symbol Symbol where ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -84,9 +84,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural -> Pair a b -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Pair a b) (a0123456789876543210 :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Pair a b) (a0123456789876543210 :: Symbol) :: Symbol where ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow (Pair a b) where type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a @@ -131,16 +131,17 @@ type Demote (Pair a b) = Pair (Demote a) (Demote b) fromSing (SPair b b) = (Pair (fromSing b)) (fromSing b) toSing (Pair (b :: Demote a) (b :: Demote b)) - = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SPair c) c) } + = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SPair c) c) instance (SShow a, SShow b) => SShow (Pair a b) where sShowsPrec :: - forall (t1 :: GHC.Types.Nat) (t2 :: Pair a b) (t3 :: Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (Pair a b) ((~>) Symbol Symbol)) - -> GHC.Types.Type) t1) t2) t3) + forall (t1 :: GHC.Num.Natural.Natural) + (t2 :: Pair a b) + (t3 :: Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) (Pair a b) ((~>) Symbol Symbol)) + -> GHC.Types.Type) t1) t2) t3) sShowsPrec (sP_0123456789876543210 :: Sing p_0123456789876543210) (SPair (sArg_0123456789876543210 :: Sing arg_0123456789876543210) @@ -175,11 +176,18 @@ Show (SPair (z :: Pair a b)) instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where sing = (SPair sing) sing + instance SingI n => SingI1 (Pair (n :: a)) where + liftSing = SPair sing + instance SingI2 Pair where + liftSing2 = SPair instance SingI (PairSym0 :: (~>) a ((~>) b (Pair a b))) where sing = (singFun2 @PairSym0) SPair instance SingI d => SingI (PairSym1 (d :: a) :: (~>) b (Pair a b)) where sing = (singFun1 @(PairSym1 (d :: a))) (SPair (sing @d)) + instance SingI1 (PairSym1 :: a -> (~>) b (Pair a b)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(PairSym1 (d :: a))) (SPair s) Singletons/PatternMatching.hs:(0,0)-(0,0): Splicing declarations singletons [d| Pair sz lz = pr @@ -191,9 +199,9 @@ foo1 :: (a, b) -> a foo1 (x, y) = (\ _ -> x) y foo2 :: (# a, b #) -> a - foo2 t@(# x, y #) = case t of { (# a, b #) -> (\ _ -> a) b } + foo2 t@(# x, y #) = case t of (# a, b #) -> (\ _ -> a) b silly :: a -> () - silly x = case x of { _ -> () } |] + silly x = case x of _ -> () |] ======> Pair sz lz = pr Pair (Pair jz zz) fls = complex @@ -204,9 +212,9 @@ foo1 :: (a, b) -> a foo1 (x, y) = (\ _ -> x) y foo2 :: (# a, b #) -> a - foo2 t@(# x, y #) = case t of { (# a, b #) -> (\ _ -> a) b } + foo2 t@(# x, y #) = case t of (# a, b #) -> (\ _ -> a) b silly :: a -> () - silly x = case x of { _ -> () } + silly x = case x of _ -> () type family Case_0123456789876543210 x t where Case_0123456789876543210 x _ = Tuple0Sym0 data Let0123456789876543210TSym0 x0123456789876543210 @@ -464,7 +472,7 @@ sX_0123456789876543210 :: Sing @_ X_0123456789876543210Sym0 sSilly (sX :: Sing x) = (id @(Sing (Case_0123456789876543210 x x :: ()))) - (case sX of { _ -> STuple0 }) + (case sX of _ -> STuple0) sFoo2 (STuple2 (sX :: Sing x) (sY :: Sing y)) = let sT :: Sing @_ (Let0123456789876543210TSym2 x y) @@ -473,93 +481,93 @@ in (id @(Sing (Case_0123456789876543210 x y (Let0123456789876543210TSym2 x y) :: a))) - (case sT of { + (case sT of STuple2 (sA :: Sing a) (sB :: Sing b) -> (applySing ((singFun1 @(Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) b) x) y)) (\ sArg_0123456789876543210 - -> case sArg_0123456789876543210 of { + -> case sArg_0123456789876543210 of (_ :: Sing arg_0123456789876543210) -> (id @(Sing (Case_0123456789876543210 arg_0123456789876543210 a b x y arg_0123456789876543210))) - (case sArg_0123456789876543210 of { _ -> sA }) }))) - sB }) + (case sArg_0123456789876543210 of _ -> sA)))) + sB) sFoo1 (STuple2 (sX :: Sing x) (sY :: Sing y)) = (applySing ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 x) y)) (\ sArg_0123456789876543210 - -> case sArg_0123456789876543210 of { + -> case sArg_0123456789876543210 of (_ :: Sing arg_0123456789876543210) -> (id @(Sing (Case_0123456789876543210 arg_0123456789876543210 x y arg_0123456789876543210))) - (case sArg_0123456789876543210 of { _ -> sX }) }))) + (case sArg_0123456789876543210 of _ -> sX)))) sY sBlimy = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of SCons _ (SCons _ (SCons (SSucc (sY_0123456789876543210 :: Sing y_0123456789876543210)) SNil)) - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sLsz = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Nat))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of SCons _ (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210) (SCons (SSucc _) SNil)) - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sX_0123456789876543210 = sAList sTt = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of STuple3 _ _ (sY_0123456789876543210 :: Sing y_0123456789876543210) - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sTjz = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of STuple3 _ (sY_0123456789876543210 :: Sing y_0123456789876543210) _ - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sTf = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of STuple3 (sY_0123456789876543210 :: Sing y_0123456789876543210) _ _ - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sX_0123456789876543210 = sTuple sFls = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of SPair (SPair _ _) (sY_0123456789876543210 :: Sing y_0123456789876543210) - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sZz = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of SPair (SPair _ (sY_0123456789876543210 :: Sing y_0123456789876543210)) _ - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sJz = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of SPair (SPair (sY_0123456789876543210 :: Sing y_0123456789876543210) _) _ - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sX_0123456789876543210 = sComplex sLz = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of SPair _ (sY_0123456789876543210 :: Sing y_0123456789876543210) - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sSz = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of SPair (sY_0123456789876543210 :: Sing y_0123456789876543210) _ - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sX_0123456789876543210 = sPr instance SingI (SillySym0 :: (~>) a ()) where sing = (singFun1 @SillySym0) sSilly diff --git a/tests/compile-and-dump/Singletons/PolyKinds.golden b/tests/compile-and-dump/Singletons/PolyKinds.golden --- a/tests/compile-and-dump/Singletons/PolyKinds.golden +++ b/tests/compile-and-dump/Singletons/PolyKinds.golden @@ -17,11 +17,11 @@ type family FffSym1 (a0123456789876543210 :: Proxy (a :: k)) :: () where FffSym1 a0123456789876543210 = Fff a0123456789876543210 class PCls (a :: k) where - type Fff (arg :: Proxy (a :: k)) :: () + type family Fff (arg :: Proxy (a :: k)) :: () class SCls (a :: k) where sFff :: - forall (t :: Proxy (a :: k)). - Sing t -> Sing (Apply FffSym0 t :: ()) + forall (t :: Proxy (a :: k)). Sing t + -> Sing (Apply FffSym0 t :: ()) instance SCls a => SingI (FffSym0 :: (~>) (Proxy (a :: k)) ()) where sing = (singFun1 @FffSym0) sFff diff --git a/tests/compile-and-dump/Singletons/PolyKindsApp.golden b/tests/compile-and-dump/Singletons/PolyKindsApp.golden --- a/tests/compile-and-dump/Singletons/PolyKindsApp.golden +++ b/tests/compile-and-dump/Singletons/PolyKindsApp.golden @@ -5,12 +5,12 @@ ======> class Cls (a :: k -> Type) where fff :: (a :: k -> Type) (b :: k) - type FffSym0 :: forall k (a :: k -> Type) (b :: k). - (a :: k -> Type) (b :: k) + type FffSym0 :: forall k (a :: k -> Type) (b :: k). (a :: k + -> Type) (b :: k) type family FffSym0 :: (a :: k -> Type) (b :: k) where FffSym0 = Fff class PCls (a :: k -> Type) where - type Fff :: (a :: k -> Type) (b :: k) + type family Fff :: (a :: k -> Type) (b :: k) class SCls (a :: k -> Type) where sFff :: forall (b :: k). Sing (FffSym0 :: (a :: k -> Type) (b :: k)) diff --git a/tests/compile-and-dump/Singletons/Records.golden b/tests/compile-and-dump/Singletons/Records.golden --- a/tests/compile-and-dump/Singletons/Records.golden +++ b/tests/compile-and-dump/Singletons/Records.golden @@ -51,8 +51,8 @@ type family Field1 (a :: Record a) :: a where Field1 (MkRecord field _) = field sField2 :: - forall a (t :: Record a). - Sing t -> Sing (Apply Field2Sym0 t :: Bool) + forall a (t :: Record a). Sing t + -> Sing (Apply Field2Sym0 t :: Bool) sField1 :: forall a (t :: Record a). Sing t -> Sing (Apply Field1Sym0 t :: a) sField2 (SMkRecord _ (sField :: Sing field)) = sField @@ -72,13 +72,20 @@ toSing (MkRecord (b :: Demote a) (b :: Demote Bool)) = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing Bool) - of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkRecord c) c) } + of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkRecord c) c) instance (SingI n, SingI n) => SingI (MkRecord (n :: a) (n :: Bool)) where sing = (SMkRecord sing) sing + instance SingI n => SingI1 (MkRecord (n :: a)) where + liftSing = SMkRecord sing + instance SingI2 MkRecord where + liftSing2 = SMkRecord instance SingI (MkRecordSym0 :: (~>) a ((~>) Bool (Record a))) where sing = (singFun2 @MkRecordSym0) SMkRecord instance SingI d => SingI (MkRecordSym1 (d :: a) :: (~>) Bool (Record a)) where sing = (singFun1 @(MkRecordSym1 (d :: a))) (SMkRecord (sing @d)) + instance SingI1 (MkRecordSym1 :: a -> (~>) Bool (Record a)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(MkRecordSym1 (d :: a))) (SMkRecord s) diff --git a/tests/compile-and-dump/Singletons/ReturnFunc.golden b/tests/compile-and-dump/Singletons/ReturnFunc.golden --- a/tests/compile-and-dump/Singletons/ReturnFunc.golden +++ b/tests/compile-and-dump/Singletons/ReturnFunc.golden @@ -72,12 +72,12 @@ type family ReturnFunc (a :: Nat) (a :: Nat) :: Nat where ReturnFunc _ a_0123456789876543210 = Apply SuccSym0 a_0123456789876543210 sIdFoo :: - forall c a (t :: c) (t :: a). - Sing t -> Sing t -> Sing (Apply (Apply IdFooSym0 t) t :: a) + forall c a (t :: c) (t :: a). Sing t + -> Sing t -> Sing (Apply (Apply IdFooSym0 t) t :: a) sId :: forall a (t :: a). Sing t -> Sing (Apply IdSym0 t :: a) sReturnFunc :: - forall (t :: Nat) (t :: Nat). - Sing t -> Sing t -> Sing (Apply (Apply ReturnFuncSym0 t) t :: Nat) + forall (t :: Nat) (t :: Nat). Sing t + -> Sing t -> Sing (Apply (Apply ReturnFuncSym0 t) t :: Nat) sIdFoo _ (sA_0123456789876543210 :: Sing a_0123456789876543210) = (applySing ((singFun1 @IdSym0) sId)) sA_0123456789876543210 sId (sX :: Sing x) = sX @@ -89,6 +89,9 @@ sing = (singFun2 @IdFooSym0) sIdFoo instance SingI d => SingI (IdFooSym1 (d :: c) :: (~>) a a) where sing = (singFun1 @(IdFooSym1 (d :: c))) (sIdFoo (sing @d)) + instance SingI1 (IdFooSym1 :: c -> (~>) a a) where + liftSing (s :: Sing (d :: c)) + = (singFun1 @(IdFooSym1 (d :: c))) (sIdFoo s) instance SingI (IdSym0 :: (~>) a a) where sing = (singFun1 @IdSym0) sId instance SingI (ReturnFuncSym0 :: (~>) Nat ((~>) Nat Nat)) where @@ -97,3 +100,6 @@ SingI (ReturnFuncSym1 (d :: Nat) :: (~>) Nat Nat) where sing = (singFun1 @(ReturnFuncSym1 (d :: Nat))) (sReturnFunc (sing @d)) + instance SingI1 (ReturnFuncSym1 :: Nat -> (~>) Nat Nat) where + liftSing (s :: Sing (d :: Nat)) + = (singFun1 @(ReturnFuncSym1 (d :: Nat))) (sReturnFunc s) diff --git a/tests/compile-and-dump/Singletons/Sections.golden b/tests/compile-and-dump/Singletons/Sections.golden --- a/tests/compile-and-dump/Singletons/Sections.golden +++ b/tests/compile-and-dump/Singletons/Sections.golden @@ -76,8 +76,8 @@ sFoo2 :: Sing (Foo2Sym0 :: [Nat]) sFoo1 :: Sing (Foo1Sym0 :: [Nat]) (%+) :: - forall (t :: Nat) (t :: Nat). - Sing t -> Sing t -> Sing (Apply (Apply (+@#@$) t) t :: Nat) + forall (t :: Nat) (t :: Nat). Sing t + -> Sing t -> Sing (Apply (Apply (+@#@$) t) t :: Nat) sFoo3 = (applySing ((applySing @@ -100,11 +100,11 @@ ((applySing ((singFun2 @MapSym0) sMap)) ((singFun1 @Lambda_0123456789876543210Sym0) (\ sLhs_0123456789876543210 - -> case sLhs_0123456789876543210 of { + -> case sLhs_0123456789876543210 of (_ :: Sing lhs_0123456789876543210) -> (applySing ((applySing ((singFun2 @(+@#@$)) (%+))) sLhs_0123456789876543210)) - ((applySing ((singFun1 @SuccSym0) SSucc)) SZero) })))) + ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))) ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero)) ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) @@ -129,3 +129,6 @@ instance SingI d => SingI ((+@#@$$) (d :: Nat) :: (~>) Nat Nat) where sing = (singFun1 @((+@#@$$) (d :: Nat))) ((%+) (sing @d)) + instance SingI1 ((+@#@$$) :: Nat -> (~>) Nat Nat) where + liftSing (s :: Sing (d :: Nat)) + = (singFun1 @((+@#@$$) (d :: Nat))) ((%+) s) diff --git a/tests/compile-and-dump/Singletons/ShowDeriving.golden b/tests/compile-and-dump/Singletons/ShowDeriving.golden --- a/tests/compile-and-dump/Singletons/ShowDeriving.golden +++ b/tests/compile-and-dump/Singletons/ShowDeriving.golden @@ -9,7 +9,7 @@ = MkFoo2a a a | a `MkFoo2b` a | (:*:) a a | a :&: a deriving Show data Foo3 - = MkFoo3 {getFoo3a :: Bool, *** :: Bool} + = MkFoo3 {getFoo3a :: Bool, (***) :: Bool} deriving Show |] ======> data Foo1 @@ -22,7 +22,7 @@ = MkFoo2a a a | a `MkFoo2b` a | (:*:) a a | a :&: a deriving Show data Foo3 - = MkFoo3 {getFoo3a :: Bool, *** :: Bool} + = MkFoo3 {getFoo3a :: Bool, (***) :: Bool} deriving Show type MkFoo1Sym0 :: Foo1 type family MkFoo1Sym0 :: Foo1 where @@ -159,12 +159,12 @@ type GetFoo3a :: Foo3 -> Bool type family GetFoo3a (a :: Foo3) :: Bool where GetFoo3a (MkFoo3 field _) = field - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural -> Foo1 -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: Foo1) (a :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Foo1) (a :: Symbol) :: Symbol where ShowsPrec_0123456789876543210 _ MkFoo1 a_0123456789876543210 = Apply (Apply ShowStringSym0 "MkFoo1") a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Foo1 ((~>) Symbol Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Foo1 ((~>) Symbol Symbol)) + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo1 ((~>) Symbol Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo1 ((~>) Symbol Symbol)) where ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => ShowsPrec_0123456789876543210Sym0 a0123456789876543210 @@ -172,9 +172,9 @@ instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> (~>) Foo1 ((~>) Symbol Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) Foo1 ((~>) Symbol Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) Foo1 ((~>) Symbol Symbol) where ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -182,9 +182,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural -> Foo1 -> (~>) Symbol Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo1) :: (~>) Symbol Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo1) :: (~>) Symbol Symbol where ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -192,21 +192,21 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural -> Foo1 -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo1) (a0123456789876543210 :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo1) (a0123456789876543210 :: Symbol) :: Symbol where ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow Foo1 where type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural -> Foo2 a -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: Foo2 a) (a :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Foo2 a) (a :: Symbol) :: Symbol where ShowsPrec_0123456789876543210 p_0123456789876543210 (MkFoo2a arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "MkFoo2a ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210 ShowsPrec_0123456789876543210 p_0123456789876543210 (MkFoo2b argL_0123456789876543210 argR_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 5))) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argL_0123456789876543210)) (Apply (Apply (.@#@$) (Apply ShowStringSym0 " `MkFoo2b` ")) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argR_0123456789876543210)))) a_0123456789876543210 ShowsPrec_0123456789876543210 p_0123456789876543210 ((:*:) arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "(:*:) ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210 ShowsPrec_0123456789876543210 p_0123456789876543210 ((:&:) argL_0123456789876543210 argR_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 5))) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argL_0123456789876543210)) (Apply (Apply (.@#@$) (Apply ShowStringSym0 " :&: ")) (Apply (Apply ShowsPrecSym0 (FromInteger 6)) argR_0123456789876543210)))) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) (Foo2 a) ((~>) Symbol Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) (Foo2 a) ((~>) Symbol Symbol)) + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Foo2 a) ((~>) Symbol Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Foo2 a) ((~>) Symbol Symbol)) where ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => ShowsPrec_0123456789876543210Sym0 a0123456789876543210 @@ -214,9 +214,9 @@ instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> (~>) (Foo2 a) ((~>) Symbol Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) (Foo2 a) ((~>) Symbol Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) (Foo2 a) ((~>) Symbol Symbol) where ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -224,9 +224,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural -> Foo2 a -> (~>) Symbol Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo2 a) :: (~>) Symbol Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo2 a) :: (~>) Symbol Symbol where ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -234,18 +234,18 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural -> Foo2 a -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo2 a) (a0123456789876543210 :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo2 a) (a0123456789876543210 :: Symbol) :: Symbol where ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow (Foo2 a) where type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural -> Foo3 -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: Foo3) (a :: Symbol) :: Symbol where - ShowsPrec_0123456789876543210 p_0123456789876543210 (MkFoo3 arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "MkFoo3 ")) (Apply (Apply (.@#@$) (Apply ShowCharSym0 "{")) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "getFoo3a = ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 0)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowCommaSpaceSym0) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "(***) = ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 0)) arg_0123456789876543210)) (Apply ShowCharSym0 "}"))))))))) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Foo3 ((~>) Symbol Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Foo3 ((~>) Symbol Symbol)) + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Foo3) (a :: Symbol) :: Symbol where + ShowsPrec_0123456789876543210 p_0123456789876543210 (MkFoo3 arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "MkFoo3 ")) (Apply (Apply (.@#@$) (Apply ShowCharSym0 '{')) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "getFoo3a = ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 0)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowCommaSpaceSym0) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "(***) = ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 0)) arg_0123456789876543210)) (Apply ShowCharSym0 '}'))))))))) a_0123456789876543210 + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo3 ((~>) Symbol Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Foo3 ((~>) Symbol Symbol)) where ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => ShowsPrec_0123456789876543210Sym0 a0123456789876543210 @@ -253,9 +253,9 @@ instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> (~>) Foo3 ((~>) Symbol Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) Foo3 ((~>) Symbol Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) Foo3 ((~>) Symbol Symbol) where ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -263,9 +263,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural -> Foo3 -> (~>) Symbol Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo3) :: (~>) Symbol Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo3) :: (~>) Symbol Symbol where ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -273,9 +273,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural -> Foo3 -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo3) (a0123456789876543210 :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Foo3) (a0123456789876543210 :: Symbol) :: Symbol where ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow Foo3 where type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a @@ -317,17 +317,17 @@ fromSing ((:%*:) b b) = ((:*:) (fromSing b)) (fromSing b) fromSing ((:%&:) b b) = ((:&:) (fromSing b)) (fromSing b) toSing (MkFoo2a (b :: Demote a) (b :: Demote a)) - = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkFoo2a c) c) } + = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkFoo2a c) c) toSing (MkFoo2b (b :: Demote a) (b :: Demote a)) - = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkFoo2b c) c) } + = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkFoo2b c) c) toSing ((:*:) (b :: Demote a) (b :: Demote a)) - = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of { - (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%*:) c) c) } + = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of + (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%*:) c) c) toSing ((:&:) (b :: Demote a) (b :: Demote a)) - = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of { - (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%&:) c) c) } + = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of + (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%&:) c) c) data SFoo3 :: Foo3 -> GHC.Types.Type where SMkFoo3 :: forall (n :: Bool) (n :: Bool). @@ -339,16 +339,17 @@ toSing (MkFoo3 (b :: Demote Bool) (b :: Demote Bool)) = case ((,) (toSing b :: SomeSing Bool)) (toSing b :: SomeSing Bool) - of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkFoo3 c) c) } + of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkFoo3 c) c) instance SShow Foo1 where sShowsPrec :: - forall (t1 :: GHC.Types.Nat) (t2 :: Foo1) (t3 :: Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) Foo1 ((~>) Symbol Symbol)) - -> GHC.Types.Type) t1) t2) t3) + forall (t1 :: GHC.Num.Natural.Natural) + (t2 :: Foo1) + (t3 :: Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) Foo1 ((~>) Symbol Symbol)) + -> GHC.Types.Type) t1) t2) t3) sShowsPrec _ SMkFoo1 @@ -359,12 +360,13 @@ sA_0123456789876543210 instance SShow a => SShow (Foo2 a) where sShowsPrec :: - forall (t1 :: GHC.Types.Nat) (t2 :: Foo2 a) (t3 :: Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (Foo2 a) ((~>) Symbol Symbol)) - -> GHC.Types.Type) t1) t2) t3) + forall (t1 :: GHC.Num.Natural.Natural) + (t2 :: Foo2 a) + (t3 :: Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) (Foo2 a) ((~>) Symbol Symbol)) + -> GHC.Types.Type) t1) t2) t3) sShowsPrec (sP_0123456789876543210 :: Sing p_0123456789876543210) (SMkFoo2a (sArg_0123456789876543210 :: Sing arg_0123456789876543210) @@ -477,12 +479,13 @@ sA_0123456789876543210 instance SShow Bool => SShow Foo3 where sShowsPrec :: - forall (t1 :: GHC.Types.Nat) (t2 :: Foo3) (t3 :: Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) Foo3 ((~>) Symbol Symbol)) - -> GHC.Types.Type) t1) t2) t3) + forall (t1 :: GHC.Num.Natural.Natural) + (t2 :: Foo3) + (t3 :: Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) Foo3 ((~>) Symbol Symbol)) + -> GHC.Types.Type) t1) t2) t3) sShowsPrec (sP_0123456789876543210 :: Sing p_0123456789876543210) (SMkFoo3 (sArg_0123456789876543210 :: Sing arg_0123456789876543210) @@ -501,7 +504,7 @@ ((applySing ((applySing ((singFun3 @(.@#@$)) (%.))) ((applySing ((singFun2 @ShowCharSym0) sShowChar)) - (sing :: Sing "{")))) + (sing :: Sing '{')))) ((applySing ((applySing ((singFun3 @(.@#@$)) (%.))) ((applySing ((singFun2 @ShowStringSym0) sShowString)) @@ -526,7 +529,7 @@ (sFromInteger (sing :: Sing 0)))) sArg_0123456789876543210))) ((applySing ((singFun2 @ShowCharSym0) sShowChar)) - (sing :: Sing "}"))))))))))) + (sing :: Sing '}'))))))))))) sA_0123456789876543210 deriving instance Show (SFoo1 (z :: Foo1)) deriving instance Data.Singletons.ShowSing.ShowSing a => @@ -538,40 +541,75 @@ instance (SingI n, SingI n) => SingI (MkFoo2a (n :: a) (n :: a)) where sing = (SMkFoo2a sing) sing + instance SingI n => SingI1 (MkFoo2a (n :: a)) where + liftSing = SMkFoo2a sing + instance SingI2 MkFoo2a where + liftSing2 = SMkFoo2a instance SingI (MkFoo2aSym0 :: (~>) a ((~>) a (Foo2 a))) where sing = (singFun2 @MkFoo2aSym0) SMkFoo2a instance SingI d => SingI (MkFoo2aSym1 (d :: a) :: (~>) a (Foo2 a)) where sing = (singFun1 @(MkFoo2aSym1 (d :: a))) (SMkFoo2a (sing @d)) + instance SingI1 (MkFoo2aSym1 :: a -> (~>) a (Foo2 a)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(MkFoo2aSym1 (d :: a))) (SMkFoo2a s) instance (SingI n, SingI n) => SingI (MkFoo2b (n :: a) (n :: a)) where sing = (SMkFoo2b sing) sing + instance SingI n => SingI1 (MkFoo2b (n :: a)) where + liftSing = SMkFoo2b sing + instance SingI2 MkFoo2b where + liftSing2 = SMkFoo2b instance SingI (MkFoo2bSym0 :: (~>) a ((~>) a (Foo2 a))) where sing = (singFun2 @MkFoo2bSym0) SMkFoo2b instance SingI d => SingI (MkFoo2bSym1 (d :: a) :: (~>) a (Foo2 a)) where sing = (singFun1 @(MkFoo2bSym1 (d :: a))) (SMkFoo2b (sing @d)) + instance SingI1 (MkFoo2bSym1 :: a -> (~>) a (Foo2 a)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(MkFoo2bSym1 (d :: a))) (SMkFoo2b s) instance (SingI n, SingI n) => SingI ((:*:) (n :: a) (n :: a)) where sing = ((:%*:) sing) sing + instance SingI n => SingI1 ((:*:) (n :: a)) where + liftSing = (:%*:) sing + instance SingI2 (:*:) where + liftSing2 = (:%*:) instance SingI ((:*:@#@$) :: (~>) a ((~>) a (Foo2 a))) where sing = (singFun2 @(:*:@#@$)) (:%*:) instance SingI d => SingI ((:*:@#@$$) (d :: a) :: (~>) a (Foo2 a)) where sing = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) (sing @d)) + instance SingI1 ((:*:@#@$$) :: a -> (~>) a (Foo2 a)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) s) instance (SingI n, SingI n) => SingI ((:&:) (n :: a) (n :: a)) where sing = ((:%&:) sing) sing + instance SingI n => SingI1 ((:&:) (n :: a)) where + liftSing = (:%&:) sing + instance SingI2 (:&:) where + liftSing2 = (:%&:) instance SingI ((:&:@#@$) :: (~>) a ((~>) a (Foo2 a))) where sing = (singFun2 @(:&:@#@$)) (:%&:) instance SingI d => SingI ((:&:@#@$$) (d :: a) :: (~>) a (Foo2 a)) where sing = (singFun1 @((:&:@#@$$) (d :: a))) ((:%&:) (sing @d)) + instance SingI1 ((:&:@#@$$) :: a -> (~>) a (Foo2 a)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @((:&:@#@$$) (d :: a))) ((:%&:) s) instance (SingI n, SingI n) => SingI (MkFoo3 (n :: Bool) (n :: Bool)) where sing = (SMkFoo3 sing) sing + instance SingI n => SingI1 (MkFoo3 (n :: Bool)) where + liftSing = SMkFoo3 sing + instance SingI2 MkFoo3 where + liftSing2 = SMkFoo3 instance SingI (MkFoo3Sym0 :: (~>) Bool ((~>) Bool Foo3)) where sing = (singFun2 @MkFoo3Sym0) SMkFoo3 instance SingI d => SingI (MkFoo3Sym1 (d :: Bool) :: (~>) Bool Foo3) where sing = (singFun1 @(MkFoo3Sym1 (d :: Bool))) (SMkFoo3 (sing @d)) + instance SingI1 (MkFoo3Sym1 :: Bool -> (~>) Bool Foo3) where + liftSing (s :: Sing (d :: Bool)) + = (singFun1 @(MkFoo3Sym1 (d :: Bool))) (SMkFoo3 s) diff --git a/tests/compile-and-dump/Singletons/StandaloneDeriving.golden b/tests/compile-and-dump/Singletons/StandaloneDeriving.golden --- a/tests/compile-and-dump/Singletons/StandaloneDeriving.golden +++ b/tests/compile-and-dump/Singletons/StandaloneDeriving.golden @@ -108,12 +108,12 @@ Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210 instance POrd (T a ()) where type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural -> T a () -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: T a ()) (a :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: T a ()) (a :: Symbol) :: Symbol where ShowsPrec_0123456789876543210 p_0123456789876543210 ((:*:) argL_0123456789876543210 argR_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 6))) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 7)) argL_0123456789876543210)) (Apply (Apply (.@#@$) (Apply ShowStringSym0 " :*: ")) (Apply (Apply ShowsPrecSym0 (FromInteger 7)) argR_0123456789876543210)))) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) (T a ()) ((~>) Symbol Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) (T a ()) ((~>) Symbol Symbol)) + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (T a ()) ((~>) Symbol Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (T a ()) ((~>) Symbol Symbol)) where ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => ShowsPrec_0123456789876543210Sym0 a0123456789876543210 @@ -121,9 +121,9 @@ instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> (~>) (T a ()) ((~>) Symbol Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) (T a ()) ((~>) Symbol Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) (T a ()) ((~>) Symbol Symbol) where ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -131,9 +131,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural -> T a () -> (~>) Symbol Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: T a ()) :: (~>) Symbol Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: T a ()) :: (~>) Symbol Symbol where ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -141,9 +141,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural -> T a () -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: T a ()) (a0123456789876543210 :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: T a ()) (a0123456789876543210 :: Symbol) :: Symbol where ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow (T a ()) where type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a @@ -205,13 +205,13 @@ Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210 instance POrd S where type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural -> S -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: S) (a :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: S) (a :: Symbol) :: Symbol where ShowsPrec_0123456789876543210 _ S1 a_0123456789876543210 = Apply (Apply ShowStringSym0 "S1") a_0123456789876543210 ShowsPrec_0123456789876543210 _ S2 a_0123456789876543210 = Apply (Apply ShowStringSym0 "S2") a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) S ((~>) Symbol Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) S ((~>) Symbol Symbol)) + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) S ((~>) Symbol Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) S ((~>) Symbol Symbol)) where ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => ShowsPrec_0123456789876543210Sym0 a0123456789876543210 @@ -219,9 +219,9 @@ instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> (~>) S ((~>) Symbol Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) S ((~>) Symbol Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) S ((~>) Symbol Symbol) where ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -229,9 +229,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural -> S -> (~>) Symbol Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: S) :: (~>) Symbol Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: S) :: (~>) Symbol Symbol where ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -239,9 +239,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural -> S -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: S) (a0123456789876543210 :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: S) (a0123456789876543210 :: Symbol) :: Symbol where ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow S where type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a @@ -266,11 +266,11 @@ type family Case_0123456789876543210 n t where Case_0123456789876543210 n 'True = S1Sym0 Case_0123456789876543210 n 'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 1)) - type ToEnum_0123456789876543210 :: GHC.Types.Nat -> S - type family ToEnum_0123456789876543210 (a :: GHC.Types.Nat) :: S where + type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural -> S + type family ToEnum_0123456789876543210 (a :: GHC.Num.Natural.Natural) :: S where ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0)) - type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat S - data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat S + type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural S + data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural S where ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) => ToEnum_0123456789876543210Sym0 a0123456789876543210 @@ -278,15 +278,15 @@ instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ()) - type ToEnum_0123456789876543210Sym1 :: GHC.Types.Nat -> S - type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: S where + type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> S + type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: S where ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 - type FromEnum_0123456789876543210 :: S -> GHC.Types.Nat - type family FromEnum_0123456789876543210 (a :: S) :: GHC.Types.Nat where + type FromEnum_0123456789876543210 :: S -> GHC.Num.Natural.Natural + type family FromEnum_0123456789876543210 (a :: S) :: GHC.Num.Natural.Natural where FromEnum_0123456789876543210 S1 = FromInteger 0 FromEnum_0123456789876543210 S2 = FromInteger 1 - type FromEnum_0123456789876543210Sym0 :: (~>) S GHC.Types.Nat - data FromEnum_0123456789876543210Sym0 :: (~>) S GHC.Types.Nat + type FromEnum_0123456789876543210Sym0 :: (~>) S GHC.Num.Natural.Natural + data FromEnum_0123456789876543210Sym0 :: (~>) S GHC.Num.Natural.Natural where FromEnum_0123456789876543210Sym0KindInference :: SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) => FromEnum_0123456789876543210Sym0 a0123456789876543210 @@ -294,8 +294,9 @@ instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ()) - type FromEnum_0123456789876543210Sym1 :: S -> GHC.Types.Nat - type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: S) :: GHC.Types.Nat where + type FromEnum_0123456789876543210Sym1 :: S + -> GHC.Num.Natural.Natural + type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: S) :: GHC.Num.Natural.Natural where FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210 instance PEnum S where type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a @@ -310,8 +311,8 @@ type Demote (T a b) = T (Demote a) (Demote b) fromSing ((:%*:) b b) = ((:*:) (fromSing b)) (fromSing b) toSing ((:*:) (b :: Demote a) (b :: Demote b)) - = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of { - (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%*:) c) c) } + = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of + (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%*:) c) c) data SS :: S -> GHC.Types.Type where SS1 :: SS (S1 :: S) @@ -325,11 +326,10 @@ toSing S2 = SomeSing SS2 instance SEq a => SEq (T a ()) where (%==) :: - forall (t1 :: T a ()) (t2 :: T a ()). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun (T a ()) ((~>) (T a ()) Bool) - -> GHC.Types.Type) t1) t2) + forall (t1 :: T a ()) (t2 :: T a ()). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun (T a ()) ((~>) (T a ()) Bool) + -> GHC.Types.Type) t1) t2) (%==) ((:%*:) (sA_0123456789876543210 :: Sing a_0123456789876543210) (sA_0123456789876543210 :: Sing a_0123456789876543210)) @@ -345,11 +345,10 @@ sB_0123456789876543210) instance SOrd a => SOrd (T a ()) where sCompare :: - forall (t1 :: T a ()) (t2 :: T a ()). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (CompareSym0 :: TyFun (T a ()) ((~>) (T a ()) Ordering) - -> GHC.Types.Type) t1) t2) + forall (t1 :: T a ()) (t2 :: T a ()). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (CompareSym0 :: TyFun (T a ()) ((~>) (T a ()) Ordering) + -> GHC.Types.Type) t1) t2) sCompare ((:%*:) (sA_0123456789876543210 :: Sing a_0123456789876543210) (sA_0123456789876543210 :: Sing a_0123456789876543210)) @@ -375,12 +374,13 @@ SNil)) instance SShow a => SShow (T a ()) where sShowsPrec :: - forall (t1 :: GHC.Types.Nat) (t2 :: T a ()) (t3 :: Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (T a ()) ((~>) Symbol Symbol)) - -> GHC.Types.Type) t1) t2) t3) + forall (t1 :: GHC.Num.Natural.Natural) + (t2 :: T a ()) + (t3 :: Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) (T a ()) ((~>) Symbol Symbol)) + -> GHC.Types.Type) t1) t2) t3) sShowsPrec (sP_0123456789876543210 :: Sing p_0123456789876543210) ((:%*:) (sArgL_0123456789876543210 :: Sing argL_0123456789876543210) @@ -409,22 +409,20 @@ sA_0123456789876543210 instance SEq S where (%==) :: - forall (t1 :: S) (t2 :: S). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun S ((~>) S Bool) - -> GHC.Types.Type) t1) t2) + forall (t1 :: S) (t2 :: S). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun S ((~>) S Bool) + -> GHC.Types.Type) t1) t2) (%==) SS1 SS1 = STrue (%==) SS1 SS2 = SFalse (%==) SS2 SS1 = SFalse (%==) SS2 SS2 = STrue instance SOrd S where sCompare :: - forall (t1 :: S) (t2 :: S). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (CompareSym0 :: TyFun S ((~>) S Ordering) - -> GHC.Types.Type) t1) t2) + forall (t1 :: S) (t2 :: S). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (CompareSym0 :: TyFun S ((~>) S Ordering) + -> GHC.Types.Type) t1) t2) sCompare SS1 SS1 = (applySing ((applySing @@ -443,12 +441,13 @@ sCompare SS2 SS1 = SGT instance SShow S where sShowsPrec :: - forall (t1 :: GHC.Types.Nat) (t2 :: S) (t3 :: Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) S ((~>) Symbol Symbol)) - -> GHC.Types.Type) t1) t2) t3) + forall (t1 :: GHC.Num.Natural.Natural) + (t2 :: S) + (t3 :: Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) S ((~>) Symbol Symbol)) + -> GHC.Types.Type) t1) t2) t3) sShowsPrec _ SS1 @@ -472,15 +471,13 @@ sMaxBound = SS2 instance SEnum S where sToEnum :: - forall (t :: GHC.Types.Nat). - Sing t - -> Sing (Apply (ToEnumSym0 :: TyFun GHC.Types.Nat S - -> GHC.Types.Type) t) + forall (t :: GHC.Num.Natural.Natural). Sing t + -> Sing (Apply (ToEnumSym0 :: TyFun GHC.Num.Natural.Natural S + -> GHC.Types.Type) t) sFromEnum :: - forall (t :: S). - Sing t - -> Sing (Apply (FromEnumSym0 :: TyFun S GHC.Types.Nat - -> GHC.Types.Type) t) + forall (t :: S). Sing t + -> Sing (Apply (FromEnumSym0 :: TyFun S GHC.Num.Natural.Natural + -> GHC.Types.Type) t) sToEnum (sN :: Sing n) = (id @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0))))) @@ -505,9 +502,9 @@ = case ((,) (((%~) a) b)) (((%~) a) b) of (,) (Proved Refl) (Proved Refl) -> Proved Refl (,) (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,) _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) instance SDecide a => Data.Type.Equality.TestEquality (ST :: T a () -> GHC.Types.Type) where @@ -520,8 +517,8 @@ = Data.Singletons.Decide.decideCoercion instance SDecide S where (%~) SS1 SS1 = Proved Refl - (%~) SS1 SS2 = Disproved (\ x -> case x of) - (%~) SS2 SS1 = Disproved (\ x -> case x of) + (%~) SS1 SS2 = Disproved (\ x -> case x of {}) + (%~) SS2 SS1 = Disproved (\ x -> case x of {}) (%~) SS2 SS2 = Proved Refl instance Data.Type.Equality.TestEquality (SS :: S -> GHC.Types.Type) where @@ -537,11 +534,18 @@ instance (SingI n, SingI n) => SingI ((:*:) (n :: a) (n :: b)) where sing = ((:%*:) sing) sing + instance SingI n => SingI1 ((:*:) (n :: a)) where + liftSing = (:%*:) sing + instance SingI2 (:*:) where + liftSing2 = (:%*:) instance SingI ((:*:@#@$) :: (~>) a ((~>) b (T a b))) where sing = (singFun2 @(:*:@#@$)) (:%*:) instance SingI d => SingI ((:*:@#@$$) (d :: a) :: (~>) b (T a b)) where sing = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) (sing @d)) + instance SingI1 ((:*:@#@$$) :: a -> (~>) b (T a b)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) s) instance SingI S1 where sing = SS1 instance SingI S2 where diff --git a/tests/compile-and-dump/Singletons/Star.golden b/tests/compile-and-dump/Singletons/Star.golden --- a/tests/compile-and-dump/Singletons/Star.golden +++ b/tests/compile-and-dump/Singletons/Star.golden @@ -148,16 +148,16 @@ Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210 instance POrd Type where type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural -> Type -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: Type) (a :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Type) (a :: Symbol) :: Symbol where ShowsPrec_0123456789876543210 _ Nat a_0123456789876543210 = Apply (Apply ShowStringSym0 "Nat") a_0123456789876543210 ShowsPrec_0123456789876543210 _ Int a_0123456789876543210 = Apply (Apply ShowStringSym0 "Int") a_0123456789876543210 ShowsPrec_0123456789876543210 _ String a_0123456789876543210 = Apply (Apply ShowStringSym0 "String") a_0123456789876543210 ShowsPrec_0123456789876543210 p_0123456789876543210 (Maybe arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Maybe ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210 ShowsPrec_0123456789876543210 p_0123456789876543210 (Vec arg_0123456789876543210 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Vec ")) (Apply (Apply (.@#@$) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210)) (Apply (Apply (.@#@$) ShowSpaceSym0) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))))) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Type ((~>) Symbol Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Type ((~>) Symbol Symbol)) + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Type ((~>) Symbol Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) Type ((~>) Symbol Symbol)) where ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => ShowsPrec_0123456789876543210Sym0 a0123456789876543210 @@ -165,9 +165,9 @@ instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> (~>) Type ((~>) Symbol Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) Type ((~>) Symbol Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) Type ((~>) Symbol Symbol) where ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -175,9 +175,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural -> Type -> (~>) Symbol Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Type) :: (~>) Symbol Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Type) :: (~>) Symbol Symbol where ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -185,9 +185,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural -> Type -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Type) (a0123456789876543210 :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Type) (a0123456789876543210 :: Symbol) :: Symbol where ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow Type where type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a @@ -212,49 +212,49 @@ toSing Singletons.Star.Int = SomeSing SInt toSing Singletons.Star.String = SomeSing SString toSing (Singletons.Star.Maybe (b :: Demote Type)) - = case toSing b :: SomeSing Type of { - SomeSing c -> SomeSing (SMaybe c) } + = case toSing b :: SomeSing Type of + SomeSing c -> SomeSing (SMaybe c) toSing (Singletons.Star.Vec (b :: Demote Type) (b :: Demote Nat)) = case ((,) (toSing b :: SomeSing Type)) (toSing b :: SomeSing Nat) - of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SVec c) c) } + of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SVec c) c) instance (SDecide Type, SDecide Nat) => SDecide Type where (%~) SNat SNat = Proved Refl - (%~) SNat SInt = Disproved (\ x -> case x of) - (%~) SNat SString = Disproved (\ x -> case x of) - (%~) SNat (SMaybe _) = Disproved (\ x -> case x of) - (%~) SNat (SVec _ _) = Disproved (\ x -> case x of) - (%~) SInt SNat = Disproved (\ x -> case x of) + (%~) SNat SInt = Disproved (\ x -> case x of {}) + (%~) SNat SString = Disproved (\ x -> case x of {}) + (%~) SNat (SMaybe _) = Disproved (\ x -> case x of {}) + (%~) SNat (SVec _ _) = Disproved (\ x -> case x of {}) + (%~) SInt SNat = Disproved (\ x -> case x of {}) (%~) SInt SInt = Proved Refl - (%~) SInt SString = Disproved (\ x -> case x of) - (%~) SInt (SMaybe _) = Disproved (\ x -> case x of) - (%~) SInt (SVec _ _) = Disproved (\ x -> case x of) - (%~) SString SNat = Disproved (\ x -> case x of) - (%~) SString SInt = Disproved (\ x -> case x of) + (%~) SInt SString = Disproved (\ x -> case x of {}) + (%~) SInt (SMaybe _) = Disproved (\ x -> case x of {}) + (%~) SInt (SVec _ _) = Disproved (\ x -> case x of {}) + (%~) SString SNat = Disproved (\ x -> case x of {}) + (%~) SString SInt = Disproved (\ x -> case x of {}) (%~) SString SString = Proved Refl - (%~) SString (SMaybe _) = Disproved (\ x -> case x of) - (%~) SString (SVec _ _) = Disproved (\ x -> case x of) - (%~) (SMaybe _) SNat = Disproved (\ x -> case x of) - (%~) (SMaybe _) SInt = Disproved (\ x -> case x of) - (%~) (SMaybe _) SString = Disproved (\ x -> case x of) + (%~) SString (SMaybe _) = Disproved (\ x -> case x of {}) + (%~) SString (SVec _ _) = Disproved (\ x -> case x of {}) + (%~) (SMaybe _) SNat = Disproved (\ x -> case x of {}) + (%~) (SMaybe _) SInt = Disproved (\ x -> case x of {}) + (%~) (SMaybe _) SString = Disproved (\ x -> case x of {}) (%~) (SMaybe a) (SMaybe b) = case ((%~) a) b of Proved Refl -> Proved Refl Disproved contra - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - (%~) (SMaybe _) (SVec _ _) = Disproved (\ x -> case x of) - (%~) (SVec _ _) SNat = Disproved (\ x -> case x of) - (%~) (SVec _ _) SInt = Disproved (\ x -> case x of) - (%~) (SVec _ _) SString = Disproved (\ x -> case x of) - (%~) (SVec _ _) (SMaybe _) = Disproved (\ x -> case x of) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) + (%~) (SMaybe _) (SVec _ _) = Disproved (\ x -> case x of {}) + (%~) (SVec _ _) SNat = Disproved (\ x -> case x of {}) + (%~) (SVec _ _) SInt = Disproved (\ x -> case x of {}) + (%~) (SVec _ _) SString = Disproved (\ x -> case x of {}) + (%~) (SVec _ _) (SMaybe _) = Disproved (\ x -> case x of {}) (%~) (SVec a a) (SVec b b) = case ((,) (((%~) a) b)) (((%~) a) b) of (,) (Proved Refl) (Proved Refl) -> Proved Refl (,) (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) (,) _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) instance (SDecide Type, SDecide Nat) => Data.Type.Equality.TestEquality (SRep :: Type -> Type) where Data.Type.Equality.testEquality = decideEquality @@ -263,11 +263,10 @@ Data.Type.Coercion.testCoercion = decideCoercion instance (SEq Type, SEq Nat) => SEq Type where (%==) :: - forall (t1 :: Type) (t2 :: Type). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun Type ((~>) Type Bool) - -> Type) t1) t2) + forall (t1 :: Type) (t2 :: Type). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun Type ((~>) Type Bool) + -> Type) t1) t2) (%==) SNat SNat = STrue (%==) SNat SInt = SFalse (%==) SNat SString = SFalse @@ -312,11 +311,10 @@ sB_0123456789876543210) instance (SOrd Type, SOrd Nat) => SOrd Type where sCompare :: - forall (t1 :: Type) (t2 :: Type). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (CompareSym0 :: TyFun Type ((~>) Type Ordering) - -> Type) t1) t2) + forall (t1 :: Type) (t2 :: Type). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (CompareSym0 :: TyFun Type ((~>) Type Ordering) + -> Type) t1) t2) sCompare SNat SNat = (applySing ((applySing @@ -398,12 +396,13 @@ sCompare (SVec _ _) (SMaybe _) = SGT instance (SShow Type, SShow Nat) => SShow Type where sShowsPrec :: - forall (t1 :: GHC.Types.Nat) (t2 :: Type) (t3 :: Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) Type ((~>) Symbol Symbol)) - -> Type) t1) t2) t3) + forall (t1 :: GHC.Num.Natural.Natural) + (t2 :: Type) + (t3 :: Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) Type ((~>) Symbol Symbol)) + -> Type) t1) t2) t3) sShowsPrec _ SNat @@ -484,13 +483,22 @@ sing = SString instance SingI n => SingI (Maybe (n :: Type)) where sing = SMaybe sing + instance SingI1 Maybe where + liftSing = SMaybe instance SingI (MaybeSym0 :: (~>) Type Type) where sing = (singFun1 @MaybeSym0) SMaybe instance (SingI n, SingI n) => SingI (Vec (n :: Type) (n :: Nat)) where sing = (SVec sing) sing + instance SingI n => SingI1 (Vec (n :: Type)) where + liftSing = SVec sing + instance SingI2 Vec where + liftSing2 = SVec instance SingI (VecSym0 :: (~>) Type ((~>) Nat Type)) where sing = (singFun2 @VecSym0) SVec instance SingI d => SingI (VecSym1 (d :: Type) :: (~>) Nat Type) where sing = (singFun1 @(VecSym1 (d :: Type))) (SVec (sing @d)) + instance SingI1 (VecSym1 :: Type -> (~>) Nat Type) where + liftSing (s :: Sing (d :: Type)) + = (singFun1 @(VecSym1 (d :: Type))) (SVec s) diff --git a/tests/compile-and-dump/Singletons/T136.golden b/tests/compile-and-dump/Singletons/T136.golden --- a/tests/compile-and-dump/Singletons/T136.golden +++ b/tests/compile-and-dump/Singletons/T136.golden @@ -71,11 +71,12 @@ Case_0123456789876543210 i arg_0123456789876543210 'False = Case_0123456789876543210 i arg_0123456789876543210 (Apply (Apply (==@#@$) i) (FromInteger 0)) type family Case_0123456789876543210 arg_0123456789876543210 t where Case_0123456789876543210 arg_0123456789876543210 i = Case_0123456789876543210 i arg_0123456789876543210 (Apply (Apply (<@#@$) i) (FromInteger 0)) - type ToEnum_0123456789876543210 :: GHC.Types.Nat -> [Bool] - type family ToEnum_0123456789876543210 (a :: GHC.Types.Nat) :: [Bool] where + type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural + -> [Bool] + type family ToEnum_0123456789876543210 (a :: GHC.Num.Natural.Natural) :: [Bool] where ToEnum_0123456789876543210 arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210 - type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat [Bool] - data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat [Bool] + type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural [Bool] + data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural [Bool] where ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) => ToEnum_0123456789876543210Sym0 a0123456789876543210 @@ -83,16 +84,18 @@ instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ()) - type ToEnum_0123456789876543210Sym1 :: GHC.Types.Nat -> [Bool] - type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: [Bool] where + type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural + -> [Bool] + type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: [Bool] where ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 - type FromEnum_0123456789876543210 :: [Bool] -> GHC.Types.Nat - type family FromEnum_0123456789876543210 (a :: [Bool]) :: GHC.Types.Nat where + type FromEnum_0123456789876543210 :: [Bool] + -> GHC.Num.Natural.Natural + type family FromEnum_0123456789876543210 (a :: [Bool]) :: GHC.Num.Natural.Natural where FromEnum_0123456789876543210 '[] = FromInteger 0 FromEnum_0123456789876543210 ('(:) 'False as) = Apply (Apply (*@#@$) (FromInteger 2)) (Apply FromEnumSym0 as) FromEnum_0123456789876543210 ('(:) 'True as) = Apply (Apply (+@#@$) (FromInteger 1)) (Apply (Apply (*@#@$) (FromInteger 2)) (Apply FromEnumSym0 as)) - type FromEnum_0123456789876543210Sym0 :: (~>) [Bool] GHC.Types.Nat - data FromEnum_0123456789876543210Sym0 :: (~>) [Bool] GHC.Types.Nat + type FromEnum_0123456789876543210Sym0 :: (~>) [Bool] GHC.Num.Natural.Natural + data FromEnum_0123456789876543210Sym0 :: (~>) [Bool] GHC.Num.Natural.Natural where FromEnum_0123456789876543210Sym0KindInference :: SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) => FromEnum_0123456789876543210Sym0 a0123456789876543210 @@ -100,8 +103,9 @@ instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ()) - type FromEnum_0123456789876543210Sym1 :: [Bool] -> GHC.Types.Nat - type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: [Bool]) :: GHC.Types.Nat where + type FromEnum_0123456789876543210Sym1 :: [Bool] + -> GHC.Num.Natural.Natural + type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: [Bool]) :: GHC.Num.Natural.Natural where FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210 instance PEnum [Bool] where type Succ a = Apply Succ_0123456789876543210Sym0 a @@ -110,25 +114,21 @@ type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a instance SEnum [Bool] where sSucc :: - forall (t :: [Bool]). - Sing t - -> Sing (Apply (SuccSym0 :: TyFun [Bool] [Bool] - -> GHC.Types.Type) t) + forall (t :: [Bool]). Sing t + -> Sing (Apply (SuccSym0 :: TyFun [Bool] [Bool] + -> GHC.Types.Type) t) sPred :: - forall (t :: [Bool]). - Sing t - -> Sing (Apply (PredSym0 :: TyFun [Bool] [Bool] - -> GHC.Types.Type) t) + forall (t :: [Bool]). Sing t + -> Sing (Apply (PredSym0 :: TyFun [Bool] [Bool] + -> GHC.Types.Type) t) sToEnum :: - forall (t :: GHC.Types.Nat). - Sing t - -> Sing (Apply (ToEnumSym0 :: TyFun GHC.Types.Nat [Bool] - -> GHC.Types.Type) t) + forall (t :: GHC.Num.Natural.Natural). Sing t + -> Sing (Apply (ToEnumSym0 :: TyFun GHC.Num.Natural.Natural [Bool] + -> GHC.Types.Type) t) sFromEnum :: - forall (t :: [Bool]). - Sing t - -> Sing (Apply (FromEnumSym0 :: TyFun [Bool] GHC.Types.Nat - -> GHC.Types.Type) t) + forall (t :: [Bool]). Sing t + -> Sing (Apply (FromEnumSym0 :: TyFun [Bool] GHC.Num.Natural.Natural + -> GHC.Types.Type) t) sSucc SNil = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) STrue)) SNil sSucc (SCons SFalse (sAs :: Sing as)) @@ -145,7 +145,7 @@ sToEnum (sArg_0123456789876543210 :: Sing arg_0123456789876543210) = (id @(Sing (Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210))) - (case sArg_0123456789876543210 of { + (case sArg_0123456789876543210 of (sI :: Sing i) -> (id @(Sing (Case_0123456789876543210 i arg_0123456789876543210 (Apply (Apply (<@#@$) i) (FromInteger 0))))) @@ -165,7 +165,7 @@ SFalse -> (applySing ((singFun1 @SuccSym0) sSucc)) ((applySing ((singFun1 @ToEnumSym0) sToEnum)) - ((applySing ((singFun1 @PredSym0) sPred)) sI)))) }) + ((applySing ((singFun1 @PredSym0) sPred)) sI))))) sFromEnum SNil = sFromInteger (sing :: Sing 0) sFromEnum (SCons SFalse (sAs :: Sing as)) = (applySing diff --git a/tests/compile-and-dump/Singletons/T136b.golden b/tests/compile-and-dump/Singletons/T136b.golden --- a/tests/compile-and-dump/Singletons/T136b.golden +++ b/tests/compile-and-dump/Singletons/T136b.golden @@ -17,7 +17,7 @@ type family MethSym1 (a0123456789876543210 :: a) :: a where MethSym1 a0123456789876543210 = Meth a0123456789876543210 class PC a where - type Meth (arg :: a) :: a + type family Meth (arg :: a) :: a class SC a where sMeth :: forall (t :: a). Sing t -> Sing (Apply MethSym0 t :: a) instance SC a => SingI (MethSym0 :: (~>) a a) where @@ -48,8 +48,7 @@ type Meth a = Apply Meth_0123456789876543210Sym0 a instance SC Bool where sMeth :: - forall (t :: Bool). - Sing t - -> Sing (Apply (MethSym0 :: TyFun Bool Bool -> GHC.Types.Type) t) + forall (t :: Bool). Sing t + -> Sing (Apply (MethSym0 :: TyFun Bool Bool -> GHC.Types.Type) t) sMeth (sA_0123456789876543210 :: Sing a_0123456789876543210) = (applySing ((singFun1 @NotSym0) sNot)) sA_0123456789876543210 diff --git a/tests/compile-and-dump/Singletons/T145.golden b/tests/compile-and-dump/Singletons/T145.golden --- a/tests/compile-and-dump/Singletons/T145.golden +++ b/tests/compile-and-dump/Singletons/T145.golden @@ -25,14 +25,17 @@ type family ColSym2 (a0123456789876543210 :: f a) (a0123456789876543210 :: a) :: Bool where ColSym2 a0123456789876543210 a0123456789876543210 = Col a0123456789876543210 a0123456789876543210 class PColumn (f :: Type -> Type) where - type Col (arg :: f a) (arg :: a) :: Bool + type family Col (arg :: f a) (arg :: a) :: Bool class SColumn (f :: Type -> Type) where sCol :: - forall a (t :: f a) (t :: a). - Sing t -> Sing t -> Sing (Apply (Apply ColSym0 t) t :: Bool) + forall a (t :: f a) (t :: a). Sing t + -> Sing t -> Sing (Apply (Apply ColSym0 t) t :: Bool) instance SColumn f => SingI (ColSym0 :: (~>) (f a) ((~>) a Bool)) where sing = (singFun2 @ColSym0) sCol instance (SColumn f, SingI d) => SingI (ColSym1 (d :: f a) :: (~>) a Bool) where sing = (singFun1 @(ColSym1 (d :: f a))) (sCol (sing @d)) + instance SColumn f => SingI1 (ColSym1 :: f a -> (~>) a Bool) where + liftSing (s :: Sing (d :: f a)) + = (singFun1 @(ColSym1 (d :: f a))) (sCol s) diff --git a/tests/compile-and-dump/Singletons/T150.golden b/tests/compile-and-dump/Singletons/T150.golden --- a/tests/compile-and-dump/Singletons/T150.golden +++ b/tests/compile-and-dump/Singletons/T150.golden @@ -9,7 +9,7 @@ (!) :: Vec n a -> Fin n -> a VCons x _ ! FZ = x VCons _ xs ! FS n = xs ! n - VNil ! n = case n of + VNil ! n = case n of {} mapVec :: (a -> b) -> Vec n a -> Vec n b mapVec _ VNil = VNil mapVec f (VCons x xs) = VCons (f x) (mapVec f xs) @@ -56,7 +56,7 @@ (!) :: Vec n a -> Fin n -> a (!) (VCons x _) FZ = x (!) (VCons _ xs) (FS n) = (xs ! n) - (!) VNil n = case n of + (!) VNil n = case n of {} mapVec :: (a -> b) -> Vec n a -> Vec n b mapVec _ VNil = VNil mapVec f (VCons x xs) = (VCons (f x)) ((mapVec f) xs) @@ -263,24 +263,25 @@ type family HeadVec (a :: Vec ('Succ n) a) :: a where HeadVec (VCons x _) = x sTransitivity :: - forall a b c (t :: Equal a b) (t :: Equal b c). - Sing t - -> Sing t -> Sing (Apply (Apply TransitivitySym0 t) t :: Equal a c) + forall a b c (t :: Equal a b) (t :: Equal b c). Sing t + -> Sing t + -> Sing (Apply (Apply TransitivitySym0 t) t :: Equal a c) sSymmetry :: - forall a b (t :: Equal a b). - Sing t -> Sing (Apply SymmetrySym0 t :: Equal b a) + forall a b (t :: Equal a b). Sing t + -> Sing (Apply SymmetrySym0 t :: Equal b a) sMapVec :: - forall a b n (t :: (~>) a b) (t :: Vec n a). - Sing t -> Sing t -> Sing (Apply (Apply MapVecSym0 t) t :: Vec n b) + forall a b n (t :: (~>) a b) (t :: Vec n a). Sing t + -> Sing t + -> Sing (Apply (Apply MapVecSym0 t) t :: Vec n b) (%!) :: - forall n a (t :: Vec n a) (t :: Fin n). - Sing t -> Sing t -> Sing (Apply (Apply (!@#@$) t) t :: a) + forall n a (t :: Vec n a) (t :: Fin n). Sing t + -> Sing t -> Sing (Apply (Apply (!@#@$) t) t :: a) sTailVec :: - forall n a (t :: Vec ('Succ n) a). - Sing t -> Sing (Apply TailVecSym0 t :: Vec n a) + forall n a (t :: Vec ('Succ n) a). Sing t + -> Sing (Apply TailVecSym0 t :: Vec n a) sHeadVec :: - forall n a (t :: Vec ('Succ n) a). - Sing t -> Sing (Apply HeadVecSym0 t :: a) + forall n a (t :: Vec ('Succ n) a). Sing t + -> Sing (Apply HeadVecSym0 t :: a) sTransitivity SReflexive SReflexive = SReflexive sSymmetry SReflexive = SReflexive sMapVec _ SVNil = SVNil @@ -292,7 +293,7 @@ (%!) (SVCons _ (sXs :: Sing xs)) (SFS (sN :: Sing n)) = (applySing ((applySing ((singFun2 @(!@#@$)) (%!))) sXs)) sN (%!) SVNil (sN :: Sing n) - = (id @(Sing (Case_0123456789876543210 n n :: a))) (case sN of) + = (id @(Sing (Case_0123456789876543210 n n :: a))) (case sN of {}) sTailVec (SVCons _ (sXs :: Sing xs)) = sXs sHeadVec (SVCons (sX :: Sing x) _) = sX instance SingI (TransitivitySym0 :: (~>) (Equal a b) ((~>) (Equal b c) (Equal a c))) where @@ -302,6 +303,10 @@ sing = (singFun1 @(TransitivitySym1 (d :: Equal a b))) (sTransitivity (sing @d)) + instance SingI1 (TransitivitySym1 :: Equal a b + -> (~>) (Equal b c) (Equal a c)) where + liftSing (s :: Sing (d :: Equal a b)) + = (singFun1 @(TransitivitySym1 (d :: Equal a b))) (sTransitivity s) instance SingI (SymmetrySym0 :: (~>) (Equal a b) (Equal b a)) where sing = (singFun1 @SymmetrySym0) sSymmetry instance SingI (MapVecSym0 :: (~>) ((~>) a b) ((~>) (Vec n a) (Vec n b))) where @@ -309,11 +314,18 @@ instance SingI d => SingI (MapVecSym1 (d :: (~>) a b) :: (~>) (Vec n a) (Vec n b)) where sing = (singFun1 @(MapVecSym1 (d :: (~>) a b))) (sMapVec (sing @d)) + instance SingI1 (MapVecSym1 :: (~>) a b + -> (~>) (Vec n a) (Vec n b)) where + liftSing (s :: Sing (d :: (~>) a b)) + = (singFun1 @(MapVecSym1 (d :: (~>) a b))) (sMapVec s) instance SingI ((!@#@$) :: (~>) (Vec n a) ((~>) (Fin n) a)) where sing = (singFun2 @(!@#@$)) (%!) instance SingI d => SingI ((!@#@$$) (d :: Vec n a) :: (~>) (Fin n) a) where sing = (singFun1 @((!@#@$$) (d :: Vec n a))) ((%!) (sing @d)) + instance SingI1 ((!@#@$$) :: Vec n a -> (~>) (Fin n) a) where + liftSing (s :: Sing (d :: Vec n a)) + = (singFun1 @((!@#@$$) (d :: Vec n a))) ((%!) s) instance SingI (TailVecSym0 :: (~>) (Vec ('Succ n) a) (Vec n a)) where sing = (singFun1 @TailVecSym0) sTailVec instance SingI (HeadVecSym0 :: (~>) (Vec ('Succ n) a) a) where @@ -351,6 +363,8 @@ sing = SFZ instance SingI n => SingI (FS (n :: Fin n)) where sing = SFS sing + instance SingI1 FS where + liftSing = SFS instance SingI (FSSym0 :: (~>) (Fin n) (Fin ('Succ n))) where sing = (singFun1 @FSSym0) SFS instance SingI MkFoo1 where @@ -362,11 +376,19 @@ instance (SingI n, SingI n) => SingI (VCons (n :: a) (n :: Vec n a)) where sing = (SVCons sing) sing + instance SingI n => SingI1 (VCons (n :: a)) where + liftSing = SVCons sing + instance SingI2 VCons where + liftSing2 = SVCons instance SingI (VConsSym0 :: (~>) a ((~>) (Vec n a) (Vec ('Succ n) a))) where sing = (singFun2 @VConsSym0) SVCons instance SingI d => SingI (VConsSym1 (d :: a) :: (~>) (Vec n a) (Vec ('Succ n) a)) where sing = (singFun1 @(VConsSym1 (d :: a))) (SVCons (sing @d)) + instance SingI1 (VConsSym1 :: a + -> (~>) (Vec n a) (Vec ('Succ n) a)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(VConsSym1 (d :: a))) (SVCons s) instance SingI Reflexive where sing = SReflexive instance SingI HNil where @@ -374,12 +396,22 @@ instance (SingI n, SingI n) => SingI (HCons (n :: x) (n :: HList xs)) where sing = (SHCons sing) sing + instance SingI n => SingI1 (HCons (n :: x)) where + liftSing = SHCons sing + instance SingI2 HCons where + liftSing2 = SHCons instance SingI (HConsSym0 :: (~>) x ((~>) (HList xs) (HList ('(:) x xs)))) where sing = (singFun2 @HConsSym0) SHCons instance SingI d => SingI (HConsSym1 (d :: x) :: (~>) (HList xs) (HList ('(:) x xs))) where sing = (singFun1 @(HConsSym1 (d :: x))) (SHCons (sing @d)) + instance SingI1 (HConsSym1 :: x + -> (~>) (HList xs) (HList ('(:) x xs))) where + liftSing (s :: Sing (d :: x)) + = (singFun1 @(HConsSym1 (d :: x))) (SHCons s) instance SingI n => SingI (Obj (n :: a)) where sing = SObj sing + instance SingI1 Obj where + liftSing = SObj instance SingI (ObjSym0 :: (~>) a Obj) where sing = (singFun1 @ObjSym0) SObj diff --git a/tests/compile-and-dump/Singletons/T159.golden b/tests/compile-and-dump/Singletons/T159.golden --- a/tests/compile-and-dump/Singletons/T159.golden +++ b/tests/compile-and-dump/Singletons/T159.golden @@ -118,15 +118,11 @@ fromSing ((:%&&) b b) = ((:&&) (fromSing b)) (fromSing b) toSing N1 = SomeSing SN1 toSing (C1 (b :: Demote T0) (b :: Demote T1)) - = case - ((,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T1) - of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SC1 c) c) } + = case ((,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T1) of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SC1 c) c) toSing ((:&&) (b :: Demote T0) (b :: Demote T1)) - = case - ((,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T1) - of { - (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%&&) c) c) } + = case ((,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T1) of + (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%&&) c) c) infixr 5 `SC1` infixr 5 :%&& instance SingI 'N1 where @@ -134,18 +130,32 @@ instance (SingI n, SingI n) => SingI ('C1 (n :: T0) (n :: T1)) where sing = (SC1 sing) sing + instance SingI n => SingI1 ('C1 (n :: T0)) where + liftSing = SC1 sing + instance SingI2 'C1 where + liftSing2 = SC1 instance SingI (C1Sym0 :: (~>) T0 ((~>) T1 T1)) where sing = (singFun2 @C1Sym0) SC1 instance SingI d => SingI (C1Sym1 (d :: T0) :: (~>) T1 T1) where sing = (singFun1 @(C1Sym1 (d :: T0))) (SC1 (sing @d)) + instance SingI1 (C1Sym1 :: T0 -> (~>) T1 T1) where + liftSing (s :: Sing (d :: T0)) + = (singFun1 @(C1Sym1 (d :: T0))) (SC1 s) instance (SingI n, SingI n) => SingI ('(:&&) (n :: T0) (n :: T1)) where sing = ((:%&&) sing) sing + instance SingI n => SingI1 ('(:&&) (n :: T0)) where + liftSing = (:%&&) sing + instance SingI2 '(:&&) where + liftSing2 = (:%&&) instance SingI ((:&&@#@$) :: (~>) T0 ((~>) T1 T1)) where sing = (singFun2 @(:&&@#@$)) (:%&&) instance SingI d => SingI ((:&&@#@$$) (d :: T0) :: (~>) T1 T1) where sing = (singFun1 @((:&&@#@$$) (d :: T0))) ((:%&&) (sing @d)) + instance SingI1 ((:&&@#@$$) :: T0 -> (~>) T1 T1) where + liftSing (s :: Sing (d :: T0)) + = (singFun1 @((:&&@#@$$) (d :: T0))) ((:%&&) s) Singletons/T159.hs:(0,0)-(0,0): Splicing declarations singletons [d| infixr 5 :|| @@ -220,28 +230,38 @@ fromSing ((:%||) b b) = ((:||) (fromSing b)) (fromSing b) toSing N2 = SomeSing SN2 toSing (C2 (b :: Demote T0) (b :: Demote T2)) - = case - ((,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T2) - of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SC2 c) c) } + = case ((,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T2) of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SC2 c) c) toSing ((:||) (b :: Demote T0) (b :: Demote T2)) - = case - ((,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T2) - of { - (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%||) c) c) } + = case ((,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T2) of + (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%||) c) c) instance SingI N2 where sing = SN2 instance (SingI n, SingI n) => SingI (C2 (n :: T0) (n :: T2)) where sing = (SC2 sing) sing + instance SingI n => SingI1 (C2 (n :: T0)) where + liftSing = SC2 sing + instance SingI2 C2 where + liftSing2 = SC2 instance SingI (C2Sym0 :: (~>) T0 ((~>) T2 T2)) where sing = (singFun2 @C2Sym0) SC2 instance SingI d => SingI (C2Sym1 (d :: T0) :: (~>) T2 T2) where sing = (singFun1 @(C2Sym1 (d :: T0))) (SC2 (sing @d)) + instance SingI1 (C2Sym1 :: T0 -> (~>) T2 T2) where + liftSing (s :: Sing (d :: T0)) + = (singFun1 @(C2Sym1 (d :: T0))) (SC2 s) instance (SingI n, SingI n) => SingI ((:||) (n :: T0) (n :: T2)) where sing = ((:%||) sing) sing + instance SingI n => SingI1 ((:||) (n :: T0)) where + liftSing = (:%||) sing + instance SingI2 (:||) where + liftSing2 = (:%||) instance SingI ((:||@#@$) :: (~>) T0 ((~>) T2 T2)) where sing = (singFun2 @(:||@#@$)) (:%||) instance SingI d => SingI ((:||@#@$$) (d :: T0) :: (~>) T2 T2) where sing = (singFun1 @((:||@#@$$) (d :: T0))) ((:%||) (sing @d)) + instance SingI1 ((:||@#@$$) :: T0 -> (~>) T2 T2) where + liftSing (s :: Sing (d :: T0)) + = (singFun1 @((:||@#@$$) (d :: T0))) ((:%||) s) diff --git a/tests/compile-and-dump/Singletons/T160.golden b/tests/compile-and-dump/Singletons/T160.golden --- a/tests/compile-and-dump/Singletons/T160.golden +++ b/tests/compile-and-dump/Singletons/T160.golden @@ -38,8 +38,8 @@ type family Foo (a :: a) :: a where Foo x = Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x) sFoo :: - forall a (t :: a). - (SNum a, SEq a) => Sing t -> Sing (Apply FooSym0 t :: a) + forall a (t :: a). (SNum a, SEq a) => + Sing t -> Sing (Apply FooSym0 t :: a) sFoo (sX :: Sing x) = let sScrutinee_0123456789876543210 :: diff --git a/tests/compile-and-dump/Singletons/T163.golden b/tests/compile-and-dump/Singletons/T163.golden --- a/tests/compile-and-dump/Singletons/T163.golden +++ b/tests/compile-and-dump/Singletons/T163.golden @@ -34,14 +34,18 @@ fromSing (SL b) = L (fromSing b) fromSing (SR b) = R (fromSing b) toSing (L (b :: Demote a)) - = case toSing b :: SomeSing a of { SomeSing c -> SomeSing (SL c) } + = case toSing b :: SomeSing a of SomeSing c -> SomeSing (SL c) toSing (R (b :: Demote b)) - = case toSing b :: SomeSing b of { SomeSing c -> SomeSing (SR c) } + = case toSing b :: SomeSing b of SomeSing c -> SomeSing (SR c) instance SingI n => SingI (L (n :: a)) where sing = SL sing + instance SingI1 L where + liftSing = SL instance SingI (LSym0 :: (~>) a ((+) a b)) where sing = (singFun1 @LSym0) SL instance SingI n => SingI (R (n :: b)) where sing = SR sing + instance SingI1 R where + liftSing = SR instance SingI (RSym0 :: (~>) b ((+) a b)) where sing = (singFun1 @RSym0) SR diff --git a/tests/compile-and-dump/Singletons/T166.golden b/tests/compile-and-dump/Singletons/T166.golden --- a/tests/compile-and-dump/Singletons/T166.golden +++ b/tests/compile-and-dump/Singletons/T166.golden @@ -1,37 +1,37 @@ Singletons/T166.hs:(0,0)-(0,0): Splicing declarations singletonsOnly [d| class Foo a where - foosPrec :: Nat -> a -> [Bool] -> [Bool] + foosPrec :: Natural -> a -> [Bool] -> [Bool] foo :: a -> [Bool] foo x s = foosPrec 0 x s |] ======> - type FoosPrecSym0 :: forall a. - (~>) Nat ((~>) a ((~>) [Bool] [Bool])) - data FoosPrecSym0 :: (~>) Nat ((~>) a ((~>) [Bool] [Bool])) + type FoosPrecSym0 :: forall a. (~>) Natural ((~>) a ((~>) [Bool] [Bool])) + data FoosPrecSym0 :: (~>) Natural ((~>) a ((~>) [Bool] [Bool])) where FoosPrecSym0KindInference :: SameKind (Apply FoosPrecSym0 arg) (FoosPrecSym1 arg) => FoosPrecSym0 a0123456789876543210 type instance Apply FoosPrecSym0 a0123456789876543210 = FoosPrecSym1 a0123456789876543210 instance SuppressUnusedWarnings FoosPrecSym0 where suppressUnusedWarnings = snd (((,) FoosPrecSym0KindInference) ()) - type FoosPrecSym1 :: forall a. Nat -> (~>) a ((~>) [Bool] [Bool]) - data FoosPrecSym1 (a0123456789876543210 :: Nat) :: (~>) a ((~>) [Bool] [Bool]) + type FoosPrecSym1 :: forall a. Natural + -> (~>) a ((~>) [Bool] [Bool]) + data FoosPrecSym1 (a0123456789876543210 :: Natural) :: (~>) a ((~>) [Bool] [Bool]) where FoosPrecSym1KindInference :: SameKind (Apply (FoosPrecSym1 a0123456789876543210) arg) (FoosPrecSym2 a0123456789876543210 arg) => FoosPrecSym1 a0123456789876543210 a0123456789876543210 type instance Apply (FoosPrecSym1 a0123456789876543210) a0123456789876543210 = FoosPrecSym2 a0123456789876543210 a0123456789876543210 instance SuppressUnusedWarnings (FoosPrecSym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) FoosPrecSym1KindInference) ()) - type FoosPrecSym2 :: forall a. Nat -> a -> (~>) [Bool] [Bool] - data FoosPrecSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: a) :: (~>) [Bool] [Bool] + type FoosPrecSym2 :: forall a. Natural -> a -> (~>) [Bool] [Bool] + data FoosPrecSym2 (a0123456789876543210 :: Natural) (a0123456789876543210 :: a) :: (~>) [Bool] [Bool] where FoosPrecSym2KindInference :: SameKind (Apply (FoosPrecSym2 a0123456789876543210 a0123456789876543210) arg) (FoosPrecSym3 a0123456789876543210 a0123456789876543210 arg) => FoosPrecSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 type instance Apply (FoosPrecSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = FoosPrec a0123456789876543210 a0123456789876543210 a0123456789876543210 instance SuppressUnusedWarnings (FoosPrecSym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) FoosPrecSym2KindInference) ()) - type FoosPrecSym3 :: forall a. Nat -> a -> [Bool] -> [Bool] - type family FoosPrecSym3 (a0123456789876543210 :: Nat) (a0123456789876543210 :: a) (a0123456789876543210 :: [Bool]) :: [Bool] where + type FoosPrecSym3 :: forall a. Natural -> a -> [Bool] -> [Bool] + type family FoosPrecSym3 (a0123456789876543210 :: Natural) (a0123456789876543210 :: a) (a0123456789876543210 :: [Bool]) :: [Bool] where FoosPrecSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = FoosPrec a0123456789876543210 a0123456789876543210 a0123456789876543210 type FooSym0 :: forall a. (~>) a [Bool] data FooSym0 :: (~>) a [Bool] @@ -80,44 +80,59 @@ type family Foo_0123456789876543210Sym1 (a0123456789876543210 :: a) :: [Bool] where Foo_0123456789876543210Sym1 a0123456789876543210 = Foo_0123456789876543210 a0123456789876543210 class PFoo a where - type FoosPrec (arg :: Nat) (arg :: a) (arg :: [Bool]) :: [Bool] - type Foo (arg :: a) :: [Bool] + type family FoosPrec (arg :: Natural) (arg :: a) (arg :: [Bool]) :: [Bool] + type family Foo (arg :: a) :: [Bool] type Foo a = Apply Foo_0123456789876543210Sym0 a class SFoo a where sFoosPrec :: - forall (t :: Nat) (t :: a) (t :: [Bool]). - Sing t - -> Sing t - -> Sing t - -> Sing (Apply (Apply (Apply FoosPrecSym0 t) t) t :: [Bool]) + forall (t :: Natural) (t :: a) (t :: [Bool]). Sing t + -> Sing t + -> Sing t + -> Sing (Apply (Apply (Apply FoosPrecSym0 t) t) t :: [Bool]) sFoo :: forall (t :: a). Sing t -> Sing (Apply FooSym0 t :: [Bool]) default sFoo :: - forall (t :: a). - ((Apply FooSym0 t :: [Bool]) - ~ Apply Foo_0123456789876543210Sym0 t) => - Sing t -> Sing (Apply FooSym0 t :: [Bool]) + forall (t :: a). ((Apply FooSym0 t :: [Bool]) + ~ Apply Foo_0123456789876543210Sym0 t) => + Sing t -> Sing (Apply FooSym0 t :: [Bool]) sFoo (sX :: Sing x) = (singFun1 @(Apply Lambda_0123456789876543210Sym0 x)) (\ sS - -> case sS of { + -> case sS of (_ :: Sing s) -> (applySing ((applySing ((applySing ((singFun3 @FoosPrecSym0) sFoosPrec)) (sFromInteger (sing :: Sing 0)))) sX)) - sS }) + sS) instance SFoo a => - SingI (FoosPrecSym0 :: (~>) Nat ((~>) a ((~>) [Bool] [Bool]))) where + SingI (FoosPrecSym0 :: (~>) Natural ((~>) a ((~>) [Bool] [Bool]))) where sing = (singFun3 @FoosPrecSym0) sFoosPrec instance (SFoo a, SingI d) => - SingI (FoosPrecSym1 (d :: Nat) :: (~>) a ((~>) [Bool] [Bool])) where - sing = (singFun2 @(FoosPrecSym1 (d :: Nat))) (sFoosPrec (sing @d)) + SingI (FoosPrecSym1 (d :: Natural) :: (~>) a ((~>) [Bool] [Bool])) where + sing + = (singFun2 @(FoosPrecSym1 (d :: Natural))) (sFoosPrec (sing @d)) + instance SFoo a => + SingI1 (FoosPrecSym1 :: Natural + -> (~>) a ((~>) [Bool] [Bool])) where + liftSing (s :: Sing (d :: Natural)) + = (singFun2 @(FoosPrecSym1 (d :: Natural))) (sFoosPrec s) instance (SFoo a, SingI d, SingI d) => - SingI (FoosPrecSym2 (d :: Nat) (d :: a) :: (~>) [Bool] [Bool]) where + SingI (FoosPrecSym2 (d :: Natural) (d :: a) :: (~>) [Bool] [Bool]) where sing - = (singFun1 @(FoosPrecSym2 (d :: Nat) (d :: a))) + = (singFun1 @(FoosPrecSym2 (d :: Natural) (d :: a))) ((sFoosPrec (sing @d)) (sing @d)) + instance (SFoo a, SingI d) => + SingI1 (FoosPrecSym2 (d :: Natural) :: a + -> (~>) [Bool] [Bool]) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(FoosPrecSym2 (d :: Natural) (d :: a))) + ((sFoosPrec (sing @d)) s) + instance SFoo a => + SingI2 (FoosPrecSym2 :: Natural -> a -> (~>) [Bool] [Bool]) where + liftSing2 (s :: Sing (d :: Natural)) (s :: Sing (d :: a)) + = (singFun1 @(FoosPrecSym2 (d :: Natural) (d :: a))) + ((sFoosPrec s) s) instance SFoo a => SingI (FooSym0 :: (~>) a [Bool]) where sing = (singFun1 @FooSym0) sFoo diff --git a/tests/compile-and-dump/Singletons/T166.hs b/tests/compile-and-dump/Singletons/T166.hs --- a/tests/compile-and-dump/Singletons/T166.hs +++ b/tests/compile-and-dump/Singletons/T166.hs @@ -13,7 +13,7 @@ $(singletonsOnly [d| class Foo a where - foosPrec :: Nat -> a -> [Bool] -> [Bool] + foosPrec :: Natural -> a -> [Bool] -> [Bool] foo :: a -> [Bool] foo x s = foosPrec 0 x s diff --git a/tests/compile-and-dump/Singletons/T167.golden b/tests/compile-and-dump/Singletons/T167.golden --- a/tests/compile-and-dump/Singletons/T167.golden +++ b/tests/compile-and-dump/Singletons/T167.golden @@ -1,40 +1,40 @@ Singletons/T167.hs:(0,0)-(0,0): Splicing declarations singletonsOnly [d| class Foo a where - foosPrec :: Nat -> a -> DiffList + foosPrec :: Natural -> a -> DiffList fooList :: a -> DiffList fooList = undefined instance Foo a => Foo [a] where foosPrec _ = fooList |] ======> - type FoosPrecSym0 :: forall a. - (~>) Nat ((~>) a ((~>) [Bool] [Bool])) - data FoosPrecSym0 :: (~>) Nat ((~>) a ((~>) [Bool] [Bool])) + type FoosPrecSym0 :: forall a. (~>) Natural ((~>) a ((~>) [Bool] [Bool])) + data FoosPrecSym0 :: (~>) Natural ((~>) a ((~>) [Bool] [Bool])) where FoosPrecSym0KindInference :: SameKind (Apply FoosPrecSym0 arg) (FoosPrecSym1 arg) => FoosPrecSym0 a0123456789876543210 type instance Apply FoosPrecSym0 a0123456789876543210 = FoosPrecSym1 a0123456789876543210 instance SuppressUnusedWarnings FoosPrecSym0 where suppressUnusedWarnings = snd (((,) FoosPrecSym0KindInference) ()) - type FoosPrecSym1 :: forall a. Nat -> (~>) a ((~>) [Bool] [Bool]) - data FoosPrecSym1 (a0123456789876543210 :: Nat) :: (~>) a ((~>) [Bool] [Bool]) + type FoosPrecSym1 :: forall a. Natural + -> (~>) a ((~>) [Bool] [Bool]) + data FoosPrecSym1 (a0123456789876543210 :: Natural) :: (~>) a ((~>) [Bool] [Bool]) where FoosPrecSym1KindInference :: SameKind (Apply (FoosPrecSym1 a0123456789876543210) arg) (FoosPrecSym2 a0123456789876543210 arg) => FoosPrecSym1 a0123456789876543210 a0123456789876543210 type instance Apply (FoosPrecSym1 a0123456789876543210) a0123456789876543210 = FoosPrecSym2 a0123456789876543210 a0123456789876543210 instance SuppressUnusedWarnings (FoosPrecSym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) FoosPrecSym1KindInference) ()) - type FoosPrecSym2 :: forall a. Nat -> a -> (~>) [Bool] [Bool] - data FoosPrecSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: a) :: (~>) [Bool] [Bool] + type FoosPrecSym2 :: forall a. Natural -> a -> (~>) [Bool] [Bool] + data FoosPrecSym2 (a0123456789876543210 :: Natural) (a0123456789876543210 :: a) :: (~>) [Bool] [Bool] where FoosPrecSym2KindInference :: SameKind (Apply (FoosPrecSym2 a0123456789876543210 a0123456789876543210) arg) (FoosPrecSym3 a0123456789876543210 a0123456789876543210 arg) => FoosPrecSym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 type instance Apply (FoosPrecSym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = FoosPrec a0123456789876543210 a0123456789876543210 a0123456789876543210 instance SuppressUnusedWarnings (FoosPrecSym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) FoosPrecSym2KindInference) ()) - type FoosPrecSym3 :: forall a. Nat -> a -> [Bool] -> [Bool] - type family FoosPrecSym3 (a0123456789876543210 :: Nat) (a0123456789876543210 :: a) (a0123456789876543210 :: [Bool]) :: [Bool] where + type FoosPrecSym3 :: forall a. Natural -> a -> [Bool] -> [Bool] + type family FoosPrecSym3 (a0123456789876543210 :: Natural) (a0123456789876543210 :: a) (a0123456789876543210 :: [Bool]) :: [Bool] where FoosPrecSym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = FoosPrec a0123456789876543210 a0123456789876543210 a0123456789876543210 type FooListSym0 :: forall a. (~>) a ((~>) [Bool] [Bool]) data FooListSym0 :: (~>) a ((~>) [Bool] [Bool]) @@ -80,14 +80,15 @@ type family FooList_0123456789876543210Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: [Bool]) :: [Bool] where FooList_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = FooList_0123456789876543210 a0123456789876543210 a0123456789876543210 class PFoo a where - type FoosPrec (arg :: Nat) (arg :: a) (arg :: [Bool]) :: [Bool] - type FooList (arg :: a) (arg :: [Bool]) :: [Bool] + type family FoosPrec (arg :: Natural) (arg :: a) (arg :: [Bool]) :: [Bool] + type family FooList (arg :: a) (arg :: [Bool]) :: [Bool] type FooList a a = Apply (Apply FooList_0123456789876543210Sym0 a) a - type FoosPrec_0123456789876543210 :: Nat -> [a] -> [Bool] -> [Bool] - type family FoosPrec_0123456789876543210 (a :: Nat) (a :: [a]) (a :: [Bool]) :: [Bool] where + type FoosPrec_0123456789876543210 :: Natural + -> [a] -> [Bool] -> [Bool] + type family FoosPrec_0123456789876543210 (a :: Natural) (a :: [a]) (a :: [Bool]) :: [Bool] where FoosPrec_0123456789876543210 _ a_0123456789876543210 a_0123456789876543210 = Apply (Apply FooListSym0 a_0123456789876543210) a_0123456789876543210 - type FoosPrec_0123456789876543210Sym0 :: (~>) Nat ((~>) [a] ((~>) [Bool] [Bool])) - data FoosPrec_0123456789876543210Sym0 :: (~>) Nat ((~>) [a] ((~>) [Bool] [Bool])) + type FoosPrec_0123456789876543210Sym0 :: (~>) Natural ((~>) [a] ((~>) [Bool] [Bool])) + data FoosPrec_0123456789876543210Sym0 :: (~>) Natural ((~>) [a] ((~>) [Bool] [Bool])) where FoosPrec_0123456789876543210Sym0KindInference :: SameKind (Apply FoosPrec_0123456789876543210Sym0 arg) (FoosPrec_0123456789876543210Sym1 arg) => FoosPrec_0123456789876543210Sym0 a0123456789876543210 @@ -95,9 +96,9 @@ instance SuppressUnusedWarnings FoosPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) FoosPrec_0123456789876543210Sym0KindInference) ()) - type FoosPrec_0123456789876543210Sym1 :: Nat + type FoosPrec_0123456789876543210Sym1 :: Natural -> (~>) [a] ((~>) [Bool] [Bool]) - data FoosPrec_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) [a] ((~>) [Bool] [Bool]) + data FoosPrec_0123456789876543210Sym1 (a0123456789876543210 :: Natural) :: (~>) [a] ((~>) [Bool] [Bool]) where FoosPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (FoosPrec_0123456789876543210Sym1 a0123456789876543210) arg) (FoosPrec_0123456789876543210Sym2 a0123456789876543210 arg) => FoosPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -105,9 +106,9 @@ instance SuppressUnusedWarnings (FoosPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) FoosPrec_0123456789876543210Sym1KindInference) ()) - type FoosPrec_0123456789876543210Sym2 :: Nat + type FoosPrec_0123456789876543210Sym2 :: Natural -> [a] -> (~>) [Bool] [Bool] - data FoosPrec_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: [a]) :: (~>) [Bool] [Bool] + data FoosPrec_0123456789876543210Sym2 (a0123456789876543210 :: Natural) (a0123456789876543210 :: [a]) :: (~>) [Bool] [Bool] where FoosPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (FoosPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (FoosPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => FoosPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -115,38 +116,37 @@ instance SuppressUnusedWarnings (FoosPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) FoosPrec_0123456789876543210Sym2KindInference) ()) - type FoosPrec_0123456789876543210Sym3 :: Nat + type FoosPrec_0123456789876543210Sym3 :: Natural -> [a] -> [Bool] -> [Bool] - type family FoosPrec_0123456789876543210Sym3 (a0123456789876543210 :: Nat) (a0123456789876543210 :: [a]) (a0123456789876543210 :: [Bool]) :: [Bool] where + type family FoosPrec_0123456789876543210Sym3 (a0123456789876543210 :: Natural) (a0123456789876543210 :: [a]) (a0123456789876543210 :: [Bool]) :: [Bool] where FoosPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = FoosPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PFoo [a] where type FoosPrec a a a = Apply (Apply (Apply FoosPrec_0123456789876543210Sym0 a) a) a class SFoo a where sFoosPrec :: - forall (t :: Nat) (t :: a) (t :: [Bool]). - Sing t - -> Sing t - -> Sing t - -> Sing (Apply (Apply (Apply FoosPrecSym0 t) t) t :: [Bool]) + forall (t :: Natural) (t :: a) (t :: [Bool]). Sing t + -> Sing t + -> Sing t + -> Sing (Apply (Apply (Apply FoosPrecSym0 t) t) t :: [Bool]) sFooList :: - forall (t :: a) (t :: [Bool]). - Sing t -> Sing t -> Sing (Apply (Apply FooListSym0 t) t :: [Bool]) + forall (t :: a) (t :: [Bool]). Sing t + -> Sing t -> Sing (Apply (Apply FooListSym0 t) t :: [Bool]) default sFooList :: - forall (t :: a) (t :: [Bool]). - ((Apply (Apply FooListSym0 t) t :: [Bool]) - ~ Apply (Apply FooList_0123456789876543210Sym0 t) t) => - Sing t -> Sing t -> Sing (Apply (Apply FooListSym0 t) t :: [Bool]) + forall (t :: a) + (t :: [Bool]). ((Apply (Apply FooListSym0 t) t :: [Bool]) + ~ Apply (Apply FooList_0123456789876543210Sym0 t) t) => + Sing t + -> Sing t -> Sing (Apply (Apply FooListSym0 t) t :: [Bool]) sFooList (sA_0123456789876543210 :: Sing a_0123456789876543210) (sA_0123456789876543210 :: Sing a_0123456789876543210) = (sUndefined sA_0123456789876543210) sA_0123456789876543210 instance SFoo a => SFoo [a] where sFoosPrec :: - forall (t :: Nat) (t :: [a]) (t :: [Bool]). - Sing t - -> Sing t - -> Sing t - -> Sing (Apply (Apply (Apply FoosPrecSym0 t) t) t :: [Bool]) + forall (t :: Natural) (t :: [a]) (t :: [Bool]). Sing t + -> Sing t + -> Sing t + -> Sing (Apply (Apply (Apply FoosPrecSym0 t) t) t :: [Bool]) sFoosPrec _ (sA_0123456789876543210 :: Sing a_0123456789876543210) @@ -156,19 +156,40 @@ sA_0123456789876543210)) sA_0123456789876543210 instance SFoo a => - SingI (FoosPrecSym0 :: (~>) Nat ((~>) a ((~>) [Bool] [Bool]))) where + SingI (FoosPrecSym0 :: (~>) Natural ((~>) a ((~>) [Bool] [Bool]))) where sing = (singFun3 @FoosPrecSym0) sFoosPrec instance (SFoo a, SingI d) => - SingI (FoosPrecSym1 (d :: Nat) :: (~>) a ((~>) [Bool] [Bool])) where - sing = (singFun2 @(FoosPrecSym1 (d :: Nat))) (sFoosPrec (sing @d)) + SingI (FoosPrecSym1 (d :: Natural) :: (~>) a ((~>) [Bool] [Bool])) where + sing + = (singFun2 @(FoosPrecSym1 (d :: Natural))) (sFoosPrec (sing @d)) + instance SFoo a => + SingI1 (FoosPrecSym1 :: Natural + -> (~>) a ((~>) [Bool] [Bool])) where + liftSing (s :: Sing (d :: Natural)) + = (singFun2 @(FoosPrecSym1 (d :: Natural))) (sFoosPrec s) instance (SFoo a, SingI d, SingI d) => - SingI (FoosPrecSym2 (d :: Nat) (d :: a) :: (~>) [Bool] [Bool]) where + SingI (FoosPrecSym2 (d :: Natural) (d :: a) :: (~>) [Bool] [Bool]) where sing - = (singFun1 @(FoosPrecSym2 (d :: Nat) (d :: a))) + = (singFun1 @(FoosPrecSym2 (d :: Natural) (d :: a))) ((sFoosPrec (sing @d)) (sing @d)) + instance (SFoo a, SingI d) => + SingI1 (FoosPrecSym2 (d :: Natural) :: a + -> (~>) [Bool] [Bool]) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(FoosPrecSym2 (d :: Natural) (d :: a))) + ((sFoosPrec (sing @d)) s) instance SFoo a => + SingI2 (FoosPrecSym2 :: Natural -> a -> (~>) [Bool] [Bool]) where + liftSing2 (s :: Sing (d :: Natural)) (s :: Sing (d :: a)) + = (singFun1 @(FoosPrecSym2 (d :: Natural) (d :: a))) + ((sFoosPrec s) s) + instance SFoo a => SingI (FooListSym0 :: (~>) a ((~>) [Bool] [Bool])) where sing = (singFun2 @FooListSym0) sFooList instance (SFoo a, SingI d) => SingI (FooListSym1 (d :: a) :: (~>) [Bool] [Bool]) where sing = (singFun1 @(FooListSym1 (d :: a))) (sFooList (sing @d)) + instance SFoo a => + SingI1 (FooListSym1 :: a -> (~>) [Bool] [Bool]) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(FooListSym1 (d :: a))) (sFooList s) diff --git a/tests/compile-and-dump/Singletons/T167.hs b/tests/compile-and-dump/Singletons/T167.hs --- a/tests/compile-and-dump/Singletons/T167.hs +++ b/tests/compile-and-dump/Singletons/T167.hs @@ -17,7 +17,7 @@ $(singletonsOnly [d| class Foo a where - foosPrec :: Nat -> a -> DiffList + foosPrec :: Natural -> a -> DiffList fooList :: a -> DiffList fooList = undefined diff --git a/tests/compile-and-dump/Singletons/T172.golden b/tests/compile-and-dump/Singletons/T172.golden --- a/tests/compile-and-dump/Singletons/T172.golden +++ b/tests/compile-and-dump/Singletons/T172.golden @@ -1,41 +1,46 @@ Singletons/T172.hs:(0,0)-(0,0): Splicing declarations singletonsOnly - [d| ($>) :: Nat -> Nat -> Nat + [d| ($>) :: Natural -> Natural -> Natural ($>) = (+) |] ======> - type ($>@#@$) :: (~>) Nat ((~>) Nat Nat) - data ($>@#@$) :: (~>) Nat ((~>) Nat Nat) + type ($>@#@$) :: (~>) Natural ((~>) Natural Natural) + data ($>@#@$) :: (~>) Natural ((~>) Natural Natural) where (:$>@#@$###) :: SameKind (Apply ($>@#@$) arg) (($>@#@$$) arg) => ($>@#@$) a0123456789876543210 type instance Apply ($>@#@$) a0123456789876543210 = ($>@#@$$) a0123456789876543210 instance SuppressUnusedWarnings ($>@#@$) where suppressUnusedWarnings = snd (((,) (:$>@#@$###)) ()) - type ($>@#@$$) :: Nat -> (~>) Nat Nat - data ($>@#@$$) (a0123456789876543210 :: Nat) :: (~>) Nat Nat + type ($>@#@$$) :: Natural -> (~>) Natural Natural + data ($>@#@$$) (a0123456789876543210 :: Natural) :: (~>) Natural Natural where (:$>@#@$$###) :: SameKind (Apply (($>@#@$$) a0123456789876543210) arg) (($>@#@$$$) a0123456789876543210 arg) => ($>@#@$$) a0123456789876543210 a0123456789876543210 type instance Apply (($>@#@$$) a0123456789876543210) a0123456789876543210 = ($>) a0123456789876543210 a0123456789876543210 instance SuppressUnusedWarnings (($>@#@$$) a0123456789876543210) where suppressUnusedWarnings = snd (((,) (:$>@#@$$###)) ()) - type ($>@#@$$$) :: Nat -> Nat -> Nat - type family ($>@#@$$$) (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) :: Nat where + type ($>@#@$$$) :: Natural -> Natural -> Natural + type family ($>@#@$$$) (a0123456789876543210 :: Natural) (a0123456789876543210 :: Natural) :: Natural where ($>@#@$$$) a0123456789876543210 a0123456789876543210 = ($>) a0123456789876543210 a0123456789876543210 - type ($>) :: Nat -> Nat -> Nat - type family ($>) (a :: Nat) (a :: Nat) :: Nat where + type ($>) :: Natural -> Natural -> Natural + type family ($>) (a :: Natural) (a :: Natural) :: Natural where ($>) a_0123456789876543210 a_0123456789876543210 = Apply (Apply (+@#@$) a_0123456789876543210) a_0123456789876543210 (%$>) :: - forall (t :: Nat) (t :: Nat). - Sing t -> Sing t -> Sing (Apply (Apply ($>@#@$) t) t :: Nat) + forall (t :: Natural) (t :: Natural). Sing t + -> Sing t + -> Sing (Apply (Apply ($>@#@$) t) t :: Natural) (%$>) (sA_0123456789876543210 :: Sing a_0123456789876543210) (sA_0123456789876543210 :: Sing a_0123456789876543210) = (applySing ((applySing ((singFun2 @(+@#@$)) (%+))) sA_0123456789876543210)) sA_0123456789876543210 - instance SingI (($>@#@$) :: (~>) Nat ((~>) Nat Nat)) where + instance SingI (($>@#@$) :: (~>) Natural ((~>) Natural Natural)) where sing = (singFun2 @($>@#@$)) (%$>) instance SingI d => - SingI (($>@#@$$) (d :: Nat) :: (~>) Nat Nat) where - sing = (singFun1 @(($>@#@$$) (d :: Nat))) ((%$>) (sing @d)) + SingI (($>@#@$$) (d :: Natural) :: (~>) Natural Natural) where + sing = (singFun1 @(($>@#@$$) (d :: Natural))) ((%$>) (sing @d)) + instance SingI1 (($>@#@$$) :: Natural + -> (~>) Natural Natural) where + liftSing (s :: Sing (d :: Natural)) + = (singFun1 @(($>@#@$$) (d :: Natural))) ((%$>) s) diff --git a/tests/compile-and-dump/Singletons/T172.hs b/tests/compile-and-dump/Singletons/T172.hs --- a/tests/compile-and-dump/Singletons/T172.hs +++ b/tests/compile-and-dump/Singletons/T172.hs @@ -13,6 +13,6 @@ import Prelude.Singletons $(singletonsOnly [d| - ($>) :: Nat -> Nat -> Nat + ($>) :: Natural -> Natural -> Natural ($>) = (+) |]) diff --git a/tests/compile-and-dump/Singletons/T175.golden b/tests/compile-and-dump/Singletons/T175.golden --- a/tests/compile-and-dump/Singletons/T175.golden +++ b/tests/compile-and-dump/Singletons/T175.golden @@ -28,7 +28,7 @@ type family BazSym0 :: a where BazSym0 = Baz class PFoo a where - type Baz :: a + type family Baz :: a type Quux1Sym0 :: forall a. a type family Quux1Sym0 :: a where Quux1Sym0 = Quux1 @@ -39,7 +39,7 @@ type family Quux1_0123456789876543210Sym0 :: a where Quux1_0123456789876543210Sym0 = Quux1_0123456789876543210 class PBar1 a where - type Quux1 :: a + type family Quux1 :: a type Quux1 = Quux1_0123456789876543210Sym0 class PBar2 a sQuux2 :: forall a. SBar2 a => Sing (Quux2Sym0 :: a) diff --git a/tests/compile-and-dump/Singletons/T176.golden b/tests/compile-and-dump/Singletons/T176.golden --- a/tests/compile-and-dump/Singletons/T176.golden +++ b/tests/compile-and-dump/Singletons/T176.golden @@ -95,8 +95,8 @@ type family Baz1Sym0 :: a where Baz1Sym0 = Baz1 class PFoo1 a where - type Bar1 (arg :: a) (arg :: (~>) a b) :: b - type Baz1 :: a + type family Bar1 (arg :: a) (arg :: (~>) a b) :: b + type family Baz1 :: a type Bar2Sym0 :: forall a b. (~>) a ((~>) b b) data Bar2Sym0 :: (~>) a ((~>) b b) where @@ -120,38 +120,38 @@ type family Baz2Sym0 :: a where Baz2Sym0 = Baz2 class PFoo2 a where - type Bar2 (arg :: a) (arg :: b) :: b - type Baz2 :: a + type family Bar2 (arg :: a) (arg :: b) :: b + type family Baz2 :: a sQuux2 :: - forall a (t :: a). - SFoo2 a => Sing t -> Sing (Apply Quux2Sym0 t :: a) + forall a (t :: a). SFoo2 a => + Sing t -> Sing (Apply Quux2Sym0 t :: a) sQuux1 :: - forall a (t :: a). - SFoo1 a => Sing t -> Sing (Apply Quux1Sym0 t :: a) + forall a (t :: a). SFoo1 a => + Sing t -> Sing (Apply Quux1Sym0 t :: a) sQuux2 (sX :: Sing x) = (applySing ((applySing ((singFun2 @Bar2Sym0) sBar2)) sX)) sBaz2 sQuux1 (sX :: Sing x) = (applySing ((applySing ((singFun2 @Bar1Sym0) sBar1)) sX)) ((singFun1 @(Apply Lambda_0123456789876543210Sym0 x)) (\ sArg_0123456789876543210 - -> case sArg_0123456789876543210 of { + -> case sArg_0123456789876543210 of (_ :: Sing arg_0123456789876543210) -> (id @(Sing (Case_0123456789876543210 arg_0123456789876543210 x arg_0123456789876543210))) - (case sArg_0123456789876543210 of { _ -> sBaz1 }) })) + (case sArg_0123456789876543210 of _ -> sBaz1))) instance SFoo2 a => SingI (Quux2Sym0 :: (~>) a a) where sing = (singFun1 @Quux2Sym0) sQuux2 instance SFoo1 a => SingI (Quux1Sym0 :: (~>) a a) where sing = (singFun1 @Quux1Sym0) sQuux1 class SFoo1 a where sBar1 :: - forall b (t :: a) (t :: (~>) a b). - Sing t -> Sing t -> Sing (Apply (Apply Bar1Sym0 t) t :: b) + forall b (t :: a) (t :: (~>) a b). Sing t + -> Sing t -> Sing (Apply (Apply Bar1Sym0 t) t :: b) sBaz1 :: Sing (Baz1Sym0 :: a) class SFoo2 a where sBar2 :: - forall b (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Bar2Sym0 t) t :: b) + forall b (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply Bar2Sym0 t) t :: b) sBaz2 :: Sing (Baz2Sym0 :: a) instance SFoo1 a => SingI (Bar1Sym0 :: (~>) a ((~>) ((~>) a b) b)) where @@ -159,8 +159,15 @@ instance (SFoo1 a, SingI d) => SingI (Bar1Sym1 (d :: a) :: (~>) ((~>) a b) b) where sing = (singFun1 @(Bar1Sym1 (d :: a))) (sBar1 (sing @d)) + instance SFoo1 a => + SingI1 (Bar1Sym1 :: a -> (~>) ((~>) a b) b) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Bar1Sym1 (d :: a))) (sBar1 s) instance SFoo2 a => SingI (Bar2Sym0 :: (~>) a ((~>) b b)) where sing = (singFun2 @Bar2Sym0) sBar2 instance (SFoo2 a, SingI d) => SingI (Bar2Sym1 (d :: a) :: (~>) b b) where sing = (singFun1 @(Bar2Sym1 (d :: a))) (sBar2 (sing @d)) + instance SFoo2 a => SingI1 (Bar2Sym1 :: a -> (~>) b b) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Bar2Sym1 (d :: a))) (sBar2 s) diff --git a/tests/compile-and-dump/Singletons/T178.golden b/tests/compile-and-dump/Singletons/T178.golden --- a/tests/compile-and-dump/Singletons/T178.golden +++ b/tests/compile-and-dump/Singletons/T178.golden @@ -99,14 +99,14 @@ Compare_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Compare_0123456789876543210 a0123456789876543210 a0123456789876543210 instance POrd Occ where type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a - type ShowsPrec_0123456789876543210 :: Nat + type ShowsPrec_0123456789876543210 :: Natural -> Occ -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210 (a :: Nat) (a :: Occ) (a :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210 (a :: Natural) (a :: Occ) (a :: Symbol) :: Symbol where ShowsPrec_0123456789876543210 _ Str a_0123456789876543210 = Apply (Apply ShowStringSym0 "Str") a_0123456789876543210 ShowsPrec_0123456789876543210 _ Opt a_0123456789876543210 = Apply (Apply ShowStringSym0 "Opt") a_0123456789876543210 ShowsPrec_0123456789876543210 _ Many a_0123456789876543210 = Apply (Apply ShowStringSym0 "Many") a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) Nat ((~>) Occ ((~>) Symbol Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) Nat ((~>) Occ ((~>) Symbol Symbol)) + type ShowsPrec_0123456789876543210Sym0 :: (~>) Natural ((~>) Occ ((~>) Symbol Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) Natural ((~>) Occ ((~>) Symbol Symbol)) where ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => ShowsPrec_0123456789876543210Sym0 a0123456789876543210 @@ -114,9 +114,9 @@ instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: Nat + type ShowsPrec_0123456789876543210Sym1 :: Natural -> (~>) Occ ((~>) Symbol Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Occ ((~>) Symbol Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: Natural) :: (~>) Occ ((~>) Symbol Symbol) where ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -124,9 +124,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: Nat + type ShowsPrec_0123456789876543210Sym2 :: Natural -> Occ -> (~>) Symbol Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Occ) :: (~>) Symbol Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: Natural) (a0123456789876543210 :: Occ) :: (~>) Symbol Symbol where ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -134,9 +134,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: Nat + type ShowsPrec_0123456789876543210Sym3 :: Natural -> Occ -> Symbol -> Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Occ) (a0123456789876543210 :: Symbol) :: Symbol where + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: Natural) (a0123456789876543210 :: Occ) (a0123456789876543210 :: Symbol) :: Symbol where ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow Occ where type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a @@ -158,11 +158,10 @@ toSing Many = SomeSing SMany instance SEq Occ where (%==) :: - forall (t1 :: Occ) (t2 :: Occ). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun Occ ((~>) Occ Bool) - -> GHC.Types.Type) t1) t2) + forall (t1 :: Occ) (t2 :: Occ). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun Occ ((~>) Occ Bool) + -> GHC.Types.Type) t1) t2) (%==) SStr SStr = STrue (%==) SStr SOpt = SFalse (%==) SStr SMany = SFalse @@ -174,11 +173,10 @@ (%==) SMany SMany = STrue instance SOrd Occ where sCompare :: - forall (t1 :: Occ) (t2 :: Occ). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (CompareSym0 :: TyFun Occ ((~>) Occ Ordering) - -> GHC.Types.Type) t1) t2) + forall (t1 :: Occ) (t2 :: Occ). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (CompareSym0 :: TyFun Occ ((~>) Occ Ordering) + -> GHC.Types.Type) t1) t2) sCompare SStr SStr = (applySing ((applySing @@ -208,12 +206,11 @@ sCompare SMany SOpt = SGT instance SShow Occ where sShowsPrec :: - forall (t1 :: Nat) (t2 :: Occ) (t3 :: Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun Nat ((~>) Occ ((~>) Symbol Symbol)) - -> GHC.Types.Type) t1) t2) t3) + forall (t1 :: Natural) (t2 :: Occ) (t3 :: Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun Natural ((~>) Occ ((~>) Symbol Symbol)) + -> GHC.Types.Type) t1) t2) t3) sShowsPrec _ SStr @@ -240,13 +237,13 @@ sA_0123456789876543210 instance SDecide Occ where (%~) SStr SStr = Proved Refl - (%~) SStr SOpt = Disproved (\ x -> case x of) - (%~) SStr SMany = Disproved (\ x -> case x of) - (%~) SOpt SStr = Disproved (\ x -> case x of) + (%~) SStr SOpt = Disproved (\ x -> case x of {}) + (%~) SStr SMany = Disproved (\ x -> case x of {}) + (%~) SOpt SStr = Disproved (\ x -> case x of {}) (%~) SOpt SOpt = Proved Refl - (%~) SOpt SMany = Disproved (\ x -> case x of) - (%~) SMany SStr = Disproved (\ x -> case x of) - (%~) SMany SOpt = Disproved (\ x -> case x of) + (%~) SOpt SMany = Disproved (\ x -> case x of {}) + (%~) SMany SStr = Disproved (\ x -> case x of {}) + (%~) SMany SOpt = Disproved (\ x -> case x of {}) (%~) SMany SMany = Proved Refl instance Data.Type.Equality.TestEquality (SOcc :: Occ -> GHC.Types.Type) where diff --git a/tests/compile-and-dump/Singletons/T183.golden b/tests/compile-and-dump/Singletons/T183.golden --- a/tests/compile-and-dump/Singletons/T183.golden +++ b/tests/compile-and-dump/Singletons/T183.golden @@ -3,7 +3,7 @@ [d| f1 (x :: Maybe Bool) = (x :: Maybe Bool) f2 (x :: Maybe a) = (x :: Maybe a) f3 (Just a :: Maybe Bool) = "hi" - g x = case Just x of { (Just y :: Maybe Bool) -> (y :: Bool) } + g x = case Just x of (Just y :: Maybe Bool) -> (y :: Bool) foo1 :: Maybe a -> a foo1 (Just x :: Maybe a) = (x :: a) foo2, foo3 :: forall a. Maybe a -> a @@ -15,8 +15,8 @@ foo5 (Just (Just (x :: a) :: Maybe a) :: Maybe (Maybe a)) = Just (Just (x :: a) :: Maybe a) :: Maybe (Maybe a) foo6 (Just x :: Maybe (Maybe a)) - = case x :: Maybe a of { - (Just (y :: a) :: Maybe a) -> Just (Just (y :: a) :: Maybe a) } + = case x :: Maybe a of + (Just (y :: a) :: Maybe a) -> Just (Just (y :: a) :: Maybe a) foo7 :: a -> b -> a foo7 (x :: a) (_ :: b) = (x :: a) foo8 :: forall a. Maybe a -> Maybe a @@ -32,7 +32,7 @@ f1 (x :: Maybe Bool) = x :: Maybe Bool f2 (x :: Maybe a) = x :: Maybe a f3 (Just a :: Maybe Bool) = "hi" - g x = case Just x of { (Just y :: Maybe Bool) -> y :: Bool } + g x = case Just x of (Just y :: Maybe Bool) -> y :: Bool foo1 :: Maybe a -> a foo1 (Just x :: Maybe a) = x :: a foo2 :: forall a. Maybe a -> a @@ -46,8 +46,8 @@ foo5 (Just (Just (x :: a) :: Maybe a) :: Maybe (Maybe a)) = Just (Just (x :: a) :: Maybe a) :: Maybe (Maybe a) foo6 (Just x :: Maybe (Maybe a)) - = case x :: Maybe a of { - (Just (y :: a) :: Maybe a) -> Just (Just (y :: a) :: Maybe a) } + = case x :: Maybe a of + (Just (y :: a) :: Maybe a) -> Just (Just (y :: a) :: Maybe a) foo7 :: a -> b -> a foo7 (x :: a) (_ :: b) = x :: a foo8 :: forall a. Maybe a -> Maybe a @@ -342,20 +342,20 @@ F1 (x :: Maybe Bool) = x :: Maybe Bool sFoo9 :: forall a (t :: a). Sing t -> Sing (Apply Foo9Sym0 t :: a) sFoo8 :: - forall a (t :: Maybe a). - Sing t -> Sing (Apply Foo8Sym0 t :: Maybe a) + forall a (t :: Maybe a). Sing t + -> Sing (Apply Foo8Sym0 t :: Maybe a) sFoo7 :: - forall a b (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo7Sym0 t) t :: a) + forall a b (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply Foo7Sym0 t) t :: a) sFoo6 :: - forall a (t :: Maybe (Maybe a)). - Sing t -> Sing (Apply Foo6Sym0 t :: Maybe (Maybe a)) + forall a (t :: Maybe (Maybe a)). Sing t + -> Sing (Apply Foo6Sym0 t :: Maybe (Maybe a)) sFoo5 :: - forall a (t :: Maybe (Maybe a)). - Sing t -> Sing (Apply Foo5Sym0 t :: Maybe (Maybe a)) + forall a (t :: Maybe (Maybe a)). Sing t + -> Sing (Apply Foo5Sym0 t :: Maybe (Maybe a)) sFoo4 :: - forall a b (t :: (a, b)). - Sing t -> Sing (Apply Foo4Sym0 t :: (b, a)) + forall a b (t :: (a, b)). Sing t + -> Sing (Apply Foo4Sym0 t :: (b, a)) sFoo3 :: forall a (t :: Maybe a). Sing t -> Sing (Apply Foo3Sym0 t :: a) sFoo2 :: @@ -367,26 +367,25 @@ sF2 :: forall arg. Sing arg -> Sing (Apply F2Sym0 arg) sF1 :: forall arg. Sing arg -> Sing (Apply F1Sym0 arg) sFoo9 (sX :: Sing x) - = case sX :: Sing x of { + = case sX :: Sing x of (_ :: Sing (x :: a)) -> let sG :: - forall b (t :: a) (t :: b). - Sing t - -> Sing t - -> Sing (Apply (Apply (Let0123456789876543210GSym1 x) t) t :: a) + forall b (t :: a) (t :: b). Sing t + -> Sing t + -> Sing (Apply (Apply (Let0123456789876543210GSym1 x) t) t :: a) sG (sY :: Sing y) _ = sY in (applySing ((applySing ((singFun2 @(Let0123456789876543210GSym1 x)) sG)) sX)) - STuple0 } + STuple0 sFoo8 (SJust (sWild_0123456789876543210 :: Sing wild_0123456789876543210)) = case ((,) (sWild_0123456789876543210 :: Sing wild_0123456789876543210)) (SJust (sWild_0123456789876543210 :: Sing wild_0123456789876543210)) - of { + of (,) (_ :: Sing (wild_0123456789876543210 :: a)) (_ :: Sing ('Just (wild_0123456789876543210 :: a) :: Maybe a)) -> let @@ -397,26 +396,26 @@ (sWild_0123456789876543210 :: Sing (wild_0123456789876543210 :: a)) :: Sing (Apply JustSym0 (wild_0123456789876543210 :: a) :: Maybe a) - in sX } + in sX sFoo8 SNothing - = case SNothing of { + = case SNothing of (_ :: Sing ('Nothing :: Maybe a)) -> let sX :: Sing @_ Let0123456789876543210XSym0 sX = SNothing :: Sing (NothingSym0 :: Maybe a) - in sX } + in sX sFoo7 (sX :: Sing x) (sWild_0123456789876543210 :: Sing wild_0123456789876543210) = case ((,) (sX :: Sing x)) (sWild_0123456789876543210 :: Sing wild_0123456789876543210) - of { + of (,) (_ :: Sing (x :: a)) (_ :: Sing (wild_0123456789876543210 :: b)) - -> sX :: Sing (x :: a) } + -> sX :: Sing (x :: a) sFoo6 (SJust (sX :: Sing x)) - = case SJust (sX :: Sing x) of { + = case SJust (sX :: Sing x) of (_ :: Sing ('Just x :: Maybe (Maybe a))) -> let sScrutinee_0123456789876543210 :: @@ -425,50 +424,50 @@ in (id @(Sing (Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x) :: Maybe (Maybe a)))) - (case sScrutinee_0123456789876543210 of { + (case sScrutinee_0123456789876543210 of SJust (sY :: Sing y) - -> case ((,) (sY :: Sing y)) (SJust (sY :: Sing y)) of { + -> case ((,) (sY :: Sing y)) (SJust (sY :: Sing y)) of (,) (_ :: Sing (y :: a)) (_ :: Sing ('Just (y :: a) :: Maybe a)) -> (applySing ((singFun1 @JustSym0) SJust)) ((applySing ((singFun1 @JustSym0) SJust)) (sY :: Sing (y :: a)) :: - Sing (Apply JustSym0 (y :: a) :: Maybe a)) } }) } + Sing (Apply JustSym0 (y :: a) :: Maybe a))) sFoo5 (SJust (SJust (sX :: Sing x))) = case (((,,) (sX :: Sing x)) (SJust (sX :: Sing x))) (SJust (SJust (sX :: Sing x))) - of { + of (,,) (_ :: Sing (x :: a)) (_ :: Sing ('Just (x :: a) :: Maybe a)) (_ :: Sing ('Just ('Just (x :: a) :: Maybe a) :: Maybe (Maybe a))) -> (applySing ((singFun1 @JustSym0) SJust)) ((applySing ((singFun1 @JustSym0) SJust)) (sX :: Sing (x :: a)) :: Sing (Apply JustSym0 (x :: a) :: Maybe a)) :: - Sing (Apply JustSym0 (Apply JustSym0 (x :: a) :: Maybe a) :: Maybe (Maybe a)) } + Sing (Apply JustSym0 (Apply JustSym0 (x :: a) :: Maybe a) :: Maybe (Maybe a)) sFoo4 (sA_0123456789876543210 :: Sing a_0123456789876543210) = (applySing ((singFun1 @(Apply Lambda_0123456789876543210Sym0 a_0123456789876543210)) (\ sArg_0123456789876543210 - -> case sArg_0123456789876543210 of { + -> case sArg_0123456789876543210 of (_ :: Sing arg_0123456789876543210) -> (id @(Sing (Case_0123456789876543210 arg_0123456789876543210 a_0123456789876543210 arg_0123456789876543210))) - (case sArg_0123456789876543210 of { + (case sArg_0123456789876543210 of STuple2 (sX :: Sing x) (sY :: Sing y) - -> case ((,) (sX :: Sing x)) (sY :: Sing y) of { + -> case ((,) (sX :: Sing x)) (sY :: Sing y) of (,) (_ :: Sing (x :: a)) (_ :: Sing (y :: b)) -> (applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) (sY :: Sing (y :: b)))) - (sX :: Sing (x :: a)) } }) }))) + (sX :: Sing (x :: a)))))) sA_0123456789876543210 sFoo3 (SJust (sX :: Sing x)) = sX :: Sing (x :: a) sFoo2 (SJust (sX :: Sing x)) - = case SJust (sX :: Sing x) of { - (_ :: Sing ('Just x :: Maybe a)) -> sX :: Sing (x :: a) } + = case SJust (sX :: Sing x) of + (_ :: Sing ('Just x :: Maybe a)) -> sX :: Sing (x :: a) sFoo1 (SJust (sX :: Sing x)) - = case SJust (sX :: Sing x) of { - (_ :: Sing ('Just x :: Maybe a)) -> sX :: Sing (x :: a) } + = case SJust (sX :: Sing x) of + (_ :: Sing ('Just x :: Maybe a)) -> sX :: Sing (x :: a) sG (sX :: Sing x) = let sScrutinee_0123456789876543210 :: @@ -478,19 +477,19 @@ in (id @(Sing (Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)))) - (case sScrutinee_0123456789876543210 of { + (case sScrutinee_0123456789876543210 of SJust (sY :: Sing y) - -> case SJust (sY :: Sing y) of { - (_ :: Sing ('Just y :: Maybe Bool)) -> sY :: Sing (y :: Bool) } }) + -> case SJust (sY :: Sing y) of + (_ :: Sing ('Just y :: Maybe Bool)) -> sY :: Sing (y :: Bool)) sF3 (SJust (sA :: Sing a)) - = case SJust (sA :: Sing a) of { - (_ :: Sing ('Just a :: Maybe Bool)) -> sing :: Sing "hi" } + = case SJust (sA :: Sing a) of + (_ :: Sing ('Just a :: Maybe Bool)) -> sing :: Sing "hi" sF2 (sX :: Sing x) - = case sX :: Sing x of { - (_ :: Sing (x :: Maybe a)) -> sX :: Sing (x :: Maybe a) } + = case sX :: Sing x of + (_ :: Sing (x :: Maybe a)) -> sX :: Sing (x :: Maybe a) sF1 (sX :: Sing x) - = case sX :: Sing x of { - (_ :: Sing (x :: Maybe Bool)) -> sX :: Sing (x :: Maybe Bool) } + = case sX :: Sing x of + (_ :: Sing (x :: Maybe Bool)) -> sX :: Sing (x :: Maybe Bool) instance SingI (Foo9Sym0 :: (~>) a a) where sing = (singFun1 @Foo9Sym0) sFoo9 instance SingI (Foo8Sym0 :: (~>) (Maybe a) (Maybe a)) where @@ -499,6 +498,9 @@ sing = (singFun2 @Foo7Sym0) sFoo7 instance SingI d => SingI (Foo7Sym1 (d :: a) :: (~>) b a) where sing = (singFun1 @(Foo7Sym1 (d :: a))) (sFoo7 (sing @d)) + instance SingI1 (Foo7Sym1 :: a -> (~>) b a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Foo7Sym1 (d :: a))) (sFoo7 s) instance SingI (Foo6Sym0 :: (~>) (Maybe (Maybe a)) (Maybe (Maybe a))) where sing = (singFun1 @Foo6Sym0) sFoo6 instance SingI (Foo5Sym0 :: (~>) (Maybe (Maybe a)) (Maybe (Maybe a))) where diff --git a/tests/compile-and-dump/Singletons/T184.golden b/tests/compile-and-dump/Singletons/T184.golden --- a/tests/compile-and-dump/Singletons/T184.golden +++ b/tests/compile-and-dump/Singletons/T184.golden @@ -346,41 +346,42 @@ sTrues :: forall (t :: [Bool]). Sing t -> Sing (Apply TruesSym0 t :: [Bool]) sCartProd :: - forall a b (t :: [a]) (t :: [b]). - Sing t - -> Sing t -> Sing (Apply (Apply CartProdSym0 t) t :: [(a, b)]) + forall a b (t :: [a]) (t :: [b]). Sing t + -> Sing t + -> Sing (Apply (Apply CartProdSym0 t) t :: [(a, b)]) sZip' :: - forall a b (t :: [a]) (t :: [b]). - Sing t -> Sing t -> Sing (Apply (Apply Zip'Sym0 t) t :: [(a, b)]) + forall a b (t :: [a]) (t :: [b]). Sing t + -> Sing t -> Sing (Apply (Apply Zip'Sym0 t) t :: [(a, b)]) sBoogie :: - forall a (t :: Maybe a) (t :: Maybe Bool). - Sing t -> Sing t -> Sing (Apply (Apply BoogieSym0 t) t :: Maybe a) + forall a (t :: Maybe a) (t :: Maybe Bool). Sing t + -> Sing t + -> Sing (Apply (Apply BoogieSym0 t) t :: Maybe a) sTrues (sXs :: Sing xs) = (applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sXs)) ((singFun1 @(Apply Lambda_0123456789876543210Sym0 xs)) (\ sX - -> case sX of { + -> case sX of (_ :: Sing x) -> (applySing ((applySing ((singFun2 @(>>@#@$)) (%>>))) ((applySing ((singFun1 @GuardSym0) sGuard)) sX))) - ((applySing ((singFun1 @ReturnSym0) sReturn)) sX) })) + ((applySing ((singFun1 @ReturnSym0) sReturn)) sX))) sCartProd (sXs :: Sing xs) (sYs :: Sing ys) = (applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sXs)) ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 xs) ys)) (\ sX - -> case sX of { + -> case sX of (_ :: Sing x) -> (applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sYs)) ((singFun1 @(Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) xs) ys)) (\ sY - -> case sY of { + -> case sY of (_ :: Sing y) -> (applySing ((singFun1 @ReturnSym0) sReturn)) ((applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sX)) - sY) })) })) + sY))))) sZip' (sXs :: Sing xs) (sYs :: Sing ys) = (applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) @@ -389,43 +390,42 @@ ((applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sXs)) ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 xs) ys)) (\ sX - -> case sX of { + -> case sX of (_ :: Sing x) - -> (applySing ((singFun1 @ReturnSym0) sReturn)) sX }))))) + -> (applySing ((singFun1 @ReturnSym0) sReturn)) sX))))) ((applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sYs)) ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 xs) ys)) (\ sY - -> case sY of { + -> case sY of (_ :: Sing y) - -> (applySing ((singFun1 @ReturnSym0) sReturn)) sY })))))) + -> (applySing ((singFun1 @ReturnSym0) sReturn)) sY)))))) ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 xs) ys)) (\ sArg_0123456789876543210 - -> case sArg_0123456789876543210 of { + -> case sArg_0123456789876543210 of (_ :: Sing arg_0123456789876543210) -> (id @(Sing (Case_0123456789876543210 arg_0123456789876543210 xs ys arg_0123456789876543210))) - (case sArg_0123456789876543210 of { + (case sArg_0123456789876543210 of STuple2 (sX :: Sing x) (sY :: Sing y) -> (applySing ((singFun1 @ReturnSym0) sReturn)) ((applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sX)) - sY) }) })) + sY)))) sBoogie (sMa :: Sing ma) (sMb :: Sing mb) = (applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sMa)) ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 ma) mb)) (\ sA - -> case sA of { + -> case sA of (_ :: Sing a) -> (applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sMb)) ((singFun1 @(Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) ma) mb)) (\ sB - -> case sB of { + -> case sB of (_ :: Sing b) -> (applySing ((applySing ((singFun2 @(>>@#@$)) (%>>))) ((applySing ((singFun1 @GuardSym0) sGuard)) sB))) - ((applySing ((singFun1 @ReturnSym0) sReturn)) - sA) })) })) + ((applySing ((singFun1 @ReturnSym0) sReturn)) sA))))) instance SingI (TruesSym0 :: (~>) [Bool] [Bool]) where sing = (singFun1 @TruesSym0) sTrues instance SingI (CartProdSym0 :: (~>) [a] ((~>) [b] [(a, b)])) where @@ -433,13 +433,23 @@ instance SingI d => SingI (CartProdSym1 (d :: [a]) :: (~>) [b] [(a, b)]) where sing = (singFun1 @(CartProdSym1 (d :: [a]))) (sCartProd (sing @d)) + instance SingI1 (CartProdSym1 :: [a] -> (~>) [b] [(a, b)]) where + liftSing (s :: Sing (d :: [a])) + = (singFun1 @(CartProdSym1 (d :: [a]))) (sCartProd s) instance SingI (Zip'Sym0 :: (~>) [a] ((~>) [b] [(a, b)])) where sing = (singFun2 @Zip'Sym0) sZip' instance SingI d => SingI (Zip'Sym1 (d :: [a]) :: (~>) [b] [(a, b)]) where sing = (singFun1 @(Zip'Sym1 (d :: [a]))) (sZip' (sing @d)) + instance SingI1 (Zip'Sym1 :: [a] -> (~>) [b] [(a, b)]) where + liftSing (s :: Sing (d :: [a])) + = (singFun1 @(Zip'Sym1 (d :: [a]))) (sZip' s) instance SingI (BoogieSym0 :: (~>) (Maybe a) ((~>) (Maybe Bool) (Maybe a))) where sing = (singFun2 @BoogieSym0) sBoogie instance SingI d => SingI (BoogieSym1 (d :: Maybe a) :: (~>) (Maybe Bool) (Maybe a)) where sing = (singFun1 @(BoogieSym1 (d :: Maybe a))) (sBoogie (sing @d)) + instance SingI1 (BoogieSym1 :: Maybe a + -> (~>) (Maybe Bool) (Maybe a)) where + liftSing (s :: Sing (d :: Maybe a)) + = (singFun1 @(BoogieSym1 (d :: Maybe a))) (sBoogie s) diff --git a/tests/compile-and-dump/Singletons/T187.golden b/tests/compile-and-dump/Singletons/T187.golden --- a/tests/compile-and-dump/Singletons/T187.golden +++ b/tests/compile-and-dump/Singletons/T187.golden @@ -65,26 +65,24 @@ type instance Sing @Empty = SEmpty instance SingKind Empty where type Demote Empty = Empty - fromSing x = case x of - toSing x = SomeSing (case x of) + fromSing x = case x of {} + toSing x = SomeSing (case x of {}) instance SEq Empty where (%==) :: - forall (t1 :: Empty) (t2 :: Empty). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun Empty ((~>) Empty Bool) - -> GHC.Types.Type) t1) t2) + forall (t1 :: Empty) (t2 :: Empty). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun Empty ((~>) Empty Bool) + -> GHC.Types.Type) t1) t2) (%==) _ _ = STrue instance SOrd Empty where sCompare :: - forall (t1 :: Empty) (t2 :: Empty). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (CompareSym0 :: TyFun Empty ((~>) Empty Ordering) - -> GHC.Types.Type) t1) t2) + forall (t1 :: Empty) (t2 :: Empty). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (CompareSym0 :: TyFun Empty ((~>) Empty Ordering) + -> GHC.Types.Type) t1) t2) sCompare _ _ = SEQ instance SDecide Empty where - (%~) x _ = Proved (case x of) + (%~) x _ = Proved (case x of {}) instance Data.Type.Equality.TestEquality (SEmpty :: Empty -> GHC.Types.Type) where Data.Type.Equality.testEquality diff --git a/tests/compile-and-dump/Singletons/T190.golden b/tests/compile-and-dump/Singletons/T190.golden --- a/tests/compile-and-dump/Singletons/T190.golden +++ b/tests/compile-and-dump/Singletons/T190.golden @@ -65,11 +65,11 @@ type family Case_0123456789876543210 n t where Case_0123456789876543210 n 'True = TSym0 Case_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument" - type ToEnum_0123456789876543210 :: GHC.Types.Nat -> T - type family ToEnum_0123456789876543210 (a :: GHC.Types.Nat) :: T where + type ToEnum_0123456789876543210 :: GHC.Num.Natural.Natural -> T + type family ToEnum_0123456789876543210 (a :: GHC.Num.Natural.Natural) :: T where ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0)) - type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat T - data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat T + type ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural T + data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural T where ToEnum_0123456789876543210Sym0KindInference :: SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) => ToEnum_0123456789876543210Sym0 a0123456789876543210 @@ -77,14 +77,14 @@ instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ()) - type ToEnum_0123456789876543210Sym1 :: GHC.Types.Nat -> T - type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: T where + type ToEnum_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> T + type family ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: T where ToEnum_0123456789876543210Sym1 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210 - type FromEnum_0123456789876543210 :: T -> GHC.Types.Nat - type family FromEnum_0123456789876543210 (a :: T) :: GHC.Types.Nat where + type FromEnum_0123456789876543210 :: T -> GHC.Num.Natural.Natural + type family FromEnum_0123456789876543210 (a :: T) :: GHC.Num.Natural.Natural where FromEnum_0123456789876543210 T = FromInteger 0 - type FromEnum_0123456789876543210Sym0 :: (~>) T GHC.Types.Nat - data FromEnum_0123456789876543210Sym0 :: (~>) T GHC.Types.Nat + type FromEnum_0123456789876543210Sym0 :: (~>) T GHC.Num.Natural.Natural + data FromEnum_0123456789876543210Sym0 :: (~>) T GHC.Num.Natural.Natural where FromEnum_0123456789876543210Sym0KindInference :: SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) => FromEnum_0123456789876543210Sym0 a0123456789876543210 @@ -92,8 +92,9 @@ instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ()) - type FromEnum_0123456789876543210Sym1 :: T -> GHC.Types.Nat - type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: T) :: GHC.Types.Nat where + type FromEnum_0123456789876543210Sym1 :: T + -> GHC.Num.Natural.Natural + type family FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: T) :: GHC.Num.Natural.Natural where FromEnum_0123456789876543210Sym1 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210 instance PEnum T where type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a @@ -113,12 +114,12 @@ instance PBounded T where type MinBound = MinBound_0123456789876543210Sym0 type MaxBound = MaxBound_0123456789876543210Sym0 - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural -> T -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: T) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: T) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where ShowsPrec_0123456789876543210 _ T a_0123456789876543210 = Apply (Apply ShowStringSym0 "T") a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol)) where ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => ShowsPrec_0123456789876543210Sym0 a0123456789876543210 @@ -126,9 +127,9 @@ instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> (~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol) where ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -136,9 +137,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural -> T -> (~>) GHC.Types.Symbol GHC.Types.Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: T) :: (~>) GHC.Types.Symbol GHC.Types.Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: T) :: (~>) GHC.Types.Symbol GHC.Types.Symbol where ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -146,9 +147,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural -> T -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: T) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: T) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow T where type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a @@ -160,19 +161,17 @@ toSing T = SomeSing ST instance SEq T where (%==) :: - forall (t1 :: T) (t2 :: T). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun T ((~>) T Bool) - -> GHC.Types.Type) t1) t2) + forall (t1 :: T) (t2 :: T). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun T ((~>) T Bool) + -> GHC.Types.Type) t1) t2) (%==) ST ST = STrue instance SOrd T where sCompare :: - forall (t1 :: T) (t2 :: T). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (CompareSym0 :: TyFun T ((~>) T Ordering) - -> GHC.Types.Type) t1) t2) + forall (t1 :: T) (t2 :: T). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (CompareSym0 :: TyFun T ((~>) T Ordering) + -> GHC.Types.Type) t1) t2) sCompare ST ST = (applySing ((applySing @@ -182,15 +181,13 @@ SNil instance SEnum T where sToEnum :: - forall (t :: GHC.Types.Nat). - Sing t - -> Sing (Apply (Data.Singletons.Base.Enum.ToEnumSym0 :: TyFun GHC.Types.Nat T - -> GHC.Types.Type) t) + forall (t :: GHC.Num.Natural.Natural). Sing t + -> Sing (Apply (Data.Singletons.Base.Enum.ToEnumSym0 :: TyFun GHC.Num.Natural.Natural T + -> GHC.Types.Type) t) sFromEnum :: - forall (t :: T). - Sing t - -> Sing (Apply (Data.Singletons.Base.Enum.FromEnumSym0 :: TyFun T GHC.Types.Nat - -> GHC.Types.Type) t) + forall (t :: T). Sing t + -> Sing (Apply (Data.Singletons.Base.Enum.FromEnumSym0 :: TyFun T GHC.Num.Natural.Natural + -> GHC.Types.Type) t) sToEnum (sN :: Sing n) = (id @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0))))) @@ -208,12 +205,13 @@ sMaxBound = ST instance SShow T where sShowsPrec :: - forall (t1 :: GHC.Types.Nat) (t2 :: T) (t3 :: GHC.Types.Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - -> GHC.Types.Type) t1) t2) t3) + forall (t1 :: GHC.Num.Natural.Natural) + (t2 :: T) + (t3 :: GHC.Types.Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + -> GHC.Types.Type) t1) t2) t3) sShowsPrec _ ST diff --git a/tests/compile-and-dump/Singletons/T197.golden b/tests/compile-and-dump/Singletons/T197.golden --- a/tests/compile-and-dump/Singletons/T197.golden +++ b/tests/compile-and-dump/Singletons/T197.golden @@ -35,11 +35,14 @@ ($$:) _ _ = FalseSym0 infixl 5 %$$: (%$$:) :: - forall (t :: Bool) (t :: Bool). - Sing t -> Sing t -> Sing (Apply (Apply ($$:@#@$) t) t :: Bool) + forall (t :: Bool) (t :: Bool). Sing t + -> Sing t -> Sing (Apply (Apply ($$:@#@$) t) t :: Bool) (%$$:) _ _ = SFalse instance SingI (($$:@#@$) :: (~>) Bool ((~>) Bool Bool)) where sing = (singFun2 @($$:@#@$)) (%$$:) instance SingI d => SingI (($$:@#@$$) (d :: Bool) :: (~>) Bool Bool) where sing = (singFun1 @(($$:@#@$$) (d :: Bool))) ((%$$:) (sing @d)) + instance SingI1 (($$:@#@$$) :: Bool -> (~>) Bool Bool) where + liftSing (s :: Sing (d :: Bool)) + = (singFun1 @(($$:@#@$$) (d :: Bool))) ((%$$:) s) diff --git a/tests/compile-and-dump/Singletons/T197b.golden b/tests/compile-and-dump/Singletons/T197b.golden --- a/tests/compile-and-dump/Singletons/T197b.golden +++ b/tests/compile-and-dump/Singletons/T197b.golden @@ -60,8 +60,8 @@ type Demote ((:*:) a b) = (:*:) (Demote a) (Demote b) fromSing ((:%*:) b b) = ((:*:) (fromSing b)) (fromSing b) toSing ((:*:) (b :: Demote a) (b :: Demote b)) - = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of { - (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%*:) c) c) } + = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of + (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%*:) c) c) data SPair :: forall a b. Pair a b -> GHC.Types.Type where SMkPair :: forall a b (n :: a) (n :: b). @@ -71,21 +71,35 @@ type Demote (Pair a b) = Pair (Demote a) (Demote b) fromSing (SMkPair b b) = (MkPair (fromSing b)) (fromSing b) toSing (MkPair (b :: Demote a) (b :: Demote b)) - = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkPair c) c) } + = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkPair c) c) instance (SingI n, SingI n) => SingI ((:*:) (n :: a) (n :: b)) where sing = ((:%*:) sing) sing + instance SingI n => SingI1 ((:*:) (n :: a)) where + liftSing = (:%*:) sing + instance SingI2 (:*:) where + liftSing2 = (:%*:) instance SingI ((:*:@#@$) :: (~>) a ((~>) b ((:*:) a b))) where sing = (singFun2 @(:*:@#@$)) (:%*:) instance SingI d => SingI ((:*:@#@$$) (d :: a) :: (~>) b ((:*:) a b)) where sing = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) (sing @d)) + instance SingI1 ((:*:@#@$$) :: a -> (~>) b ((:*:) a b)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) s) instance (SingI n, SingI n) => SingI (MkPair (n :: a) (n :: b)) where sing = (SMkPair sing) sing + instance SingI n => SingI1 (MkPair (n :: a)) where + liftSing = SMkPair sing + instance SingI2 MkPair where + liftSing2 = SMkPair instance SingI (MkPairSym0 :: (~>) a ((~>) b (Pair a b))) where sing = (singFun2 @MkPairSym0) SMkPair instance SingI d => SingI (MkPairSym1 (d :: a) :: (~>) b (Pair a b)) where sing = (singFun1 @(MkPairSym1 (d :: a))) (SMkPair (sing @d)) + instance SingI1 (MkPairSym1 :: a -> (~>) b (Pair a b)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(MkPairSym1 (d :: a))) (SMkPair s) diff --git a/tests/compile-and-dump/Singletons/T200.golden b/tests/compile-and-dump/Singletons/T200.golden --- a/tests/compile-and-dump/Singletons/T200.golden +++ b/tests/compile-and-dump/Singletons/T200.golden @@ -112,13 +112,13 @@ type family ($$:) (a :: ErrorMessage) (a :: ErrorMessage) :: ErrorMessage where ($$:) x y = Apply (Apply (:$$:@#@$) x) y (%<>:) :: - forall (t :: ErrorMessage) (t :: ErrorMessage). - Sing t - -> Sing t -> Sing (Apply (Apply (<>:@#@$) t) t :: ErrorMessage) + forall (t :: ErrorMessage) (t :: ErrorMessage). Sing t + -> Sing t + -> Sing (Apply (Apply (<>:@#@$) t) t :: ErrorMessage) (%$$:) :: - forall (t :: ErrorMessage) (t :: ErrorMessage). - Sing t - -> Sing t -> Sing (Apply (Apply ($$:@#@$) t) t :: ErrorMessage) + forall (t :: ErrorMessage) (t :: ErrorMessage). Sing t + -> Sing t + -> Sing (Apply (Apply ($$:@#@$) t) t :: ErrorMessage) (%<>:) (sX :: Sing x) (sY :: Sing y) = (applySing ((applySing ((singFun2 @(:<>:@#@$)) (:%<>:))) sX)) sY (%$$:) (sX :: Sing x) (sY :: Sing y) @@ -129,12 +129,20 @@ SingI ((<>:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where sing = (singFun1 @((<>:@#@$$) (d :: ErrorMessage))) ((%<>:) (sing @d)) + instance SingI1 ((<>:@#@$$) :: ErrorMessage + -> (~>) ErrorMessage ErrorMessage) where + liftSing (s :: Sing (d :: ErrorMessage)) + = (singFun1 @((<>:@#@$$) (d :: ErrorMessage))) ((%<>:) s) instance SingI (($$:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where sing = (singFun2 @($$:@#@$)) (%$$:) instance SingI d => SingI (($$:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where sing = (singFun1 @(($$:@#@$$) (d :: ErrorMessage))) ((%$$:) (sing @d)) + instance SingI1 (($$:@#@$$) :: ErrorMessage + -> (~>) ErrorMessage ErrorMessage) where + liftSing (s :: Sing (d :: ErrorMessage)) + = (singFun1 @(($$:@#@$$) (d :: ErrorMessage))) ((%$$:) s) data SErrorMessage :: ErrorMessage -> GHC.Types.Type where (:%$$:) :: forall (n :: ErrorMessage) (n :: ErrorMessage). @@ -154,37 +162,55 @@ = case ((,) (toSing b :: SomeSing ErrorMessage)) (toSing b :: SomeSing ErrorMessage) - of { - (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%$$:) c) c) } + of + (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%$$:) c) c) toSing ((:<>:) (b :: Demote ErrorMessage) (b :: Demote ErrorMessage)) = case ((,) (toSing b :: SomeSing ErrorMessage)) (toSing b :: SomeSing ErrorMessage) - of { - (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%<>:) c) c) } + of + (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%<>:) c) c) toSing (EM (b :: Demote [Bool])) - = case toSing b :: SomeSing [Bool] of { - SomeSing c -> SomeSing (SEM c) } + = case toSing b :: SomeSing [Bool] of + SomeSing c -> SomeSing (SEM c) instance (SingI n, SingI n) => SingI ((:$$:) (n :: ErrorMessage) (n :: ErrorMessage)) where sing = ((:%$$:) sing) sing + instance SingI n => SingI1 ((:$$:) (n :: ErrorMessage)) where + liftSing = (:%$$:) sing + instance SingI2 (:$$:) where + liftSing2 = (:%$$:) instance SingI ((:$$:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where sing = (singFun2 @(:$$:@#@$)) (:%$$:) instance SingI d => SingI ((:$$:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where sing = (singFun1 @((:$$:@#@$$) (d :: ErrorMessage))) ((:%$$:) (sing @d)) + instance SingI1 ((:$$:@#@$$) :: ErrorMessage + -> (~>) ErrorMessage ErrorMessage) where + liftSing (s :: Sing (d :: ErrorMessage)) + = (singFun1 @((:$$:@#@$$) (d :: ErrorMessage))) ((:%$$:) s) instance (SingI n, SingI n) => SingI ((:<>:) (n :: ErrorMessage) (n :: ErrorMessage)) where sing = ((:%<>:) sing) sing + instance SingI n => SingI1 ((:<>:) (n :: ErrorMessage)) where + liftSing = (:%<>:) sing + instance SingI2 (:<>:) where + liftSing2 = (:%<>:) instance SingI ((:<>:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where sing = (singFun2 @(:<>:@#@$)) (:%<>:) instance SingI d => SingI ((:<>:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where sing = (singFun1 @((:<>:@#@$$) (d :: ErrorMessage))) ((:%<>:) (sing @d)) + instance SingI1 ((:<>:@#@$$) :: ErrorMessage + -> (~>) ErrorMessage ErrorMessage) where + liftSing (s :: Sing (d :: ErrorMessage)) + = (singFun1 @((:<>:@#@$$) (d :: ErrorMessage))) ((:%<>:) s) instance SingI n => SingI (EM (n :: [Bool])) where sing = SEM sing + instance SingI1 EM where + liftSing = SEM instance SingI (EMSym0 :: (~>) [Bool] ErrorMessage) where sing = (singFun1 @EMSym0) SEM diff --git a/tests/compile-and-dump/Singletons/T204.golden b/tests/compile-and-dump/Singletons/T204.golden --- a/tests/compile-and-dump/Singletons/T204.golden +++ b/tests/compile-and-dump/Singletons/T204.golden @@ -62,8 +62,8 @@ type Demote (Ratio1 a) = Ratio1 (Demote a) fromSing ((:^%) b b) = ((:%) (fromSing b)) (fromSing b) toSing ((:%) (b :: Demote a) (b :: Demote a)) - = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of { - (,) (SomeSing c) (SomeSing c) -> SomeSing (((:^%) c) c) } + = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of + (,) (SomeSing c) (SomeSing c) -> SomeSing (((:^%) c) c) data SRatio2 :: forall a. Ratio2 a -> GHC.Types.Type where (:^%%) :: forall a (n :: a) (n :: a). @@ -73,20 +73,34 @@ type Demote (Ratio2 a) = Ratio2 (Demote a) fromSing ((:^%%) b b) = ((:%%) (fromSing b)) (fromSing b) toSing ((:%%) (b :: Demote a) (b :: Demote a)) - = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of { - (,) (SomeSing c) (SomeSing c) -> SomeSing (((:^%%) c) c) } + = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of + (,) (SomeSing c) (SomeSing c) -> SomeSing (((:^%%) c) c) instance (SingI n, SingI n) => SingI ((:%) (n :: a) (n :: a)) where sing = ((:^%) sing) sing + instance SingI n => SingI1 ((:%) (n :: a)) where + liftSing = (:^%) sing + instance SingI2 (:%) where + liftSing2 = (:^%) instance SingI ((:%@#@$) :: (~>) a ((~>) a (Ratio1 a))) where sing = (singFun2 @(:%@#@$)) (:^%) instance SingI d => SingI ((:%@#@$$) (d :: a) :: (~>) a (Ratio1 a)) where sing = (singFun1 @((:%@#@$$) (d :: a))) ((:^%) (sing @d)) + instance SingI1 ((:%@#@$$) :: a -> (~>) a (Ratio1 a)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @((:%@#@$$) (d :: a))) ((:^%) s) instance (SingI n, SingI n) => SingI ((:%%) (n :: a) (n :: a)) where sing = ((:^%%) sing) sing + instance SingI n => SingI1 ((:%%) (n :: a)) where + liftSing = (:^%%) sing + instance SingI2 (:%%) where + liftSing2 = (:^%%) instance SingI ((:%%@#@$) :: (~>) a ((~>) a (Ratio2 a))) where sing = (singFun2 @(:%%@#@$)) (:^%%) instance SingI d => SingI ((:%%@#@$$) (d :: a) :: (~>) a (Ratio2 a)) where sing = (singFun1 @((:%%@#@$$) (d :: a))) ((:^%%) (sing @d)) + instance SingI1 ((:%%@#@$$) :: a -> (~>) a (Ratio2 a)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @((:%%@#@$$) (d :: a))) ((:^%%) s) diff --git a/tests/compile-and-dump/Singletons/T209.golden b/tests/compile-and-dump/Singletons/T209.golden --- a/tests/compile-and-dump/Singletons/T209.golden +++ b/tests/compile-and-dump/Singletons/T209.golden @@ -54,20 +54,29 @@ instance PC Bool Hm instance PC a (Maybe a) sM :: - forall a b (t :: a) (t :: b) (t :: Bool). - Sing t - -> Sing t - -> Sing t -> Sing (Apply (Apply (Apply MSym0 t) t) t :: Bool) + forall a b (t :: a) (t :: b) (t :: Bool). Sing t + -> Sing t + -> Sing t + -> Sing (Apply (Apply (Apply MSym0 t) t) t :: Bool) sM _ _ (sX :: Sing x) = sX instance SingI (MSym0 :: (~>) a ((~>) b ((~>) Bool Bool))) where sing = (singFun3 @MSym0) sM instance SingI d => SingI (MSym1 (d :: a) :: (~>) b ((~>) Bool Bool)) where sing = (singFun2 @(MSym1 (d :: a))) (sM (sing @d)) + instance SingI1 (MSym1 :: a -> (~>) b ((~>) Bool Bool)) where + liftSing (s :: Sing (d :: a)) = (singFun2 @(MSym1 (d :: a))) (sM s) instance (SingI d, SingI d) => SingI (MSym2 (d :: a) (d :: b) :: (~>) Bool Bool) where sing = (singFun1 @(MSym2 (d :: a) (d :: b))) ((sM (sing @d)) (sing @d)) + instance SingI d => + SingI1 (MSym2 (d :: a) :: b -> (~>) Bool Bool) where + liftSing (s :: Sing (d :: b)) + = (singFun1 @(MSym2 (d :: a) (d :: b))) ((sM (sing @d)) s) + instance SingI2 (MSym2 :: a -> b -> (~>) Bool Bool) where + liftSing2 (s :: Sing (d :: a)) (s :: Sing (d :: b)) + = (singFun1 @(MSym2 (d :: a) (d :: b))) ((sM s) s) data SHm :: Hm -> GHC.Types.Type where SHm :: SHm (Hm :: Hm) type instance Sing @Hm = SHm instance SingKind Hm where diff --git a/tests/compile-and-dump/Singletons/T216.golden b/tests/compile-and-dump/Singletons/T216.golden --- a/tests/compile-and-dump/Singletons/T216.golden +++ b/tests/compile-and-dump/Singletons/T216.golden @@ -11,12 +11,12 @@ data MyProxySym1 (k0123456789876543210 :: Type) :: (~>) k0123456789876543210 Type where MyProxySym1KindInference :: SameKind (Apply (MyProxySym1 k0123456789876543210) arg) (MyProxySym2 k0123456789876543210 arg) => - MyProxySym1 k0123456789876543210 e - type instance Apply (MyProxySym1 k0123456789876543210) e = MyProxy k0123456789876543210 e + MyProxySym1 k0123456789876543210 e0123456789876543210 + type instance Apply (MyProxySym1 k0123456789876543210) e0123456789876543210 = MyProxy k0123456789876543210 e0123456789876543210 instance SuppressUnusedWarnings (MyProxySym1 k0123456789876543210) where suppressUnusedWarnings = snd (((,) MyProxySym1KindInference) ()) - type family MyProxySym2 (k0123456789876543210 :: Type) (e :: k0123456789876543210) :: Type where - MyProxySym2 k0123456789876543210 e = MyProxy k0123456789876543210 e + type family MyProxySym2 (k0123456789876543210 :: Type) (e0123456789876543210 :: k0123456789876543210) :: Type where + MyProxySym2 k0123456789876543210 e0123456789876543210 = MyProxy k0123456789876543210 e0123456789876543210 data SymmetrySym0 :: (~>) t0123456789876543210 ((~>) t0123456789876543210 ((~>) ((:~:) a0123456789876543210 y0123456789876543210) Type)) where SymmetrySym0KindInference :: SameKind (Apply SymmetrySym0 arg) (SymmetrySym1 arg) => @@ -34,9 +34,9 @@ data SymmetrySym2 (a0123456789876543210 :: t0123456789876543210) (y0123456789876543210 :: t0123456789876543210) :: (~>) ((:~:) a0123456789876543210 y0123456789876543210) Type where SymmetrySym2KindInference :: SameKind (Apply (SymmetrySym2 a0123456789876543210 y0123456789876543210) arg) (SymmetrySym3 a0123456789876543210 y0123456789876543210 arg) => - SymmetrySym2 a0123456789876543210 y0123456789876543210 e - type instance Apply (SymmetrySym2 a0123456789876543210 y0123456789876543210) e = Symmetry a0123456789876543210 y0123456789876543210 e + SymmetrySym2 a0123456789876543210 y0123456789876543210 e0123456789876543210 + type instance Apply (SymmetrySym2 a0123456789876543210 y0123456789876543210) e0123456789876543210 = Symmetry a0123456789876543210 y0123456789876543210 e0123456789876543210 instance SuppressUnusedWarnings (SymmetrySym2 a0123456789876543210 y0123456789876543210) where suppressUnusedWarnings = snd (((,) SymmetrySym2KindInference) ()) - type family SymmetrySym3 (a0123456789876543210 :: t0123456789876543210) (y0123456789876543210 :: t0123456789876543210) (e :: (:~:) a0123456789876543210 y0123456789876543210) :: Type where - SymmetrySym3 a0123456789876543210 y0123456789876543210 e = Symmetry a0123456789876543210 y0123456789876543210 e + type family SymmetrySym3 (a0123456789876543210 :: t0123456789876543210) (y0123456789876543210 :: t0123456789876543210) (e0123456789876543210 :: (:~:) a0123456789876543210 y0123456789876543210) :: Type where + SymmetrySym3 a0123456789876543210 y0123456789876543210 e0123456789876543210 = Symmetry a0123456789876543210 y0123456789876543210 e0123456789876543210 diff --git a/tests/compile-and-dump/Singletons/T249.golden b/tests/compile-and-dump/Singletons/T249.golden --- a/tests/compile-and-dump/Singletons/T249.golden +++ b/tests/compile-and-dump/Singletons/T249.golden @@ -49,8 +49,7 @@ type Demote (Foo1 a) = Foo1 (Demote a) fromSing (SMkFoo1 b) = MkFoo1 (fromSing b) toSing (MkFoo1 (b :: Demote a)) - = case toSing b :: SomeSing a of { - SomeSing c -> SomeSing (SMkFoo1 c) } + = case toSing b :: SomeSing a of SomeSing c -> SomeSing (SMkFoo1 c) data SFoo2 :: forall a. Foo2 a -> Type where SMkFoo2 :: forall x (n :: x). @@ -60,8 +59,7 @@ type Demote (Foo2 a) = Foo2 (Demote a) fromSing (SMkFoo2 b) = MkFoo2 (fromSing b) toSing (MkFoo2 (b :: Demote x)) - = case toSing b :: SomeSing x of { - SomeSing c -> SomeSing (SMkFoo2 c) } + = case toSing b :: SomeSing x of SomeSing c -> SomeSing (SMkFoo2 c) data SFoo3 :: forall a. Foo3 a -> Type where SMkFoo3 :: forall x (n :: x). @@ -71,17 +69,22 @@ type Demote (Foo3 a) = Foo3 (Demote a) fromSing (SMkFoo3 b) = MkFoo3 (fromSing b) toSing (MkFoo3 (b :: Demote x)) - = case toSing b :: SomeSing x of { - SomeSing c -> SomeSing (SMkFoo3 c) } + = case toSing b :: SomeSing x of SomeSing c -> SomeSing (SMkFoo3 c) instance SingI n => SingI (MkFoo1 (n :: a)) where sing = SMkFoo1 sing + instance SingI1 MkFoo1 where + liftSing = SMkFoo1 instance SingI (MkFoo1Sym0 :: (~>) a (Foo1 a)) where sing = (singFun1 @MkFoo1Sym0) SMkFoo1 instance SingI n => SingI (MkFoo2 (n :: x)) where sing = SMkFoo2 sing + instance SingI1 MkFoo2 where + liftSing = SMkFoo2 instance SingI (MkFoo2Sym0 :: (~>) x (Foo2 x)) where sing = (singFun1 @MkFoo2Sym0) SMkFoo2 instance SingI n => SingI (MkFoo3 (n :: x)) where sing = SMkFoo3 sing + instance SingI1 MkFoo3 where + liftSing = SMkFoo3 instance SingI (MkFoo3Sym0 :: (~>) x (Foo3 x)) where sing = (singFun1 @MkFoo3Sym0) SMkFoo3 diff --git a/tests/compile-and-dump/Singletons/T271.golden b/tests/compile-and-dump/Singletons/T271.golden --- a/tests/compile-and-dump/Singletons/T271.golden +++ b/tests/compile-and-dump/Singletons/T271.golden @@ -13,8 +13,8 @@ data Identity :: Type -> Type where Identity :: a -> Identity a deriving (Eq, Ord) - type ConstantSym0 :: forall (a :: Type) (b :: Type). - (~>) a (Constant (a :: Type) (b :: Type)) + type ConstantSym0 :: forall (a :: Type) + (b :: Type). (~>) a (Constant (a :: Type) (b :: Type)) data ConstantSym0 :: (~>) a (Constant (a :: Type) (b :: Type)) where ConstantSym0KindInference :: SameKind (Apply ConstantSym0 arg) (ConstantSym1 arg) => @@ -22,8 +22,8 @@ type instance Apply ConstantSym0 a0123456789876543210 = Constant a0123456789876543210 instance SuppressUnusedWarnings ConstantSym0 where suppressUnusedWarnings = snd (((,) ConstantSym0KindInference) ()) - type ConstantSym1 :: forall (a :: Type) (b :: Type). - a -> Constant (a :: Type) (b :: Type) + type ConstantSym1 :: forall (a :: Type) (b :: Type). a + -> Constant (a :: Type) (b :: Type) type family ConstantSym1 (a0123456789876543210 :: a) :: Constant (a :: Type) (b :: Type) where ConstantSym1 a0123456789876543210 = Constant a0123456789876543210 type IdentitySym0 :: (~>) a (Identity a) @@ -164,8 +164,8 @@ type Demote (Constant a b) = Constant (Demote a) (Demote b) fromSing (SConstant b) = Constant (fromSing b) toSing (Constant (b :: Demote a)) - = case toSing b :: SomeSing a of { - SomeSing c -> SomeSing (SConstant c) } + = case toSing b :: SomeSing a of + SomeSing c -> SomeSing (SConstant c) data SIdentity :: forall (a :: Type). Identity a -> Type where SIdentity :: forall a (n :: a). @@ -175,15 +175,14 @@ type Demote (Identity a) = Identity (Demote a) fromSing (SIdentity b) = Identity (fromSing b) toSing (Identity (b :: Demote a)) - = case toSing b :: SomeSing a of { - SomeSing c -> SomeSing (SIdentity c) } + = case toSing b :: SomeSing a of + SomeSing c -> SomeSing (SIdentity c) instance SEq a => SEq (Constant a b) where (%==) :: - forall (t1 :: Constant a b) (t2 :: Constant a b). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun (Constant a b) ((~>) (Constant a b) Bool) - -> Type) t1) t2) + forall (t1 :: Constant a b) (t2 :: Constant a b). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun (Constant a b) ((~>) (Constant a b) Bool) + -> Type) t1) t2) (%==) (SConstant (sA_0123456789876543210 :: Sing a_0123456789876543210)) (SConstant (sB_0123456789876543210 :: Sing b_0123456789876543210)) @@ -192,11 +191,10 @@ sB_0123456789876543210 instance SOrd a => SOrd (Constant a b) where sCompare :: - forall (t1 :: Constant a b) (t2 :: Constant a b). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (CompareSym0 :: TyFun (Constant a b) ((~>) (Constant a b) Ordering) - -> Type) t1) t2) + forall (t1 :: Constant a b) (t2 :: Constant a b). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (CompareSym0 :: TyFun (Constant a b) ((~>) (Constant a b) Ordering) + -> Type) t1) t2) sCompare (SConstant (sA_0123456789876543210 :: Sing a_0123456789876543210)) (SConstant (sB_0123456789876543210 :: Sing b_0123456789876543210)) @@ -214,11 +212,10 @@ SNil) instance SEq a => SEq (Identity a) where (%==) :: - forall (t1 :: Identity a) (t2 :: Identity a). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply ((==@#@$) :: TyFun (Identity a) ((~>) (Identity a) Bool) - -> Type) t1) t2) + forall (t1 :: Identity a) (t2 :: Identity a). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply ((==@#@$) :: TyFun (Identity a) ((~>) (Identity a) Bool) + -> Type) t1) t2) (%==) (SIdentity (sA_0123456789876543210 :: Sing a_0123456789876543210)) (SIdentity (sB_0123456789876543210 :: Sing b_0123456789876543210)) @@ -227,11 +224,10 @@ sB_0123456789876543210 instance SOrd a => SOrd (Identity a) where sCompare :: - forall (t1 :: Identity a) (t2 :: Identity a). - Sing t1 - -> Sing t2 - -> Sing (Apply (Apply (CompareSym0 :: TyFun (Identity a) ((~>) (Identity a) Ordering) - -> Type) t1) t2) + forall (t1 :: Identity a) (t2 :: Identity a). Sing t1 + -> Sing t2 + -> Sing (Apply (Apply (CompareSym0 :: TyFun (Identity a) ((~>) (Identity a) Ordering) + -> Type) t1) t2) sCompare (SIdentity (sA_0123456789876543210 :: Sing a_0123456789876543210)) (SIdentity (sB_0123456789876543210 :: Sing b_0123456789876543210)) @@ -252,7 +248,7 @@ = case ((%~) a) b of Proved Refl -> Proved Refl Disproved contra - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) instance SDecide a => Data.Type.Equality.TestEquality (SConstant :: Constant a b -> Type) where @@ -268,7 +264,7 @@ = case ((%~) a) b of Proved Refl -> Proved Refl Disproved contra - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) + -> Disproved (\ refl -> case refl of Refl -> contra Refl) instance SDecide a => Data.Type.Equality.TestEquality (SIdentity :: Identity a -> Type) where @@ -281,9 +277,13 @@ = Data.Singletons.Decide.decideCoercion instance SingI n => SingI (Constant (n :: a)) where sing = SConstant sing + instance SingI1 Constant where + liftSing = SConstant instance SingI (ConstantSym0 :: (~>) a (Constant (a :: Type) (b :: Type))) where sing = (singFun1 @ConstantSym0) SConstant instance SingI n => SingI (Identity (n :: a)) where sing = SIdentity sing + instance SingI1 Identity where + liftSing = SIdentity instance SingI (IdentitySym0 :: (~>) a (Identity a)) where sing = (singFun1 @IdentitySym0) SIdentity diff --git a/tests/compile-and-dump/Singletons/T287.golden b/tests/compile-and-dump/Singletons/T287.golden --- a/tests/compile-and-dump/Singletons/T287.golden +++ b/tests/compile-and-dump/Singletons/T287.golden @@ -30,7 +30,7 @@ type family (<<>>@#@$$$) (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: a where (<<>>@#@$$$) a0123456789876543210 a0123456789876543210 = (<<>>) a0123456789876543210 a0123456789876543210 class PS a where - type (<<>>) (arg :: a) (arg :: a) :: a + type family (<<>>) (arg :: a) (arg :: a) :: a type family Lambda_0123456789876543210 f g x where Lambda_0123456789876543210 f g x = Apply (Apply (<<>>@#@$) (Apply f x)) (Apply g x) data Lambda_0123456789876543210Sym0 f0123456789876543210 @@ -90,22 +90,26 @@ type (<<>>) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a class SS a where (%<<>>) :: - forall (t :: a) (t :: a). - Sing t -> Sing t -> Sing (Apply (Apply (<<>>@#@$) t) t :: a) + forall (t :: a) (t :: a). Sing t + -> Sing t -> Sing (Apply (Apply (<<>>@#@$) t) t :: a) instance SS b => SS ((~>) a b) where (%<<>>) :: - forall (t :: (~>) a b) (t :: (~>) a b). - Sing t -> Sing t -> Sing (Apply (Apply (<<>>@#@$) t) t :: (~>) a b) + forall (t :: (~>) a b) (t :: (~>) a b). Sing t + -> Sing t + -> Sing (Apply (Apply (<<>>@#@$) t) t :: (~>) a b) (%<<>>) (sF :: Sing f) (sG :: Sing g) = (singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 f) g)) (\ sX - -> case sX of { + -> case sX of (_ :: Sing x) -> (applySing ((applySing ((singFun2 @(<<>>@#@$)) (%<<>>))) ((applySing sF) sX))) - ((applySing sG) sX) }) + ((applySing sG) sX)) instance SS a => SingI ((<<>>@#@$) :: (~>) a ((~>) a a)) where sing = (singFun2 @(<<>>@#@$)) (%<<>>) instance (SS a, SingI d) => SingI ((<<>>@#@$$) (d :: a) :: (~>) a a) where sing = (singFun1 @((<<>>@#@$$) (d :: a))) ((%<<>>) (sing @d)) + instance SS a => SingI1 ((<<>>@#@$$) :: a -> (~>) a a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @((<<>>@#@$$) (d :: a))) ((%<<>>) s) diff --git a/tests/compile-and-dump/Singletons/T296.golden b/tests/compile-and-dump/Singletons/T296.golden --- a/tests/compile-and-dump/Singletons/T296.golden +++ b/tests/compile-and-dump/Singletons/T296.golden @@ -48,8 +48,8 @@ type family F (a :: MyProxy a) :: MyProxy a where F MyProxy = Let0123456789876543210XSym0 sF :: - forall a (t :: MyProxy a). - Sing t -> Sing (Apply FSym0 t :: MyProxy a) + forall a (t :: MyProxy a). Sing t + -> Sing (Apply FSym0 t :: MyProxy a) sF SMyProxy = let sX :: Sing @_ Let0123456789876543210XSym0 diff --git a/tests/compile-and-dump/Singletons/T312.golden b/tests/compile-and-dump/Singletons/T312.golden --- a/tests/compile-and-dump/Singletons/T312.golden +++ b/tests/compile-and-dump/Singletons/T312.golden @@ -142,27 +142,27 @@ type family Baz_0123456789876543210Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: b where Baz_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 = Baz_0123456789876543210 a0123456789876543210 a0123456789876543210 class PFoo a where - type Bar (arg :: a) (arg :: b) :: b - type Baz (arg :: a) (arg :: b) :: b + type family Bar (arg :: a) (arg :: b) :: b + type family Baz (arg :: a) (arg :: b) :: b type Bar a a = Apply (Apply Bar_0123456789876543210Sym0 a) a type Baz a a = Apply (Apply Baz_0123456789876543210Sym0 a) a class SFoo a where sBar :: - forall b (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply BarSym0 t) t :: b) + forall b (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply BarSym0 t) t :: b) sBaz :: - forall b (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply BazSym0 t) t :: b) + forall b (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply BazSym0 t) t :: b) default sBar :: - forall b (t :: a) (t :: b). - ((Apply (Apply BarSym0 t) t :: b) - ~ Apply (Apply Bar_0123456789876543210Sym0 t) t) => - Sing t -> Sing t -> Sing (Apply (Apply BarSym0 t) t :: b) + forall b (t :: a) (t :: b). ((Apply (Apply BarSym0 t) t :: b) + ~ Apply (Apply Bar_0123456789876543210Sym0 t) t) => + Sing t + -> Sing t -> Sing (Apply (Apply BarSym0 t) t :: b) default sBaz :: - forall b (t :: a) (t :: b). - ((Apply (Apply BazSym0 t) t :: b) - ~ Apply (Apply Baz_0123456789876543210Sym0 t) t) => - Sing t -> Sing t -> Sing (Apply (Apply BazSym0 t) t :: b) + forall b (t :: a) (t :: b). ((Apply (Apply BazSym0 t) t :: b) + ~ Apply (Apply Baz_0123456789876543210Sym0 t) t) => + Sing t + -> Sing t -> Sing (Apply (Apply BazSym0 t) t :: b) sBar _ (sX :: Sing x) = sX sBaz (sA_0123456789876543210 :: Sing a_0123456789876543210) @@ -171,10 +171,9 @@ ((applySing (let sH :: - forall c (t :: c) (t :: b). - Sing t - -> Sing t - -> Sing (Apply (Apply (Let0123456789876543210HSym2 a_0123456789876543210 a_0123456789876543210) t) t :: b) + forall c (t :: c) (t :: b). Sing t + -> Sing t + -> Sing (Apply (Apply (Let0123456789876543210HSym2 a_0123456789876543210 a_0123456789876543210) t) t :: b) sH _ (sX :: Sing x) = sX in (singFun2 @@ -187,8 +186,14 @@ instance (SFoo a, SingI d) => SingI (BarSym1 (d :: a) :: (~>) b b) where sing = (singFun1 @(BarSym1 (d :: a))) (sBar (sing @d)) + instance SFoo a => SingI1 (BarSym1 :: a -> (~>) b b) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(BarSym1 (d :: a))) (sBar s) instance SFoo a => SingI (BazSym0 :: (~>) a ((~>) b b)) where sing = (singFun2 @BazSym0) sBaz instance (SFoo a, SingI d) => SingI (BazSym1 (d :: a) :: (~>) b b) where sing = (singFun1 @(BazSym1 (d :: a))) (sBaz (sing @d)) + instance SFoo a => SingI1 (BazSym1 :: a -> (~>) b b) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(BazSym1 (d :: a))) (sBaz s) diff --git a/tests/compile-and-dump/Singletons/T313.golden b/tests/compile-and-dump/Singletons/T313.golden --- a/tests/compile-and-dump/Singletons/T313.golden +++ b/tests/compile-and-dump/Singletons/T313.golden @@ -18,7 +18,7 @@ type family PFoo3 a where PFoo3 a = Maybe a class PC (a :: Type) where - type PFoo4 a + type family PFoo4 a type PFoo4 a = Maybe a instance PC a where type PFoo4 a = Maybe a @@ -80,7 +80,7 @@ type family SFoo3 a where SFoo3 a = Maybe a class SC (a :: Type) where - type SFoo4 a + type family SFoo4 a type SFoo4 a = Maybe a instance SC a where type SFoo4 a = Maybe a diff --git a/tests/compile-and-dump/Singletons/T322.golden b/tests/compile-and-dump/Singletons/T322.golden --- a/tests/compile-and-dump/Singletons/T322.golden +++ b/tests/compile-and-dump/Singletons/T322.golden @@ -35,8 +35,8 @@ (!) a_0123456789876543210 a_0123456789876543210 = Apply (Apply (||@#@$) a_0123456789876543210) a_0123456789876543210 infixr 2 %! (%!) :: - forall (t :: Bool) (t :: Bool). - Sing t -> Sing t -> Sing (Apply (Apply (!@#@$) t) t :: Bool) + forall (t :: Bool) (t :: Bool). Sing t + -> Sing t -> Sing (Apply (Apply (!@#@$) t) t :: Bool) (%!) (sA_0123456789876543210 :: Sing a_0123456789876543210) (sA_0123456789876543210 :: Sing a_0123456789876543210) @@ -48,3 +48,6 @@ instance SingI d => SingI ((!@#@$$) (d :: Bool) :: (~>) Bool Bool) where sing = (singFun1 @((!@#@$$) (d :: Bool))) ((%!) (sing @d)) + instance SingI1 ((!@#@$$) :: Bool -> (~>) Bool Bool) where + liftSing (s :: Sing (d :: Bool)) + = (singFun1 @((!@#@$$) (d :: Bool))) ((%!) s) diff --git a/tests/compile-and-dump/Singletons/T326.golden b/tests/compile-and-dump/Singletons/T326.golden --- a/tests/compile-and-dump/Singletons/T326.golden +++ b/tests/compile-and-dump/Singletons/T326.golden @@ -25,7 +25,7 @@ infixl 9 <%>@#@$$$ type PC1 :: GHC.Types.Type -> Constraint class PC1 (a :: GHC.Types.Type) where - type (<%>) (arg :: a) (arg :: a) :: a + type family (<%>) (arg :: a) (arg :: a) :: a infixl 9 <%> Singletons/T326.hs:0:0:: Splicing declarations genSingletons [''C2] @@ -54,12 +54,12 @@ infixl 9 <%%>@#@$$$ type PC2 :: GHC.Types.Type -> Constraint class PC2 (a :: GHC.Types.Type) where - type (<%%>) (arg :: a) (arg :: a) :: a + type family (<%%>) (arg :: a) (arg :: a) :: a infixl 9 <%%> class SC2 (a :: GHC.Types.Type) where (%<%%>) :: - forall (t :: a) (t :: a). - Sing t -> Sing t -> Sing (Apply (Apply (<%%>@#@$) t) t :: a) + forall (t :: a) (t :: a). Sing t + -> Sing t -> Sing (Apply (Apply (<%%>@#@$) t) t :: a) type SC2 :: GHC.Types.Type -> Constraint infixl 9 %<%%> instance SC2 a => SingI ((<%%>@#@$) :: (~>) a ((~>) a a)) where @@ -67,3 +67,6 @@ instance (SC2 a, SingI d) => SingI ((<%%>@#@$$) (d :: a) :: (~>) a a) where sing = (singFun1 @((<%%>@#@$$) (d :: a))) ((%<%%>) (sing @d)) + instance SC2 a => SingI1 ((<%%>@#@$$) :: a -> (~>) a a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @((<%%>@#@$$) (d :: a))) ((%<%%>) s) diff --git a/tests/compile-and-dump/Singletons/T353.golden b/tests/compile-and-dump/Singletons/T353.golden --- a/tests/compile-and-dump/Singletons/T353.golden +++ b/tests/compile-and-dump/Singletons/T353.golden @@ -36,9 +36,8 @@ type MkProdSym0 :: forall k (f :: k -> Type) (g :: k -> Type) - (p :: k). - (~>) (f p) ((~>) (g p) (Prod (f :: k -> Type) (g :: k - -> Type) (p :: k))) + (p :: k). (~>) (f p) ((~>) (g p) (Prod (f :: k -> Type) (g :: k + -> Type) (p :: k))) data MkProdSym0 :: (~>) (f p) ((~>) (g p) (Prod (f :: k -> Type) (g :: k -> Type) (p :: k))) where @@ -50,8 +49,9 @@ type MkProdSym1 :: forall k (f :: k -> Type) (g :: k -> Type) - (p :: k). - f p -> (~>) (g p) (Prod (f :: k -> Type) (g :: k -> Type) (p :: k)) + (p :: k). f p + -> (~>) (g p) (Prod (f :: k -> Type) (g :: k + -> Type) (p :: k)) data MkProdSym1 (a0123456789876543210 :: f p) :: (~>) (g p) (Prod (f :: k -> Type) (g :: k -> Type) (p :: k)) @@ -64,8 +64,8 @@ type MkProdSym2 :: forall k (f :: k -> Type) (g :: k -> Type) - (p :: k). - f p -> g p -> Prod (f :: k -> Type) (g :: k -> Type) (p :: k) + (p :: k). f p + -> g p -> Prod (f :: k -> Type) (g :: k -> Type) (p :: k) type family MkProdSym2 (a0123456789876543210 :: f p) (a0123456789876543210 :: g p) :: Prod (f :: k -> Type) (g :: k -> Type) (p :: k) where @@ -73,8 +73,10 @@ Singletons/T353.hs:0:0:: Splicing declarations genDefunSymbols [''Foo] ======> - type MkFooSym0 :: forall k k (a :: k) (b :: k). - (~>) (Proxy a) ((~>) (Proxy b) (Foo (a :: k) (b :: k))) + type MkFooSym0 :: forall k + k + (a :: k) + (b :: k). (~>) (Proxy a) ((~>) (Proxy b) (Foo (a :: k) (b :: k))) data MkFooSym0 :: (~>) (Proxy a) ((~>) (Proxy b) (Foo (a :: k) (b :: k))) where MkFooSym0KindInference :: SameKind (Apply MkFooSym0 arg) (MkFooSym1 arg) => @@ -82,8 +84,8 @@ type instance Apply MkFooSym0 a0123456789876543210 = MkFooSym1 a0123456789876543210 instance SuppressUnusedWarnings MkFooSym0 where suppressUnusedWarnings = snd (((,) MkFooSym0KindInference) ()) - type MkFooSym1 :: forall k k (a :: k) (b :: k). - Proxy a -> (~>) (Proxy b) (Foo (a :: k) (b :: k)) + type MkFooSym1 :: forall k k (a :: k) (b :: k). Proxy a + -> (~>) (Proxy b) (Foo (a :: k) (b :: k)) data MkFooSym1 (a0123456789876543210 :: Proxy a) :: (~>) (Proxy b) (Foo (a :: k) (b :: k)) where MkFooSym1KindInference :: SameKind (Apply (MkFooSym1 a0123456789876543210) arg) (MkFooSym2 a0123456789876543210 arg) => @@ -91,7 +93,7 @@ type instance Apply (MkFooSym1 a0123456789876543210) a0123456789876543210 = 'MkFoo a0123456789876543210 a0123456789876543210 instance SuppressUnusedWarnings (MkFooSym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) MkFooSym1KindInference) ()) - type MkFooSym2 :: forall k k (a :: k) (b :: k). - Proxy a -> Proxy b -> Foo (a :: k) (b :: k) + type MkFooSym2 :: forall k k (a :: k) (b :: k). Proxy a + -> Proxy b -> Foo (a :: k) (b :: k) type family MkFooSym2 (a0123456789876543210 :: Proxy a) (a0123456789876543210 :: Proxy b) :: Foo (a :: k) (b :: k) where MkFooSym2 a0123456789876543210 a0123456789876543210 = 'MkFoo a0123456789876543210 a0123456789876543210 diff --git a/tests/compile-and-dump/Singletons/T358.golden b/tests/compile-and-dump/Singletons/T358.golden --- a/tests/compile-and-dump/Singletons/T358.golden +++ b/tests/compile-and-dump/Singletons/T358.golden @@ -29,7 +29,7 @@ type family Method1Sym0 :: f a where Method1Sym0 = Method1 class PC1 (f :: k -> Type) where - type Method1 :: f a + type family Method1 :: f a type Method2aSym0 :: forall b a. (~>) b a data Method2aSym0 :: (~>) b a where @@ -53,8 +53,8 @@ type family Method2bSym1 (a0123456789876543210 :: b) :: a where Method2bSym1 a0123456789876543210 = Method2b a0123456789876543210 class PC2 a where - type Method2a (arg :: b) :: a - type Method2b (arg :: b) :: a + type family Method2a (arg :: b) :: a + type family Method2b (arg :: b) :: a type Method1_0123456789876543210 :: [a] type family Method1_0123456789876543210 :: [a] where Method1_0123456789876543210 = NilSym0 diff --git a/tests/compile-and-dump/Singletons/T367.golden b/tests/compile-and-dump/Singletons/T367.golden --- a/tests/compile-and-dump/Singletons/T367.golden +++ b/tests/compile-and-dump/Singletons/T367.golden @@ -28,10 +28,13 @@ type family Const' (a :: a) (a :: b) :: a where Const' x _ = x sConst' :: - forall a b (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Const'Sym0 t) t :: a) + forall a b (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply Const'Sym0 t) t :: a) sConst' (sX :: Sing x) _ = sX instance SingI (Const'Sym0 :: (~>) a ((~>) b a)) where sing = (singFun2 @Const'Sym0) sConst' instance SingI d => SingI (Const'Sym1 (d :: a) :: (~>) b a) where sing = (singFun1 @(Const'Sym1 (d :: a))) (sConst' (sing @d)) + instance SingI1 (Const'Sym1 :: a -> (~>) b a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(Const'Sym1 (d :: a))) (sConst' s) diff --git a/tests/compile-and-dump/Singletons/T371.golden b/tests/compile-and-dump/Singletons/T371.golden --- a/tests/compile-and-dump/Singletons/T371.golden +++ b/tests/compile-and-dump/Singletons/T371.golden @@ -41,13 +41,13 @@ type Y2Sym1 :: forall (a :: Type). X a -> Y (a :: Type) type family Y2Sym1 (a0123456789876543210 :: X a) :: Y (a :: Type) where Y2Sym1 a0123456789876543210 = Y2 a0123456789876543210 - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural -> X a -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: X a) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: X a) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where ShowsPrec_0123456789876543210 _ X1 a_0123456789876543210 = Apply (Apply ShowStringSym0 "X1") a_0123456789876543210 ShowsPrec_0123456789876543210 p_0123456789876543210 (X2 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "X2 ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) where ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => ShowsPrec_0123456789876543210Sym0 a0123456789876543210 @@ -55,9 +55,9 @@ instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> (~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol) where ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -65,9 +65,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural -> X a -> (~>) GHC.Types.Symbol GHC.Types.Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: X a) :: (~>) GHC.Types.Symbol GHC.Types.Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: X a) :: (~>) GHC.Types.Symbol GHC.Types.Symbol where ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -75,19 +75,19 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural -> X a -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: X a) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: X a) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow (X a) where type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a - type ShowsPrec_0123456789876543210 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210 :: GHC.Num.Natural.Natural -> Y a -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: Y a) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where + type family ShowsPrec_0123456789876543210 (a :: GHC.Num.Natural.Natural) (a :: Y a) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where ShowsPrec_0123456789876543210 _ Y1 a_0123456789876543210 = Apply (Apply ShowStringSym0 "Y1") a_0123456789876543210 ShowsPrec_0123456789876543210 p_0123456789876543210 (Y2 arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Y2 ")) (Apply (Apply ShowsPrecSym0 (FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210 - type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + type ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Num.Natural.Natural ((~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) where ShowsPrec_0123456789876543210Sym0KindInference :: SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) => ShowsPrec_0123456789876543210Sym0 a0123456789876543210 @@ -95,9 +95,9 @@ instance SuppressUnusedWarnings ShowsPrec_0123456789876543210Sym0 where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ()) - type ShowsPrec_0123456789876543210Sym1 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym1 :: GHC.Num.Natural.Natural -> (~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol) - data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol) + data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Num.Natural.Natural) :: (~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol) where ShowsPrec_0123456789876543210Sym1KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210 @@ -105,9 +105,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym1 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ()) - type ShowsPrec_0123456789876543210Sym2 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym2 :: GHC.Num.Natural.Natural -> Y a -> (~>) GHC.Types.Symbol GHC.Types.Symbol - data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Y a) :: (~>) GHC.Types.Symbol GHC.Types.Symbol + data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Y a) :: (~>) GHC.Types.Symbol GHC.Types.Symbol where ShowsPrec_0123456789876543210Sym2KindInference :: SameKind (Apply (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) => ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210 @@ -115,9 +115,9 @@ instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where suppressUnusedWarnings = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ()) - type ShowsPrec_0123456789876543210Sym3 :: GHC.Types.Nat + type ShowsPrec_0123456789876543210Sym3 :: GHC.Num.Natural.Natural -> Y a -> GHC.Types.Symbol -> GHC.Types.Symbol - type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Y a) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where + type family ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Num.Natural.Natural) (a0123456789876543210 :: Y a) (a0123456789876543210 :: GHC.Types.Symbol) :: GHC.Types.Symbol where ShowsPrec_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210 = ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210 instance PShow (Y a) where type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a @@ -133,8 +133,7 @@ fromSing (SX2 b) = X2 (fromSing b) toSing X1 = SomeSing SX1 toSing (X2 (b :: Demote (Y a))) - = case toSing b :: SomeSing (Y a) of { - SomeSing c -> SomeSing (SX2 c) } + = case toSing b :: SomeSing (Y a) of SomeSing c -> SomeSing (SX2 c) data SY :: forall (a :: Type). Y a -> Type where SY1 :: forall (a :: Type). SY (Y1 :: Y (a :: Type)) @@ -147,16 +146,16 @@ fromSing (SY2 b) = Y2 (fromSing b) toSing Y1 = SomeSing SY1 toSing (Y2 (b :: Demote (X a))) - = case toSing b :: SomeSing (X a) of { - SomeSing c -> SomeSing (SY2 c) } + = case toSing b :: SomeSing (X a) of SomeSing c -> SomeSing (SY2 c) instance SShow (Y a) => SShow (X a) where sShowsPrec :: - forall (t1 :: GHC.Types.Nat) (t2 :: X a) (t3 :: GHC.Types.Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - -> Type) t1) t2) t3) + forall (t1 :: GHC.Num.Natural.Natural) + (t2 :: X a) + (t3 :: GHC.Types.Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + -> Type) t1) t2) t3) sShowsPrec _ SX1 @@ -186,12 +185,13 @@ sA_0123456789876543210 instance SShow (X a) => SShow (Y a) where sShowsPrec :: - forall (t1 :: GHC.Types.Nat) (t2 :: Y a) (t3 :: GHC.Types.Symbol). - Sing t1 - -> Sing t2 - -> Sing t3 - -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) - -> Type) t1) t2) t3) + forall (t1 :: GHC.Num.Natural.Natural) + (t2 :: Y a) + (t3 :: GHC.Types.Symbol). Sing t1 + -> Sing t2 + -> Sing t3 + -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Num.Natural.Natural ((~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol)) + -> Type) t1) t2) t3) sShowsPrec _ SY1 @@ -227,11 +227,15 @@ sing = SX1 instance SingI n => SingI (X2 (n :: Y a)) where sing = SX2 sing + instance SingI1 X2 where + liftSing = SX2 instance SingI (X2Sym0 :: (~>) (Y a) (X (a :: Type))) where sing = (singFun1 @X2Sym0) SX2 instance SingI Y1 where sing = SY1 instance SingI n => SingI (Y2 (n :: X a)) where sing = SY2 sing + instance SingI1 Y2 where + liftSing = SY2 instance SingI (Y2Sym0 :: (~>) (X a) (Y (a :: Type))) where sing = (singFun1 @Y2Sym0) SY2 diff --git a/tests/compile-and-dump/Singletons/T376.golden b/tests/compile-and-dump/Singletons/T376.golden --- a/tests/compile-and-dump/Singletons/T376.golden +++ b/tests/compile-and-dump/Singletons/T376.golden @@ -28,8 +28,8 @@ type family F (a :: (~>) () ()) (a :: ()) :: () where F g a_0123456789876543210 = Apply (g :: (~>) () ()) a_0123456789876543210 sF :: - forall (t :: (~>) () ()) (t :: ()). - Sing t -> Sing t -> Sing (Apply (Apply FSym0 t) t :: ()) + forall (t :: (~>) () ()) (t :: ()). Sing t + -> Sing t -> Sing (Apply (Apply FSym0 t) t :: ()) sF (sG :: Sing g) (sA_0123456789876543210 :: Sing a_0123456789876543210) @@ -39,3 +39,6 @@ instance SingI d => SingI (FSym1 (d :: (~>) () ()) :: (~>) () ()) where sing = (singFun1 @(FSym1 (d :: (~>) () ()))) (sF (sing @d)) + instance SingI1 (FSym1 :: (~>) () () -> (~>) () ()) where + liftSing (s :: Sing (d :: (~>) () ())) + = (singFun1 @(FSym1 (d :: (~>) () ()))) (sF s) diff --git a/tests/compile-and-dump/Singletons/T378a.golden b/tests/compile-and-dump/Singletons/T378a.golden --- a/tests/compile-and-dump/Singletons/T378a.golden +++ b/tests/compile-and-dump/Singletons/T378a.golden @@ -53,13 +53,16 @@ type family ConstBA (a :: a) (a :: b) :: a where ConstBA x _ = x sConstBA :: - forall b a (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply ConstBASym0 t) t :: a) + forall b a (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply ConstBASym0 t) t :: a) sConstBA (sX :: Sing x) _ = sX instance SingI (ConstBASym0 :: (~>) a ((~>) b a)) where sing = (singFun2 @ConstBASym0) sConstBA instance SingI d => SingI (ConstBASym1 (d :: a) :: (~>) b a) where sing = (singFun1 @(ConstBASym1 (d :: a))) (sConstBA (sing @d)) + instance SingI1 (ConstBASym1 :: a -> (~>) b a) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(ConstBASym1 (d :: a))) (sConstBA s) data SProxy :: forall k (a :: k). Proxy a -> Type where SProxy1 :: forall a. SProxy (Proxy1 :: Proxy a) diff --git a/tests/compile-and-dump/Singletons/T378b.golden b/tests/compile-and-dump/Singletons/T378b.golden --- a/tests/compile-and-dump/Singletons/T378b.golden +++ b/tests/compile-and-dump/Singletons/T378b.golden @@ -84,11 +84,11 @@ type PC :: forall b a. a -> b -> Constraint class PC x y sNatMinus :: - forall (t :: Nat) (t :: Nat). - Sing t -> Sing t -> Sing (Apply (Apply NatMinusSym0 t) t :: Nat) + forall (t :: Nat) (t :: Nat). Sing t + -> Sing t -> Sing (Apply (Apply NatMinusSym0 t) t :: Nat) sF :: - forall b a (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply FSym0 t) t :: ()) + forall b a (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply FSym0 t) t :: ()) sNatMinus SZero _ = SZero sNatMinus (SSucc (sA :: Sing a)) (SSucc (sB :: Sing b)) = (applySing ((applySing ((singFun2 @NatMinusSym0) sNatMinus)) sA)) @@ -109,16 +109,21 @@ instance SingI d => SingI (NatMinusSym1 (d :: Nat) :: (~>) Nat Nat) where sing = (singFun1 @(NatMinusSym1 (d :: Nat))) (sNatMinus (sing @d)) + instance SingI1 (NatMinusSym1 :: Nat -> (~>) Nat Nat) where + liftSing (s :: Sing (d :: Nat)) + = (singFun1 @(NatMinusSym1 (d :: Nat))) (sNatMinus s) instance SingI (FSym0 :: (~>) a ((~>) b ())) where sing = (singFun2 @FSym0) sF instance SingI d => SingI (FSym1 (d :: a) :: (~>) b ()) where sing = (singFun1 @(FSym1 (d :: a))) (sF (sing @d)) + instance SingI1 (FSym1 :: a -> (~>) b ()) where + liftSing (s :: Sing (d :: a)) = (singFun1 @(FSym1 (d :: a))) (sF s) type SD :: forall b a (x :: a) (y :: b). D x y -> Type data SD :: forall b a (x :: a) (y :: b). D x y -> Type type instance Sing @(D x y) = SD instance (SingKind x, SingKind y) => SingKind (D x y) where type Demote (D x y) = D (Demote x) (Demote y) - fromSing x = case x of - toSing x = SomeSing (case x of) + fromSing x = case x of {} + toSing x = SomeSing (case x of {}) class SC x y type SC :: forall b a. a -> b -> Constraint diff --git a/tests/compile-and-dump/Singletons/T401.golden b/tests/compile-and-dump/Singletons/T401.golden --- a/tests/compile-and-dump/Singletons/T401.golden +++ b/tests/compile-and-dump/Singletons/T401.golden @@ -1,13 +1,13 @@ -Singletons/T401.hs:0:0: error: - `singletons-th` does not support higher-rank `forall`s -In the type: (forall a_0 . a_0 -> a_0) -> b_1 -> b_1 - +Singletons/T401.hs:0:0: error: Q monad failure | 5 | $(singletons [d| | ^^^^^^^^^^^^^^^... -Singletons/T401.hs:0:0: error: Q monad failure +Singletons/T401.hs:0:0: error: + `singletons-th` does not support higher-rank `forall`s +In the type: (forall a_0 . a_0 -> a_0) -> b_1 -> b_1 + | 5 | $(singletons [d| | ^^^^^^^^^^^^^^^... diff --git a/tests/compile-and-dump/Singletons/T401b.golden b/tests/compile-and-dump/Singletons/T401b.golden --- a/tests/compile-and-dump/Singletons/T401b.golden +++ b/tests/compile-and-dump/Singletons/T401b.golden @@ -1,13 +1,13 @@ -Singletons/T401b.hs:0:0: error: - `singletons-th` does not support higher-rank `forall`s -In the type: (forall a_0 . a_0) -> T_1 - +Singletons/T401b.hs:0:0: error: Q monad failure | 5 | $(singletons [d| | ^^^^^^^^^^^^^^^... -Singletons/T401b.hs:0:0: error: Q monad failure +Singletons/T401b.hs:0:0: error: + `singletons-th` does not support higher-rank `forall`s +In the type: (forall a_0 . a_0) -> T_1 + | 5 | $(singletons [d| | ^^^^^^^^^^^^^^^... diff --git a/tests/compile-and-dump/Singletons/T410.golden b/tests/compile-and-dump/Singletons/T410.golden --- a/tests/compile-and-dump/Singletons/T410.golden +++ b/tests/compile-and-dump/Singletons/T410.golden @@ -32,7 +32,7 @@ type family EqualsSym2 (a0123456789876543210 :: a) (a0123456789876543210 :: a) :: Bool where EqualsSym2 a0123456789876543210 a0123456789876543210 = Equals a0123456789876543210 a0123456789876543210 class PEq a where - type Equals (arg :: a) (arg :: a) :: Bool + type family Equals (arg :: a) (arg :: a) :: Bool type Equals_0123456789876543210 :: () -> () -> Bool type family Equals_0123456789876543210 (a :: ()) (a :: ()) :: Bool where Equals_0123456789876543210 '() '() = TrueSym0 diff --git a/tests/compile-and-dump/Singletons/T412.golden b/tests/compile-and-dump/Singletons/T412.golden --- a/tests/compile-and-dump/Singletons/T412.golden +++ b/tests/compile-and-dump/Singletons/T412.golden @@ -144,7 +144,7 @@ M1Sym2 a0123456789876543210 a0123456789876543210 = M1 a0123456789876543210 a0123456789876543210 infix 6 `M1Sym2` class PC1 a b where - type M1 (arg :: a) (arg :: b) :: Bool + type family M1 (arg :: a) (arg :: b) :: Bool infix 6 `M1` infixr 5 `sD1B` infixr 5 `sD1A` @@ -169,25 +169,35 @@ type Demote (D1 a b) = D1 (Demote a) (Demote b) fromSing (SMkD1 b b) = (MkD1 (fromSing b)) (fromSing b) toSing (MkD1 (b :: Demote a) (b :: Demote b)) - = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkD1 c) c) } + = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkD1 c) c) class SC1 a b where sM1 :: - forall (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply M1Sym0 t) t :: Bool) + forall (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply M1Sym0 t) t :: Bool) infix 6 `sM1` instance (SingI n, SingI n) => SingI (MkD1 (n :: a) (n :: b)) where sing = (SMkD1 sing) sing + instance SingI n => SingI1 (MkD1 (n :: a)) where + liftSing = SMkD1 sing + instance SingI2 MkD1 where + liftSing2 = SMkD1 instance SingI (MkD1Sym0 :: (~>) a ((~>) b (D1 a b))) where sing = (singFun2 @MkD1Sym0) SMkD1 instance SingI d => SingI (MkD1Sym1 (d :: a) :: (~>) b (D1 a b)) where sing = (singFun1 @(MkD1Sym1 (d :: a))) (SMkD1 (sing @d)) + instance SingI1 (MkD1Sym1 :: a -> (~>) b (D1 a b)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(MkD1Sym1 (d :: a))) (SMkD1 s) instance SC1 a b => SingI (M1Sym0 :: (~>) a ((~>) b Bool)) where sing = (singFun2 @M1Sym0) sM1 instance (SC1 a b, SingI d) => SingI (M1Sym1 (d :: a) :: (~>) b Bool) where sing = (singFun1 @(M1Sym1 (d :: a))) (sM1 (sing @d)) + instance SC1 a b => SingI1 (M1Sym1 :: a -> (~>) b Bool) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(M1Sym1 (d :: a))) (sM1 s) Singletons/T412.hs:0:0:: Splicing declarations genSingletons [''C2, ''T2a, ''T2b, ''D2] ======> @@ -215,13 +225,13 @@ infix 6 `M2Sym2` type PC2 :: GHC.Types.Type -> GHC.Types.Type -> Constraint class PC2 (a :: GHC.Types.Type) (b :: GHC.Types.Type) where - type M2 (arg :: a) (arg :: b) :: Bool + type family M2 (arg :: a) (arg :: b) :: Bool infix 5 `PC2` infix 6 `M2` class SC2 (a :: GHC.Types.Type) (b :: GHC.Types.Type) where sM2 :: - forall (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply M2Sym0 t) t :: Bool) + forall (t :: a) (t :: b). Sing t + -> Sing t -> Sing (Apply (Apply M2Sym0 t) t :: Bool) type SC2 :: GHC.Types.Type -> GHC.Types.Type -> Constraint infix 5 `SC2` infix 6 `sM2` @@ -230,6 +240,9 @@ instance (SC2 a b, SingI d) => SingI (M2Sym1 (d :: a) :: (~>) b Bool) where sing = (singFun1 @(M2Sym1 (d :: a))) (sM2 (sing @d)) + instance SC2 a b => SingI1 (M2Sym1 :: a -> (~>) b Bool) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(M2Sym1 (d :: a))) (sM2 s) type T2aSym0 :: (~>) GHC.Types.Type ((~>) GHC.Types.Type GHC.Types.Type) data T2aSym0 :: (~>) GHC.Types.Type ((~>) GHC.Types.Type GHC.Types.Type) where @@ -277,8 +290,7 @@ T2bSym2 a0123456789876543210 a0123456789876543210 = T2b a0123456789876543210 a0123456789876543210 infixl 5 `T2bSym2` type MkD2Sym0 :: forall (a :: GHC.Types.Type) - (b :: GHC.Types.Type). - (~>) a ((~>) b (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type))) + (b :: GHC.Types.Type). (~>) a ((~>) b (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type))) data MkD2Sym0 :: (~>) a ((~>) b (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type))) where MkD2Sym0KindInference :: SameKind (Apply MkD2Sym0 arg) (MkD2Sym1 arg) => @@ -288,8 +300,8 @@ suppressUnusedWarnings = snd (((,) MkD2Sym0KindInference) ()) infixr 5 `MkD2Sym0` type MkD2Sym1 :: forall (a :: GHC.Types.Type) - (b :: GHC.Types.Type). - a -> (~>) b (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)) + (b :: GHC.Types.Type). a + -> (~>) b (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)) data MkD2Sym1 (a0123456789876543210 :: a) :: (~>) b (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)) where MkD2Sym1KindInference :: SameKind (Apply (MkD2Sym1 a0123456789876543210) arg) (MkD2Sym2 a0123456789876543210 arg) => @@ -299,15 +311,16 @@ suppressUnusedWarnings = snd (((,) MkD2Sym1KindInference) ()) infixr 5 `MkD2Sym1` type MkD2Sym2 :: forall (a :: GHC.Types.Type) - (b :: GHC.Types.Type). - a -> b -> D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type) + (b :: GHC.Types.Type). a + -> b + -> D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type) type family MkD2Sym2 (a0123456789876543210 :: a) (a0123456789876543210 :: b) :: D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type) where MkD2Sym2 a0123456789876543210 a0123456789876543210 = 'MkD2 a0123456789876543210 a0123456789876543210 infixr 5 `MkD2Sym2` infixr 5 `D2A` infixr 5 `D2B` - type D2BSym0 :: forall (a :: GHC.Types.Type) (b :: GHC.Types.Type). - (~>) (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)) b + type D2BSym0 :: forall (a :: GHC.Types.Type) + (b :: GHC.Types.Type). (~>) (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)) b data D2BSym0 :: (~>) (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)) b where D2BSym0KindInference :: SameKind (Apply D2BSym0 arg) (D2BSym1 arg) => @@ -315,12 +328,13 @@ type instance Apply D2BSym0 a0123456789876543210 = D2B a0123456789876543210 instance SuppressUnusedWarnings D2BSym0 where suppressUnusedWarnings = snd (((,) D2BSym0KindInference) ()) - type D2BSym1 :: forall (a :: GHC.Types.Type) (b :: GHC.Types.Type). - D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type) -> b + type D2BSym1 :: forall (a :: GHC.Types.Type) + (b :: GHC.Types.Type). D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type) + -> b type family D2BSym1 (a0123456789876543210 :: D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)) :: b where D2BSym1 a0123456789876543210 = D2B a0123456789876543210 - type D2ASym0 :: forall (a :: GHC.Types.Type) (b :: GHC.Types.Type). - (~>) (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)) a + type D2ASym0 :: forall (a :: GHC.Types.Type) + (b :: GHC.Types.Type). (~>) (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)) a data D2ASym0 :: (~>) (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)) a where D2ASym0KindInference :: SameKind (Apply D2ASym0 arg) (D2ASym1 arg) => @@ -328,36 +342,39 @@ type instance Apply D2ASym0 a0123456789876543210 = D2A a0123456789876543210 instance SuppressUnusedWarnings D2ASym0 where suppressUnusedWarnings = snd (((,) D2ASym0KindInference) ()) - type D2ASym1 :: forall (a :: GHC.Types.Type) (b :: GHC.Types.Type). - D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type) -> a + type D2ASym1 :: forall (a :: GHC.Types.Type) + (b :: GHC.Types.Type). D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type) + -> a type family D2ASym1 (a0123456789876543210 :: D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)) :: a where D2ASym1 a0123456789876543210 = D2A a0123456789876543210 - type D2B :: forall (a :: GHC.Types.Type) (b :: GHC.Types.Type). - D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type) -> b + type D2B :: forall (a :: GHC.Types.Type) + (b :: GHC.Types.Type). D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type) + -> b type family D2B (a :: D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)) :: b where D2B ('MkD2 _ field) = field - type D2A :: forall (a :: GHC.Types.Type) (b :: GHC.Types.Type). - D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type) -> a + type D2A :: forall (a :: GHC.Types.Type) + (b :: GHC.Types.Type). D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type) + -> a type family D2A (a :: D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)) :: a where D2A ('MkD2 field _) = field sD2B :: forall (a :: GHC.Types.Type) (b :: GHC.Types.Type) - (t :: D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)). - Sing t -> Sing (Apply D2BSym0 t :: b) + (t :: D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)). Sing t + -> Sing (Apply D2BSym0 t :: b) sD2A :: forall (a :: GHC.Types.Type) (b :: GHC.Types.Type) - (t :: D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)). - Sing t -> Sing (Apply D2ASym0 t :: a) + (t :: D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)). Sing t + -> Sing (Apply D2ASym0 t :: a) sD2B (SMkD2 _ (sField :: Sing field)) = sField sD2A (SMkD2 (sField :: Sing field) _) = sField instance SingI (D2BSym0 :: (~>) (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)) b) where sing = (singFun1 @D2BSym0) sD2B instance SingI (D2ASym0 :: (~>) (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)) a) where sing = (singFun1 @D2ASym0) sD2A - type SD2 :: forall (a :: GHC.Types.Type) (b :: GHC.Types.Type). - D2 a b -> GHC.Types.Type + type SD2 :: forall (a :: GHC.Types.Type) + (b :: GHC.Types.Type). D2 a b -> GHC.Types.Type data SD2 :: forall (a :: GHC.Types.Type) (b :: GHC.Types.Type). D2 a b -> GHC.Types.Type where @@ -373,16 +390,24 @@ type Demote (D2 a b) = D2 (Demote a) (Demote b) fromSing (SMkD2 b b) = (MkD2 (fromSing b)) (fromSing b) toSing (MkD2 (b :: Demote a) (b :: Demote b)) - = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkD2 c) c) } + = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SMkD2 c) c) infixr 5 `SMkD2` infixr 5 `sD2A` infixr 5 `sD2B` instance (SingI n, SingI n) => SingI ('MkD2 (n :: a) (n :: b)) where sing = (SMkD2 sing) sing + instance SingI n => SingI1 ('MkD2 (n :: a)) where + liftSing = SMkD2 sing + instance SingI2 'MkD2 where + liftSing2 = SMkD2 instance SingI (MkD2Sym0 :: (~>) a ((~>) b (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type)))) where sing = (singFun2 @MkD2Sym0) SMkD2 instance SingI d => SingI (MkD2Sym1 (d :: a) :: (~>) b (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type))) where sing = (singFun1 @(MkD2Sym1 (d :: a))) (SMkD2 (sing @d)) + instance SingI1 (MkD2Sym1 :: a + -> (~>) b (D2 (a :: GHC.Types.Type) (b :: GHC.Types.Type))) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @(MkD2Sym1 (d :: a))) (SMkD2 s) diff --git a/tests/compile-and-dump/Singletons/T414.golden b/tests/compile-and-dump/Singletons/T414.golden --- a/tests/compile-and-dump/Singletons/T414.golden +++ b/tests/compile-and-dump/Singletons/T414.golden @@ -10,12 +10,12 @@ type T3 a b |] ======> class C1 (a :: Bool) where - type T1 a b + type family T1 a b class C2 a where - type T2 a b + type family T2 a b type C3 :: Bool -> Constraint class C3 a where - type T3 a b + type family T3 a b data T1Sym0 a0123456789876543210 where T1Sym0KindInference :: SameKind (Apply T1Sym0 arg) (T1Sym1 arg) => diff --git a/tests/compile-and-dump/Singletons/T443.golden b/tests/compile-and-dump/Singletons/T443.golden --- a/tests/compile-and-dump/Singletons/T443.golden +++ b/tests/compile-and-dump/Singletons/T443.golden @@ -77,11 +77,11 @@ type family Head (a :: Vec (S n) a) :: a where Head ((:>) field _) = field sTail :: - forall n a (t :: Vec (S n) a). - Sing t -> Sing (Apply TailSym0 t :: Vec n a) + forall n a (t :: Vec (S n) a). Sing t + -> Sing (Apply TailSym0 t :: Vec n a) sHead :: - forall n a (t :: Vec (S n) a). - Sing t -> Sing (Apply HeadSym0 t :: a) + forall n a (t :: Vec (S n) a). Sing t + -> Sing (Apply HeadSym0 t :: a) sTail ((:%>) _ (sField :: Sing field)) = sField sHead ((:%>) (sField :: Sing field) _) = sField instance SingI (TailSym0 :: (~>) (Vec (S n) a) (Vec n a)) where @@ -103,6 +103,8 @@ sing = SZ instance SingI n => SingI (S (n :: Nat)) where sing = SS sing + instance SingI1 S where + liftSing = SS instance SingI (SSym0 :: (~>) Nat Nat) where sing = (singFun1 @SSym0) SS instance SingI VNil where @@ -110,8 +112,16 @@ instance (SingI n, SingI n) => SingI ((:>) (n :: a) (n :: Vec n a)) where sing = ((:%>) sing) sing + instance SingI n => SingI1 ((:>) (n :: a)) where + liftSing = (:%>) sing + instance SingI2 (:>) where + liftSing2 = (:%>) instance SingI ((:>@#@$) :: (~>) a ((~>) (Vec n a) (Vec (S n) a))) where sing = (singFun2 @(:>@#@$)) (:%>) instance SingI d => SingI ((:>@#@$$) (d :: a) :: (~>) (Vec n a) (Vec (S n) a)) where sing = (singFun1 @((:>@#@$$) (d :: a))) ((:%>) (sing @d)) + instance SingI1 ((:>@#@$$) :: a + -> (~>) (Vec n a) (Vec (S n) a)) where + liftSing (s :: Sing (d :: a)) + = (singFun1 @((:>@#@$$) (d :: a))) ((:%>) s) diff --git a/tests/compile-and-dump/Singletons/T445.golden b/tests/compile-and-dump/Singletons/T445.golden --- a/tests/compile-and-dump/Singletons/T445.golden +++ b/tests/compile-and-dump/Singletons/T445.golden @@ -1,16 +1,16 @@ Singletons/T445.hs:0:0:: Splicing declarations genDefunSymbols [''Lit] ======> - type LitSym0 :: (~>) Lit.Nat Nat - data LitSym0 :: (~>) Lit.Nat Nat + type LitSym0 :: (~>) Natural Nat + data LitSym0 :: (~>) Natural Nat where LitSym0KindInference :: SameKind (Apply LitSym0 arg) (LitSym1 arg) => LitSym0 a0123456789876543210 type instance Apply LitSym0 a0123456789876543210 = Lit a0123456789876543210 instance SuppressUnusedWarnings LitSym0 where suppressUnusedWarnings = snd (((,) LitSym0KindInference) ()) - type LitSym1 :: Lit.Nat -> Nat - type family LitSym1 (a0123456789876543210 :: Lit.Nat) :: Nat where + type LitSym1 :: Natural -> Nat + type family LitSym1 (a0123456789876543210 :: Natural) :: Nat where LitSym1 a0123456789876543210 = Lit a0123456789876543210 Singletons/T445.hs:(0,0)-(0,0): Splicing declarations promoteOnly diff --git a/tests/compile-and-dump/Singletons/T445.hs b/tests/compile-and-dump/Singletons/T445.hs --- a/tests/compile-and-dump/Singletons/T445.hs +++ b/tests/compile-and-dump/Singletons/T445.hs @@ -2,10 +2,11 @@ import Data.Singletons.TH import qualified GHC.TypeLits as Lit +import Numeric.Natural (Natural) import Prelude.Singletons import Singletons.Nat -type Lit :: Lit.Nat -> Nat +type Lit :: Natural -> Nat type family Lit n where Lit 0 = Zero Lit n = Succ (Lit (n Lit.- 1)) diff --git a/tests/compile-and-dump/Singletons/T450.golden b/tests/compile-and-dump/Singletons/T450.golden --- a/tests/compile-and-dump/Singletons/T450.golden +++ b/tests/compile-and-dump/Singletons/T450.golden @@ -10,15 +10,6 @@ defunctionalizedName = \ n sat -> defunctionalizedName defaultOptions (customPromote customs n) sat} - ageDecs <- withOptions - (customOptions - [(''Age, ''PAge), ('MkAge, 'PMkAge), (''Natural, ''Nat)]) - $ do ageDecs1 <- genSingletons [''Age] - ageDecs2 <- singletons - [d| addAge :: Age -> Age -> Age - addAge (MkAge (x :: Natural)) (MkAge (y :: Natural)) - = MkAge (x + y :: Natural) |] - pure $ ageDecs1 ++ ageDecs2 messageDecs <- withOptions (customOptions [(''Message, ''PMessage), ('MkMessage, 'PMkMessage), @@ -43,73 +34,8 @@ (MkFunction (g :: a -> b)) = MkFunction (f . g :: a -> c) |] pure $ functionDecs1 ++ functionDecs2 - pure $ ageDecs ++ messageDecs ++ functionDecs + pure $ messageDecs ++ functionDecs ======> - type PMkAgeSym0 :: (~>) Nat PAge - data PMkAgeSym0 :: (~>) Nat PAge - where - PMkAgeSym0KindInference :: SameKind (Apply PMkAgeSym0 arg) (PMkAgeSym1 arg) => - PMkAgeSym0 a0123456789876543210 - type instance Apply PMkAgeSym0 a0123456789876543210 = 'PMkAge a0123456789876543210 - instance SuppressUnusedWarnings PMkAgeSym0 where - suppressUnusedWarnings = snd (((,) PMkAgeSym0KindInference) ()) - type PMkAgeSym1 :: Nat -> PAge - type family PMkAgeSym1 (a0123456789876543210 :: Nat) :: PAge where - PMkAgeSym1 a0123456789876543210 = 'PMkAge a0123456789876543210 - type SAge :: PAge -> GHC.Types.Type - data SAge :: PAge -> GHC.Types.Type - where - SMkAge :: forall (n :: Nat). (Sing n) -> SAge ('PMkAge n :: PAge) - type instance Sing @PAge = SAge - instance SingKind PAge where - type Demote PAge = Age - fromSing (SMkAge b) = MkAge (fromSing b) - toSing (MkAge (b :: Demote Nat)) - = case toSing b :: SomeSing Nat of { - SomeSing c -> SomeSing (SMkAge c) } - instance SingI n => SingI ('PMkAge (n :: Nat)) where - sing = SMkAge sing - instance SingI (PMkAgeSym0 :: (~>) Nat PAge) where - sing = (singFun1 @PMkAgeSym0) SMkAge - addAge :: Age -> Age -> Age - addAge (MkAge (x :: Natural)) (MkAge (y :: Natural)) - = MkAge ((x + y) :: Natural) - type AddAgeSym0 :: (~>) PAge ((~>) PAge PAge) - data AddAgeSym0 :: (~>) PAge ((~>) PAge PAge) - where - AddAgeSym0KindInference :: SameKind (Apply AddAgeSym0 arg) (AddAgeSym1 arg) => - AddAgeSym0 a0123456789876543210 - type instance Apply AddAgeSym0 a0123456789876543210 = AddAgeSym1 a0123456789876543210 - instance SuppressUnusedWarnings AddAgeSym0 where - suppressUnusedWarnings = snd (((,) AddAgeSym0KindInference) ()) - type AddAgeSym1 :: PAge -> (~>) PAge PAge - data AddAgeSym1 (a0123456789876543210 :: PAge) :: (~>) PAge PAge - where - AddAgeSym1KindInference :: SameKind (Apply (AddAgeSym1 a0123456789876543210) arg) (AddAgeSym2 a0123456789876543210 arg) => - AddAgeSym1 a0123456789876543210 a0123456789876543210 - type instance Apply (AddAgeSym1 a0123456789876543210) a0123456789876543210 = AddAge a0123456789876543210 a0123456789876543210 - instance SuppressUnusedWarnings (AddAgeSym1 a0123456789876543210) where - suppressUnusedWarnings = snd (((,) AddAgeSym1KindInference) ()) - type AddAgeSym2 :: PAge -> PAge -> PAge - type family AddAgeSym2 (a0123456789876543210 :: PAge) (a0123456789876543210 :: PAge) :: PAge where - AddAgeSym2 a0123456789876543210 a0123456789876543210 = AddAge a0123456789876543210 a0123456789876543210 - type AddAge :: PAge -> PAge -> PAge - type family AddAge (a :: PAge) (a :: PAge) :: PAge where - AddAge ('PMkAge (x :: Nat)) ('PMkAge (y :: Nat)) = Apply PMkAgeSym0 (Apply (Apply (+@#@$) x) y :: Nat) - sAddAge :: - forall (t :: PAge) (t :: PAge). - Sing t -> Sing t -> Sing (Apply (Apply AddAgeSym0 t) t :: PAge) - sAddAge (SMkAge (sX :: Sing x)) (SMkAge (sY :: Sing y)) - = case ((,) (sX :: Sing x)) (sY :: Sing y) of { - (,) (_ :: Sing (x :: Nat)) (_ :: Sing (y :: Nat)) - -> (applySing ((singFun1 @PMkAgeSym0) SMkAge)) - ((applySing ((applySing ((singFun2 @(+@#@$)) (%+))) sX)) sY :: - Sing (Apply (Apply (+@#@$) x) y :: Nat)) } - instance SingI (AddAgeSym0 :: (~>) PAge ((~>) PAge PAge)) where - sing = (singFun2 @AddAgeSym0) sAddAge - instance SingI d => - SingI (AddAgeSym1 (d :: PAge) :: (~>) PAge PAge) where - sing = (singFun1 @(AddAgeSym1 (d :: PAge))) (sAddAge (sing @d)) type PMkMessageSym0 :: (~>) Symbol PMessage data PMkMessageSym0 :: (~>) Symbol PMessage where @@ -131,10 +57,12 @@ type Demote PMessage = Message fromSing (SMkMessage b) = MkMessage (fromSing b) toSing (MkMessage (b :: Demote Symbol)) - = case toSing b :: SomeSing Symbol of { - SomeSing c -> SomeSing (SMkMessage c) } + = case toSing b :: SomeSing Symbol of + SomeSing c -> SomeSing (SMkMessage c) instance SingI n => SingI ('PMkMessage (n :: Symbol)) where sing = SMkMessage sing + instance SingI1 'PMkMessage where + liftSing = SMkMessage instance SingI (PMkMessageSym0 :: (~>) Symbol PMessage) where sing = (singFun1 @PMkMessageSym0) SMkMessage appendMessage :: Message -> Message -> Message @@ -165,17 +93,17 @@ type family AppendMessage (a :: PMessage) (a :: PMessage) :: PMessage where AppendMessage ('PMkMessage (x :: Symbol)) ('PMkMessage (y :: Symbol)) = Apply PMkMessageSym0 (Apply (Apply (<>@#@$) x) y :: Symbol) sAppendMessage :: - forall (t :: PMessage) (t :: PMessage). - Sing t - -> Sing t -> Sing (Apply (Apply AppendMessageSym0 t) t :: PMessage) + forall (t :: PMessage) (t :: PMessage). Sing t + -> Sing t + -> Sing (Apply (Apply AppendMessageSym0 t) t :: PMessage) sAppendMessage (SMkMessage (sX :: Sing x)) (SMkMessage (sY :: Sing y)) - = case ((,) (sX :: Sing x)) (sY :: Sing y) of { + = case ((,) (sX :: Sing x)) (sY :: Sing y) of (,) (_ :: Sing (x :: Symbol)) (_ :: Sing (y :: Symbol)) -> (applySing ((singFun1 @PMkMessageSym0) SMkMessage)) ((applySing ((applySing ((singFun2 @(<>@#@$)) (%<>))) sX)) sY :: - Sing (Apply (Apply (<>@#@$) x) y :: Symbol)) } + Sing (Apply (Apply (<>@#@$) x) y :: Symbol)) instance SingI (AppendMessageSym0 :: (~>) PMessage ((~>) PMessage PMessage)) where sing = (singFun2 @AppendMessageSym0) sAppendMessage instance SingI d => @@ -183,9 +111,13 @@ sing = (singFun1 @(AppendMessageSym1 (d :: PMessage))) (sAppendMessage (sing @d)) + instance SingI1 (AppendMessageSym1 :: PMessage + -> (~>) PMessage PMessage) where + liftSing (s :: Sing (d :: PMessage)) + = (singFun1 @(AppendMessageSym1 (d :: PMessage))) + (sAppendMessage s) type PMkFunctionSym0 :: forall (a :: GHC.Types.Type) - (b :: GHC.Types.Type). - (~>) ((~>) a b) (PFunction (a :: GHC.Types.Type) (b :: GHC.Types.Type)) + (b :: GHC.Types.Type). (~>) ((~>) a b) (PFunction (a :: GHC.Types.Type) (b :: GHC.Types.Type)) data PMkFunctionSym0 :: (~>) ((~>) a b) (PFunction (a :: GHC.Types.Type) (b :: GHC.Types.Type)) where PMkFunctionSym0KindInference :: SameKind (Apply PMkFunctionSym0 arg) (PMkFunctionSym1 arg) => @@ -195,13 +127,12 @@ suppressUnusedWarnings = snd (((,) PMkFunctionSym0KindInference) ()) type PMkFunctionSym1 :: forall (a :: GHC.Types.Type) - (b :: GHC.Types.Type). - (~>) a b -> PFunction (a :: GHC.Types.Type) (b :: GHC.Types.Type) + (b :: GHC.Types.Type). (~>) a b + -> PFunction (a :: GHC.Types.Type) (b :: GHC.Types.Type) type family PMkFunctionSym1 (a0123456789876543210 :: (~>) a b) :: PFunction (a :: GHC.Types.Type) (b :: GHC.Types.Type) where PMkFunctionSym1 a0123456789876543210 = 'PMkFunction a0123456789876543210 type SFunction :: forall (a :: GHC.Types.Type) - (b :: GHC.Types.Type). - PFunction a b -> GHC.Types.Type + (b :: GHC.Types.Type). PFunction a b -> GHC.Types.Type data SFunction :: forall (a :: GHC.Types.Type) (b :: GHC.Types.Type). PFunction a b -> GHC.Types.Type @@ -216,10 +147,12 @@ type Demote (PFunction a b) = Function (Demote a) (Demote b) fromSing (SMkFunction b) = MkFunction (fromSing b) toSing (MkFunction (b :: Demote ((~>) a b))) - = case toSing b :: SomeSing ((~>) a b) of { - SomeSing c -> SomeSing (SMkFunction c) } + = case toSing b :: SomeSing ((~>) a b) of + SomeSing c -> SomeSing (SMkFunction c) instance SingI n => SingI ('PMkFunction (n :: (~>) a b)) where sing = SMkFunction sing + instance SingI1 'PMkFunction where + liftSing = SMkFunction instance SingI (PMkFunctionSym0 :: (~>) ((~>) a b) (PFunction (a :: GHC.Types.Type) (b :: GHC.Types.Type))) where sing = (singFun1 @PMkFunctionSym0) SMkFunction composeFunction :: Function b c -> Function a b -> Function a c @@ -255,18 +188,17 @@ type family ComposeFunction (a :: PFunction b c) (a :: PFunction a b) :: PFunction a c where ComposeFunction ('PMkFunction (f :: (~>) b c)) ('PMkFunction (g :: (~>) a b)) = Apply PMkFunctionSym0 (Apply (Apply (.@#@$) f) g :: (~>) a c) sComposeFunction :: - forall b c a (t :: PFunction b c) (t :: PFunction a b). - Sing t - -> Sing t - -> Sing (Apply (Apply ComposeFunctionSym0 t) t :: PFunction a c) + forall b c a (t :: PFunction b c) (t :: PFunction a b). Sing t + -> Sing t + -> Sing (Apply (Apply ComposeFunctionSym0 t) t :: PFunction a c) sComposeFunction (SMkFunction (sF :: Sing f)) (SMkFunction (sG :: Sing g)) - = case ((,) (sF :: Sing f)) (sG :: Sing g) of { + = case ((,) (sF :: Sing f)) (sG :: Sing g) of (,) (_ :: Sing (f :: (~>) b c)) (_ :: Sing (g :: (~>) a b)) -> (applySing ((singFun1 @PMkFunctionSym0) SMkFunction)) ((applySing ((applySing ((singFun3 @(.@#@$)) (%.))) sF)) sG :: - Sing (Apply (Apply (.@#@$) f) g :: (~>) a c)) } + Sing (Apply (Apply (.@#@$) f) g :: (~>) a c)) instance SingI (ComposeFunctionSym0 :: (~>) (PFunction b c) ((~>) (PFunction a b) (PFunction a c))) where sing = (singFun2 @ComposeFunctionSym0) sComposeFunction instance SingI d => @@ -274,3 +206,8 @@ sing = (singFun1 @(ComposeFunctionSym1 (d :: PFunction b c))) (sComposeFunction (sing @d)) + instance SingI1 (ComposeFunctionSym1 :: PFunction b c + -> (~>) (PFunction a b) (PFunction a c)) where + liftSing (s :: Sing (d :: PFunction b c)) + = (singFun1 @(ComposeFunctionSym1 (d :: PFunction b c))) + (sComposeFunction s) diff --git a/tests/compile-and-dump/Singletons/T450.hs b/tests/compile-and-dump/Singletons/T450.hs --- a/tests/compile-and-dump/Singletons/T450.hs +++ b/tests/compile-and-dump/Singletons/T450.hs @@ -6,12 +6,7 @@ import Data.Text (Text) import Language.Haskell.TH (Name) import Prelude.Singletons -import GHC.TypeNats (Nat) -import Numeric.Natural (Natural) -newtype Age = MkAge Natural -newtype PAge = PMkAge Nat - newtype Message = MkMessage Text newtype PMessage = PMkMessage Symbol @@ -31,19 +26,6 @@ (customPromote customs n) sat } - ageDecs <- - withOptions (customOptions [ (''Age, ''PAge) - , ('MkAge, 'PMkAge) - , (''Natural, ''Nat) - ]) $ do - ageDecs1 <- genSingletons [''Age] - ageDecs2 <- singletons [d| - addAge :: Age -> Age -> Age - addAge (MkAge (x :: Natural)) (MkAge (y :: Natural)) = - MkAge (x + y :: Natural) - |] - pure $ ageDecs1 ++ ageDecs2 - messageDecs <- withOptions (customOptions [ (''Message, ''PMessage) , ('MkMessage, 'PMkMessage) @@ -68,4 +50,4 @@ MkFunction (f . g :: a -> c) |] pure $ functionDecs1 ++ functionDecs2 - pure $ ageDecs ++ messageDecs ++ functionDecs) + pure $ messageDecs ++ functionDecs) diff --git a/tests/compile-and-dump/Singletons/T470.golden b/tests/compile-and-dump/Singletons/T470.golden --- a/tests/compile-and-dump/Singletons/T470.golden +++ b/tests/compile-and-dump/Singletons/T470.golden @@ -58,11 +58,10 @@ fromSing (SMkT1 b) = MkT1 (fromSing b) fromSing (SMkT2 b) = MkT2 (fromSing b) toSing (MkT1 (b :: Demote a)) - = case toSing b :: SomeSing a of { - SomeSing c -> SomeSing (SMkT1 c) } + = case toSing b :: SomeSing a of SomeSing c -> SomeSing (SMkT1 c) toSing (MkT2 (b :: Demote Void)) - = case toSing b :: SomeSing Void of { - SomeSing c -> SomeSing (SMkT2 c) } + = case toSing b :: SomeSing Void of + SomeSing c -> SomeSing (SMkT2 c) data SS :: S -> Type where SMkS :: forall (n :: Bool). !(Sing n) -> SS (MkS n :: S) type instance Sing @S = SS @@ -70,18 +69,23 @@ type Demote S = S fromSing (SMkS b) = MkS (fromSing b) toSing (MkS (b :: Demote Bool)) - = case toSing b :: SomeSing Bool of { - SomeSing c -> SomeSing (SMkS c) } + = case toSing b :: SomeSing Bool of SomeSing c -> SomeSing (SMkS c) instance SingI n => SingI (MkT1 (n :: a)) where sing = SMkT1 sing + instance SingI1 MkT1 where + liftSing = SMkT1 instance SingI (MkT1Sym0 :: (~>) a (T a)) where sing = (singFun1 @MkT1Sym0) SMkT1 instance SingI n => SingI (MkT2 (n :: Void)) where sing = SMkT2 sing + instance SingI1 MkT2 where + liftSing = SMkT2 instance SingI (MkT2Sym0 :: (~>) Void (T a)) where sing = (singFun1 @MkT2Sym0) SMkT2 instance SingI n => SingI (MkS (n :: Bool)) where sing = SMkS sing + instance SingI1 MkS where + liftSing = SMkS instance SingI (MkSSym0 :: (~>) Bool S) where sing = (singFun1 @MkSSym0) SMkS diff --git a/tests/compile-and-dump/Singletons/T480.golden b/tests/compile-and-dump/Singletons/T480.golden new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/T480.golden @@ -0,0 +1,14 @@ + +Singletons/T480.hs:0:0: error: Q monad failure + | +5 | $(singletons + | ^^^^^^^^^^^... + +Singletons/T480.hs:0:0: error: + `singletons-th` does not support wildcard types + unless they appear in visible type patterns of data constructors + In the type: _ + + | +5 | $(singletons + | ^^^^^^^^^^^... diff --git a/tests/compile-and-dump/Singletons/T480.hs b/tests/compile-and-dump/Singletons/T480.hs new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/T480.hs @@ -0,0 +1,8 @@ +module T480 where + +import Data.Singletons.TH + +$(singletons + [d| f :: _ -> _ + f x = x + |]) diff --git a/tests/compile-and-dump/Singletons/T487.golden b/tests/compile-and-dump/Singletons/T487.golden new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/T487.golden @@ -0,0 +1,73 @@ +Singletons/T487.hs:(0,0)-(0,0): Splicing declarations + singletonsOnly + [d| exprEx :: Char + exprEx = 'a' + consEx :: Char -> Symbol + consEx x = consSymbol x "bc" + unconsEx :: Maybe (Char, Symbol) + unconsEx = unconsSymbol "abc" + natToCharEx :: Char + natToCharEx = natToChar 97 + charToNatEx :: Natural + charToNatEx = charToNat 'a' |] + ======> + type CharToNatExSym0 :: Natural + type family CharToNatExSym0 :: Natural where + CharToNatExSym0 = CharToNatEx + type NatToCharExSym0 :: Char + type family NatToCharExSym0 :: Char where + NatToCharExSym0 = NatToCharEx + type UnconsExSym0 :: Maybe (Char, Symbol) + type family UnconsExSym0 :: Maybe (Char, Symbol) where + UnconsExSym0 = UnconsEx + type ConsExSym0 :: (~>) Char Symbol + data ConsExSym0 :: (~>) Char Symbol + where + ConsExSym0KindInference :: SameKind (Apply ConsExSym0 arg) (ConsExSym1 arg) => + ConsExSym0 a0123456789876543210 + type instance Apply ConsExSym0 a0123456789876543210 = ConsEx a0123456789876543210 + instance SuppressUnusedWarnings ConsExSym0 where + suppressUnusedWarnings = snd (((,) ConsExSym0KindInference) ()) + type ConsExSym1 :: Char -> Symbol + type family ConsExSym1 (a0123456789876543210 :: Char) :: Symbol where + ConsExSym1 a0123456789876543210 = ConsEx a0123456789876543210 + type ExprExSym0 :: Char + type family ExprExSym0 :: Char where + ExprExSym0 = ExprEx + type CharToNatEx :: Natural + type family CharToNatEx :: Natural where + CharToNatEx = Apply CharToNatSym0 'a' + type NatToCharEx :: Char + type family NatToCharEx :: Char where + NatToCharEx = Apply NatToCharSym0 (FromInteger 97) + type UnconsEx :: Maybe (Char, Symbol) + type family UnconsEx :: Maybe (Char, Symbol) where + UnconsEx = Apply UnconsSymbolSym0 "abc" + type ConsEx :: Char -> Symbol + type family ConsEx (a :: Char) :: Symbol where + ConsEx x = Apply (Apply ConsSymbolSym0 x) "bc" + type ExprEx :: Char + type family ExprEx :: Char where + ExprEx = 'a' + sCharToNatEx :: Sing (CharToNatExSym0 :: Natural) + sNatToCharEx :: Sing (NatToCharExSym0 :: Char) + sUnconsEx :: Sing (UnconsExSym0 :: Maybe (Char, Symbol)) + sConsEx :: + forall (t :: Char). Sing t -> Sing (Apply ConsExSym0 t :: Symbol) + sExprEx :: Sing (ExprExSym0 :: Char) + sCharToNatEx + = (applySing ((singFun1 @CharToNatSym0) sCharToNat)) + (sing :: Sing 'a') + sNatToCharEx + = (applySing ((singFun1 @NatToCharSym0) sNatToChar)) + (sFromInteger (sing :: Sing 97)) + sUnconsEx + = (applySing ((singFun1 @UnconsSymbolSym0) sUnconsSymbol)) + (sing :: Sing "abc") + sConsEx (sX :: Sing x) + = (applySing + ((applySing ((singFun2 @ConsSymbolSym0) sConsSymbol)) sX)) + (sing :: Sing "bc") + sExprEx = sing :: Sing 'a' + instance SingI (ConsExSym0 :: (~>) Char Symbol) where + sing = (singFun1 @ConsExSym0) sConsEx diff --git a/tests/compile-and-dump/Singletons/T487.hs b/tests/compile-and-dump/Singletons/T487.hs new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/T487.hs @@ -0,0 +1,40 @@ +module T487 where + +import Data.Singletons.Base.TH +import GHC.TypeLits.Singletons +import Text.Show.Singletons + +$(singletonsOnly [d| + exprEx :: Char + exprEx = 'a' + + consEx :: Char -> Symbol + consEx x = consSymbol x "bc" + + unconsEx :: Maybe (Char, Symbol) + unconsEx = unconsSymbol "abc" + + natToCharEx :: Char + natToCharEx = natToChar 97 + + charToNatEx :: Natural + charToNatEx = charToNat 'a' + |]) + +showCharTest :: Show_ ExprEx :~: "'a'" +showCharTest = Refl + +showSymbolTest :: Show_ "Hello, World!" :~: "\"Hello, World!\"" +showSymbolTest = Refl + +consSymbolTest :: ConsEx 'a' :~: "abc" +consSymbolTest = Refl + +unconsSymbolTest :: UnconsEx :~: Just '( 'a', "bc" ) +unconsSymbolTest = Refl + +natToCharTest :: NatToCharEx :~: 'a' +natToCharTest = Refl + +charToNatTest :: CharToNatEx :~: 97 +charToNatTest = Refl diff --git a/tests/compile-and-dump/Singletons/T489.golden b/tests/compile-and-dump/Singletons/T489.golden new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/T489.golden @@ -0,0 +1,60 @@ +Singletons/T489.hs:(0,0)-(0,0): Splicing declarations + singletons + [d| blah :: Maybe a -> [a] + blah (Just @a x) = [x :: a] + blah (Nothing @a) = [] :: [a] + flurmp :: Maybe () -> () + flurmp (Nothing @_) = () + flurmp (Just ()) = () |] + ======> + blah :: Maybe a -> [a] + blah (Just @a x) = [x :: a] + blah (Nothing @a) = [] :: [a] + flurmp :: Maybe () -> () + flurmp (Nothing @_) = () + flurmp (Just ()) = () + type FlurmpSym0 :: (~>) (Maybe ()) () + data FlurmpSym0 :: (~>) (Maybe ()) () + where + FlurmpSym0KindInference :: SameKind (Apply FlurmpSym0 arg) (FlurmpSym1 arg) => + FlurmpSym0 a0123456789876543210 + type instance Apply FlurmpSym0 a0123456789876543210 = Flurmp a0123456789876543210 + instance SuppressUnusedWarnings FlurmpSym0 where + suppressUnusedWarnings = snd (((,) FlurmpSym0KindInference) ()) + type FlurmpSym1 :: Maybe () -> () + type family FlurmpSym1 (a0123456789876543210 :: Maybe ()) :: () where + FlurmpSym1 a0123456789876543210 = Flurmp a0123456789876543210 + type BlahSym0 :: (~>) (Maybe a) [a] + data BlahSym0 :: (~>) (Maybe a) [a] + where + BlahSym0KindInference :: SameKind (Apply BlahSym0 arg) (BlahSym1 arg) => + BlahSym0 a0123456789876543210 + type instance Apply BlahSym0 a0123456789876543210 = Blah a0123456789876543210 + instance SuppressUnusedWarnings BlahSym0 where + suppressUnusedWarnings = snd (((,) BlahSym0KindInference) ()) + type BlahSym1 :: Maybe a -> [a] + type family BlahSym1 (a0123456789876543210 :: Maybe a) :: [a] where + BlahSym1 a0123456789876543210 = Blah a0123456789876543210 + type Flurmp :: Maybe () -> () + type family Flurmp (a :: Maybe ()) :: () where + Flurmp ('Nothing @_) = Tuple0Sym0 + Flurmp ('Just '()) = Tuple0Sym0 + type Blah :: Maybe a -> [a] + type family Blah (a :: Maybe a) :: [a] where + Blah ('Just @a x) = Apply (Apply (:@#@$) (x :: a)) NilSym0 + Blah ('Nothing @a) = NilSym0 :: [a] + sFlurmp :: + forall (t :: Maybe ()). Sing t -> Sing (Apply FlurmpSym0 t :: ()) + sBlah :: + forall a (t :: Maybe a). Sing t -> Sing (Apply BlahSym0 t :: [a]) + sFlurmp (SNothing @_) = STuple0 + sFlurmp (SJust STuple0) = STuple0 + sBlah (SJust @a (sX :: Sing x)) + = (applySing + ((applySing ((singFun2 @(:@#@$)) SCons)) (sX :: Sing (x :: a)))) + SNil + sBlah (SNothing @a) = SNil :: Sing (NilSym0 :: [a]) + instance SingI (FlurmpSym0 :: (~>) (Maybe ()) ()) where + sing = (singFun1 @FlurmpSym0) sFlurmp + instance SingI (BlahSym0 :: (~>) (Maybe a) [a]) where + sing = (singFun1 @BlahSym0) sBlah diff --git a/tests/compile-and-dump/Singletons/T489.hs b/tests/compile-and-dump/Singletons/T489.hs new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/T489.hs @@ -0,0 +1,14 @@ +module T489 where + +import Data.Singletons.Base.TH +import Prelude.Singletons + +$(singletons [d| + blah :: Maybe a -> [a] + blah (Just @a x) = [x :: a] + blah (Nothing @a) = [] :: [a] + + flurmp :: Maybe () -> () + flurmp (Nothing @_) = () + flurmp (Just ()) = () + |]) diff --git a/tests/compile-and-dump/Singletons/T492.golden b/tests/compile-and-dump/Singletons/T492.golden new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/T492.golden diff --git a/tests/compile-and-dump/Singletons/T492.hs b/tests/compile-and-dump/Singletons/T492.hs new file mode 100644 --- /dev/null +++ b/tests/compile-and-dump/Singletons/T492.hs @@ -0,0 +1,25 @@ +module T492 where + +import Data.Functor.Const +import Data.Functor.Const.Singletons +import Data.Proxy +import Data.Proxy.Singletons +import Prelude.Singletons hiding (Const, ConstSym0, ConstSym1) + +f :: Const Bool Ordering +f = Const @Bool @Ordering True + +sF1 :: SConst ('Const @Bool @Ordering True) +sF1 = SConst @Bool @Ordering STrue + +sF2 :: SConst (ConstSym0 @Bool @Ordering @@ True) +sF2 = singFun1 @(ConstSym0 @Bool @Ordering) SConst @@ STrue + +sF3 :: SConst (ConstSym1 @Bool @Ordering True) +sF3 = SConst @Bool @Ordering STrue + +sP1 :: SProxy ('Proxy @Bool) +sP1 = SProxy @Bool + +sP2 :: SProxy (ProxySym0 @Bool) +sP2 = SProxy @Bool diff --git a/tests/compile-and-dump/Singletons/T54.golden b/tests/compile-and-dump/Singletons/T54.golden --- a/tests/compile-and-dump/Singletons/T54.golden +++ b/tests/compile-and-dump/Singletons/T54.golden @@ -1,10 +1,10 @@ Singletons/T54.hs:(0,0)-(0,0): Splicing declarations singletons [d| g :: Bool -> Bool - g e = (case [not] of { [_] -> not }) e |] + g e = (case [not] of [_] -> not) e |] ======> g :: Bool -> Bool - g e = (case [not] of { [_] -> not }) e + g e = (case [not] of [_] -> not) e data Let0123456789876543210Scrutinee_0123456789876543210Sym0 e0123456789876543210 where Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) => @@ -50,8 +50,8 @@ in (id @(Sing (Case_0123456789876543210 e (Let0123456789876543210Scrutinee_0123456789876543210Sym1 e)))) - (case sScrutinee_0123456789876543210 of { - SCons _ SNil -> (singFun1 @NotSym0) sNot }))) + (case sScrutinee_0123456789876543210 of + SCons _ SNil -> (singFun1 @NotSym0) sNot))) sE instance SingI (GSym0 :: (~>) Bool Bool) where sing = (singFun1 @GSym0) sG diff --git a/tests/compile-and-dump/Singletons/TopLevelPatterns.golden b/tests/compile-and-dump/Singletons/TopLevelPatterns.golden --- a/tests/compile-and-dump/Singletons/TopLevelPatterns.golden +++ b/tests/compile-and-dump/Singletons/TopLevelPatterns.golden @@ -54,8 +54,8 @@ toSing (Bar (b :: Demote Bool) (b :: Demote Bool)) = case ((,) (toSing b :: SomeSing Bool)) (toSing b :: SomeSing Bool) - of { - (,) (SomeSing c) (SomeSing c) -> SomeSing ((SBar c) c) } + of + (,) (SomeSing c) (SomeSing c) -> SomeSing ((SBar c) c) instance SingI False where sing = SFalse instance SingI True where @@ -63,11 +63,18 @@ instance (SingI n, SingI n) => SingI (Bar (n :: Bool) (n :: Bool)) where sing = (SBar sing) sing + instance SingI n => SingI1 (Bar (n :: Bool)) where + liftSing = SBar sing + instance SingI2 Bar where + liftSing2 = SBar instance SingI (BarSym0 :: (~>) Bool ((~>) Bool Foo)) where sing = (singFun2 @BarSym0) SBar instance SingI d => SingI (BarSym1 (d :: Bool) :: (~>) Bool Foo) where sing = (singFun1 @(BarSym1 (d :: Bool))) (SBar (sing @d)) + instance SingI1 (BarSym1 :: Bool -> (~>) Bool Foo) where + liftSing (s :: Sing (d :: Bool)) + = (singFun1 @(BarSym1 (d :: Bool))) (SBar s) Singletons/TopLevelPatterns.hs:(0,0)-(0,0): Splicing declarations singletons [d| otherwise :: Bool @@ -290,17 +297,17 @@ sM = (GHC.Base.id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of SCons _ (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210) SNil) - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sL = (GHC.Base.id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of SCons (sY_0123456789876543210 :: Sing y_0123456789876543210) (SCons _ SNil) - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sX_0123456789876543210 = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) @@ -312,15 +319,15 @@ sK = (GHC.Base.id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of SBar _ (sY_0123456789876543210 :: Sing y_0123456789876543210) - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sJ = (GHC.Base.id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of SBar (sY_0123456789876543210 :: Sing y_0123456789876543210) _ - -> sY_0123456789876543210 }) + -> sY_0123456789876543210) sX_0123456789876543210 = (applySing ((applySing ((singFun2 @BarSym0) SBar)) STrue)) ((applySing ((singFun1 @HSym0) sH)) SFalse) @@ -328,17 +335,17 @@ = (applySing ((GHC.Base.id @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of STuple2 _ (sY_0123456789876543210 :: Sing y_0123456789876543210) - -> sY_0123456789876543210 }))) + -> sY_0123456789876543210))) sA_0123456789876543210 sH (sA_0123456789876543210 :: Sing a_0123456789876543210) = (applySing ((GHC.Base.id @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of STuple2 (sY_0123456789876543210 :: Sing y_0123456789876543210) _ - -> sY_0123456789876543210 }))) + -> sY_0123456789876543210))) sA_0123456789876543210 sX_0123456789876543210 = (applySing @@ -349,19 +356,19 @@ = (applySing ((GHC.Base.id @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of SCons _ (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210) SNil) - -> sY_0123456789876543210 }))) + -> sY_0123456789876543210))) sA_0123456789876543210 sF (sA_0123456789876543210 :: Sing a_0123456789876543210) = (applySing ((GHC.Base.id @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0))) - (case sX_0123456789876543210 of { + (case sX_0123456789876543210 of SCons (sY_0123456789876543210 :: Sing y_0123456789876543210) (SCons _ SNil) - -> sY_0123456789876543210 }))) + -> sY_0123456789876543210))) sA_0123456789876543210 sX_0123456789876543210 = (applySing