diff --git a/CHANGES.md b/CHANGES.md --- a/CHANGES.md +++ b/CHANGES.md @@ -1,6 +1,17 @@ Changelog for singletons project ================================ +2.2 +--- +* With `TypeInType`, we no longer kind `KProxy`. @int-index has very helpfully +removed the use of `KProxy` from `singletons`. + +* Drop support for GHC 7.x. + +* Remove `bugInGHC`. That function was intended to work around GHC's difficulty +in detecting exhaustiveness of GADT pattern matches. GHC 8 comes with a much +better exhaustiveness checker, and so this function is no longer necessary. + 2.1 --- * Require `th-desugar` >= 1.6 diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -singletons 2.0 +singletons 2.2 ============== [![Build Status](https://travis-ci.org/goldfirere/singletons.svg?branch=master)](https://travis-ci.org/goldfirere/singletons) @@ -33,7 +33,7 @@ Compatibility ------------- -The singletons library requires GHC 7.10.2 or greater. Any code that uses the +The singletons library requires GHC 8.0.1 or greater. Any code that uses the singleton generation primitives needs to enable a long list of GHC extensions. This list includes, but is not necessarily limited to, the following: @@ -43,8 +43,6 @@ * `TypeFamilies` * `GADTs` * `KindSignatures` -* `DataKinds` -* `PolyKinds` * `TypeOperators` * `FlexibleContexts` * `RankNTypes` @@ -52,6 +50,14 @@ * `FlexibleInstances` * `InstanceSigs` * `DefaultSignatures` +* `TypeInType` + +You may also want + +* `-Wno-redundant-constraints` + +as the code that `singletons` generates uses redundant constraints, and there +seems to be no way, without a large library redesign, to avoid this. Modules for singleton types --------------------------- diff --git a/singletons.cabal b/singletons.cabal --- a/singletons.cabal +++ b/singletons.cabal @@ -1,5 +1,5 @@ name: singletons -version: 2.1 +version: 2.2 -- Remember to bump version in the Makefile as well cabal-version: >= 1.10 synopsis: A framework for generating singleton types @@ -9,17 +9,13 @@ maintainer: Richard Eisenberg , Jan Stolarek bug-reports: https://github.com/goldfirere/singletons/issues stability: experimental -tested-with: GHC >= 7.10.2 +tested-with: GHC == 8.0.1 extra-source-files: README.md, CHANGES.md, tests/compile-and-dump/buildGoldenFiles.awk, tests/compile-and-dump/GradingClient/*.hs, tests/compile-and-dump/InsertionSort/*.hs, tests/compile-and-dump/Promote/*.hs, tests/compile-and-dump/Singletons/*.hs - tests/compile-and-dump/GradingClient/*.ghc710.template, - tests/compile-and-dump/InsertionSort/*.ghc710.template, - tests/compile-and-dump/Promote/*.ghc710.template, - tests/compile-and-dump/Singletons/*.ghc710.template tests/compile-and-dump/GradingClient/*.ghc80.template, tests/compile-and-dump/InsertionSort/*.ghc80.template, tests/compile-and-dump/Promote/*.ghc80.template, @@ -42,11 +38,11 @@ source-repository this type: git location: https://github.com/goldfirere/singletons.git - tag: v2.1 + tag: v2.2 library hs-source-dirs: src - build-depends: base >= 4.8.1.0 && < 5, + build-depends: base >= 4.9 && < 5, mtl >= 2.1.2, template-haskell, containers >= 0.5, @@ -55,9 +51,7 @@ default-language: Haskell2010 other-extensions: TemplateHaskell -- TemplateHaskell must be listed in cabal file to work with - -- ghc7.8 - if impl(ghc >= 7.11) - ghc-options: -Wno-redundant-constraints + -- ghc7.8+ exposed-modules: Data.Singletons, Data.Singletons.CustomStar, @@ -111,7 +105,7 @@ Data.Singletons.TypeLits.Internal, Data.Singletons.Syntax - ghc-options: -Wall + ghc-options: -Wall -Wno-redundant-constraints test-suite singletons-test-suite type: exitcode-stdio-1.0 @@ -121,7 +115,7 @@ main-is: SingletonsTestSuite.hs other-modules: SingletonsTestSuiteUtils - build-depends: base >= 4.7.0.1 && < 5, + build-depends: base >= 4.9 && < 5, filepath >= 1.3, process >= 1.1, tasty >= 0.6, diff --git a/src/Data/Promotion/Prelude.hs b/src/Data/Promotion/Prelude.hs --- a/src/Data/Promotion/Prelude.hs +++ b/src/Data/Promotion/Prelude.hs @@ -71,7 +71,7 @@ Zip, Zip3, ZipWith, ZipWith3, Unzip, Unzip3, -- * Other datatypes - Proxy(..), KProxy(..), + Proxy(..), -- * Defunctionalization symbols FalseSym0, TrueSym0, @@ -153,7 +153,7 @@ (:!!$), (:!!$$), (:!!$$$), ) where -import Data.Proxy ( Proxy(..), KProxy(..) ) +import Data.Proxy ( Proxy(..) ) import Data.Promotion.Prelude.Base import Data.Promotion.Prelude.Bool import Data.Promotion.Prelude.Either diff --git a/src/Data/Promotion/TH.hs b/src/Data/Promotion/TH.hs --- a/src/Data/Promotion/TH.hs +++ b/src/Data/Promotion/TH.hs @@ -40,7 +40,7 @@ PEq(..), If, (:&&), POrd(..), Any, - Proxy(..), KProxy(..), ThenCmp, Foldl, + Proxy(..), ThenCmp, Foldl, Error, ErrorSym0, TrueSym0, FalseSym0, @@ -58,7 +58,6 @@ ) where -import Data.Proxy import Data.Singletons import Data.Singletons.Promote import Data.Singletons.Prelude.Instances diff --git a/src/Data/Singletons.hs b/src/Data/Singletons.hs --- a/src/Data/Singletons.hs +++ b/src/Data/Singletons.hs @@ -1,6 +1,7 @@ {-# LANGUAGE MagicHash, RankNTypes, PolyKinds, GADTs, DataKinds, - FlexibleContexts, TypeFamilies, TypeOperators, - UndecidableInstances #-} + FlexibleContexts, FlexibleInstances, + TypeFamilies, TypeOperators, + UndecidableInstances, TypeInType #-} ----------------------------------------------------------------------------- -- | @@ -39,7 +40,8 @@ withSing, singThat, -- ** Defunctionalization - TyFun, TyCon1, TyCon2, TyCon3, TyCon4, TyCon5, TyCon6, TyCon7, TyCon8, + TyFun, type (~>), + TyCon1, TyCon2, TyCon3, TyCon4, TyCon5, TyCon6, TyCon7, TyCon8, Apply, type (@@), -- ** Defunctionalized singletons @@ -56,17 +58,17 @@ SingFunction6, SingFunction7, SingFunction8, -- * Auxiliary functions - bugInGHC, - KProxy(..) + Proxy(..) ) where +import Data.Kind import Unsafe.Coerce -import Data.Proxy ( Proxy(..), KProxy(..) ) +import Data.Proxy ( Proxy(..) ) import GHC.Exts ( Proxy# ) -- | Convenient synonym to refer to the kind of a type variable: --- @type KindOf (a :: k) = ('KProxy :: KProxy k)@ -type KindOf (a :: k) = ('KProxy :: KProxy k) +-- @type KindOf (a :: k) = ('Proxy :: Proxy k)@ +type KindOf (a :: k) = ('Proxy :: Proxy k) ---------------------------------------------------------------------- ---- Sing & friends -------------------------------------------------- @@ -83,23 +85,23 @@ -- extension to use this method the way you want. sing :: Sing a --- | The 'SingKind' class is essentially a /kind/ class. It classifies all kinds +-- | The 'SingKind' class is a /kind/ class. It classifies all kinds -- for which singletons are defined. The class supports converting between a singleton -- type and the base (unrefined) type which it is built from. -class (kparam ~ 'KProxy) => SingKind (kparam :: KProxy k) where +class SingKind k where -- | Get a base type from a proxy for the promoted kind. For example, - -- @DemoteRep ('KProxy :: KProxy Bool)@ will be the type @Bool@. - type DemoteRep kparam :: * + -- @DemoteRep Bool@ will be the type @Bool@. + type DemoteRep k :: * -- | Convert a singleton to its unrefined version. - fromSing :: Sing (a :: k) -> DemoteRep kparam + fromSing :: Sing (a :: k) -> DemoteRep k -- | Convert an unrefined type to an existentially-quantified singleton type. - toSing :: DemoteRep kparam -> SomeSing kparam + toSing :: DemoteRep k -> SomeSing k -- | Convenient abbreviation for 'DemoteRep': --- @type Demote (a :: k) = DemoteRep ('KProxy :: KProxy k)@ -type Demote (a :: k) = DemoteRep ('KProxy :: KProxy k) +-- @type Demote (a :: k) = DemoteRep k@ +type Demote (a :: k) = DemoteRep k -- | An /existentially-quantified/ singleton. This type is useful when you want a -- singleton type, but there is no way of knowing, at compile-time, what the type @@ -111,8 +113,8 @@ -- > SomeSing sb -> {- fancy dependently-typed code with sb -} -- -- An example like the one above may be easier to write using 'withSomeSing'. -data SomeSing (kproxy :: KProxy k) where - SomeSing :: Sing (a :: k) -> SomeSing ('KProxy :: KProxy k) +data SomeSing k where + SomeSing :: Sing (a :: k) -> SomeSing k ---------------------------------------------------------------------- ---- SingInstance ---------------------------------------------------- @@ -142,30 +144,39 @@ -- applications have to be fully saturated. data TyFun :: * -> * -> * --- | Wrapper for converting the normal type-level arrow into a 'TyFun'. +-- | Something of kind `a ~> b` is a defunctionalized type function that is +-- not necessarily generative or injective. +type a ~> b = TyFun a b -> * +infixr 0 ~> + +-- | Wrapper for converting the normal type-level arrow into a '~>'. -- For example, given: -- -- > data Nat = Zero | Succ Nat --- > type family Map (a :: TyFun a b -> *) (a :: [a]) :: [b] +-- > type family Map (a :: a ~> b) (a :: [a]) :: [b] -- > Map f '[] = '[] -- > Map f (x ': xs) = Apply f x ': Map f xs -- -- We can write: -- -- > Map (TyCon1 Succ) [Zero, Succ Zero] -data TyCon1 :: (k1 -> k2) -> (TyFun k1 k2) -> * +data TyCon1 :: (k1 -> k2) -> (k1 ~> k2) -- | Similar to 'TyCon1', but for two-parameter type constructors. -data TyCon2 :: (k1 -> k2 -> k3) -> TyFun k1 (TyFun k2 k3 -> *) -> * -data TyCon3 :: (k1 -> k2 -> k3 -> k4) -> TyFun k1 (TyFun k2 (TyFun k3 k4 -> *) -> *) -> * -data TyCon4 :: (k1 -> k2 -> k3 -> k4 -> k5) -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 k5 -> *) -> *) -> *) -> * -data TyCon5 :: (k1 -> k2 -> k3 -> k4 -> k5 -> k6) -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 k6 -> *) -> *) -> *) -> *) -> * -data TyCon6 :: (k1 -> k2 -> k3 -> k4 -> k5 -> k6 -> k7) -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 (TyFun k6 k7 -> *) -> *) -> *) -> *) -> *) -> * -data TyCon7 :: (k1 -> k2 -> k3 -> k4 -> k5 -> k6 -> k7 -> k8) -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 (TyFun k6 (TyFun k7 k8 -> *) -> *) -> *) -> *) -> *) -> *) -> * -data TyCon8 :: (k1 -> k2 -> k3 -> k4 -> k5 -> k6 -> k7 -> k8 -> k9) -> TyFun k1 (TyFun k2 (TyFun k3 (TyFun k4 (TyFun k5 (TyFun k6 (TyFun k7 (TyFun k8 k9 -> *) -> *) -> *) -> *) -> *) -> *) -> *) -> * +data TyCon2 :: (k1 -> k2 -> k3) -> (k1 ~> k2 ~> k3) +data TyCon3 :: (k1 -> k2 -> k3 -> k4) -> (k1 ~> k2 ~> k3 ~> k4) +data TyCon4 :: (k1 -> k2 -> k3 -> k4 -> k5) -> (k1 ~> k2 ~> k3 ~> k4 ~> k5) +data TyCon5 :: (k1 -> k2 -> k3 -> k4 -> k5 -> k6) + -> (k1 ~> k2 ~> k3 ~> k4 ~> k5 ~> k6) +data TyCon6 :: (k1 -> k2 -> k3 -> k4 -> k5 -> k6 -> k7) + -> (k1 ~> k2 ~> k3 ~> k4 ~> k5 ~> k6 ~> k7) +data TyCon7 :: (k1 -> k2 -> k3 -> k4 -> k5 -> k6 -> k7 -> k8) + -> (k1 ~> k2 ~> k3 ~> k4 ~> k5 ~> k6 ~> k7 ~> k8) +data TyCon8 :: (k1 -> k2 -> k3 -> k4 -> k5 -> k6 -> k7 -> k8 -> k9) + -> (k1 ~> k2 ~> k3 ~> k4 ~> k5 ~> k6 ~> k7 ~> k8 ~> k9) -- | Type level function application -type family Apply (f :: TyFun k1 k2 -> *) (x :: k1) :: k2 +type family Apply (f :: k1 ~> k2) (x :: k1) :: k2 type instance Apply (TyCon1 f) x = f x type instance Apply (TyCon2 f) x = TyCon1 (f x) type instance Apply (TyCon3 f) x = TyCon2 (f x) @@ -183,13 +194,11 @@ ---- Defunctionalized Sing instance and utilities -------------------- ---------------------------------------------------------------------- -newtype instance Sing (f :: TyFun k1 k2 -> *) = +newtype instance Sing (f :: k1 ~> k2) = SLambda { applySing :: forall t. Sing t -> Sing (f @@ t) } -instance (SingKind ('KProxy :: KProxy k1), SingKind ('KProxy :: KProxy k2)) - => SingKind ('KProxy :: KProxy (TyFun k1 k2 -> *)) where - type DemoteRep ('KProxy :: KProxy (TyFun k1 k2 -> *)) = - DemoteRep ('KProxy :: KProxy k1) -> DemoteRep ('KProxy :: KProxy k2) +instance (SingKind k1, SingKind k2) => SingKind (k1 ~> k2) where + type DemoteRep (k1 ~> k2) = DemoteRep k1 -> DemoteRep k2 fromSing sFun x = withSomeSing x (fromSing . applySing sFun) toSing _ = error "Cannot create existentially-quantified singleton functions." @@ -274,8 +283,8 @@ -- | Convert a normal datatype (like 'Bool') to a singleton for that datatype, -- passing it into a continuation. -withSomeSing :: SingKind ('KProxy :: KProxy k) - => DemoteRep ('KProxy :: KProxy k) -- ^ The original datatype +withSomeSing :: SingKind k + => DemoteRep k -- ^ The original datatype -> (forall (a :: k). Sing a -> r) -- ^ Function expecting a singleton -> r withSomeSing x f = @@ -293,7 +302,7 @@ -- property. If the singleton does not satisfy the property, then the function -- returns 'Nothing'. The property is expressed in terms of the underlying -- representation of the singleton. -singThat :: forall (a :: k). (SingKind ('KProxy :: KProxy k), SingI a) +singThat :: forall (a :: k). (SingKind k, SingI a) => (Demote a -> Bool) -> Maybe (Sing a) singThat p = withSing $ \x -> if p (fromSing x) then Just x else Nothing @@ -304,11 +313,3 @@ -- | Allows creation of a singleton when a @proxy#@ is at hand. singByProxy# :: SingI a => Proxy# a -> Sing a singByProxy# _ = sing - --- | GHC 7.8 sometimes warns about incomplete pattern matches when no such --- patterns are possible, due to GADT constraints. --- See the bug report at . --- In such cases, it's useful to have a catch-all pattern that then has --- 'bugInGHC' as its right-hand side. -bugInGHC :: forall a. a -bugInGHC = error "Bug encountered in GHC -- this should never happen" diff --git a/src/Data/Singletons/Decide.hs b/src/Data/Singletons/Decide.hs --- a/src/Data/Singletons/Decide.hs +++ b/src/Data/Singletons/Decide.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE RankNTypes, PolyKinds, DataKinds, TypeOperators, +{-# LANGUAGE RankNTypes, PolyKinds, DataKinds, TypeOperators, TypeInType, TypeFamilies, FlexibleContexts, UndecidableInstances, GADTs #-} {-# OPTIONS_GHC -fno-warn-orphans #-} @@ -23,6 +23,7 @@ (:~:)(..), Void, Refuted, Decision(..) ) where +import Data.Kind import Data.Singletons import Data.Type.Equality import Data.Void @@ -44,11 +45,11 @@ -- | Members of the 'SDecide' "kind" class support decidable equality. Instances -- of this class are generated alongside singleton definitions for datatypes that -- derive an 'Eq' instance. -class (kparam ~ 'KProxy) => SDecide (kparam :: KProxy k) where +class SDecide k where -- | Compute a proof or disproof of equality, given two singletons. (%~) :: forall (a :: k) (b :: k). Sing a -> Sing b -> Decision (a :~: b) -instance SDecide ('KProxy :: KProxy k) => TestEquality (Sing :: k -> *) where +instance SDecide k => TestEquality (Sing :: k -> Type) where testEquality a b = case a %~ b of Proved Refl -> Just Refl diff --git a/src/Data/Singletons/Names.hs b/src/Data/Singletons/Names.hs --- a/src/Data/Singletons/Names.hs +++ b/src/Data/Singletons/Names.hs @@ -29,7 +29,7 @@ eqName, ordName, boundedName, orderingName, singFamilyName, singIName, singMethName, demoteRepName, singKindClassName, sEqClassName, sEqMethName, sconsName, snilName, - sIfName, kProxyDataName, kProxyTypeName, proxyTypeName, proxyDataName, + sIfName, proxyTypeName, proxyDataName, someSingTypeName, someSingDataName, sListName, sDecideClassName, sDecideMethName, provedName, disprovedName, reflName, toSingName, fromSingName, @@ -73,8 +73,6 @@ sIfName = mk_name_v "Data.Singletons.Prelude.Bool" "sIf" sconsName = mk_name_d "Data.Singletons.Prelude.Instances" "SCons" snilName = mk_name_d "Data.Singletons.Prelude.Instances" "SNil" -kProxyDataName = 'KProxy -kProxyTypeName = ''KProxy someSingTypeName = ''SomeSing someSingDataName = 'SomeSing proxyTypeName = ''Proxy @@ -172,11 +170,6 @@ promoteClassName :: Name -> Name promoteClassName = prefixUCName "P" "#" --- produce the silly type class used to store the type variables for --- a class -classTvsName :: Name -> Name -classTvsName = suffixName "TyVars" "^^^" - mkTyName :: Quasi q => Name -> q Name mkTyName tmName = do let nameStr = nameBase tmName @@ -223,7 +216,7 @@ | otherwise = (prefixLCName "s" "%") $ upcase n kindParam :: DKind -> DType -kindParam k = DSigT (DConT kProxyDataName) (DConT kProxyTypeName `DAppT` k) +kindParam k = DSigT (DConT proxyDataName) (DConT proxyTypeName `DAppT` k) proxyFor :: DType -> DExp proxyFor ty = DSigE (DConE proxyDataName) (DAppT (DConT proxyTypeName) ty) @@ -232,7 +225,7 @@ singFamily = DConT singFamilyName singKindConstraint :: DKind -> DPred -singKindConstraint k = DAppPr (DConPr singKindClassName) (kindParam k) +singKindConstraint = DAppPr (DConPr singKindClassName) demote :: DType demote = DConT demoteRepName @@ -259,6 +252,6 @@ -> q ([DTyVarBndr], DCxt) mkKProxies ns = do kproxies <- mapM (const $ qNewName "kproxy") ns - return ( zipWith (\kp kv -> DKindedTV kp (DConT kProxyTypeName `DAppT` DVarT kv)) + return ( zipWith (\kp kv -> DKindedTV kp (DConT proxyTypeName `DAppT` DVarT kv)) kproxies ns - , map (\kp -> mkEqPred (DVarT kp) (DConT kProxyDataName)) kproxies ) + , map (\kp -> mkEqPred (DVarT kp) (DConT proxyDataName)) kproxies ) diff --git a/src/Data/Singletons/Prelude/Enum.hs b/src/Data/Singletons/Prelude/Enum.hs --- a/src/Data/Singletons/Prelude/Enum.hs +++ b/src/Data/Singletons/Prelude/Enum.hs @@ -1,6 +1,6 @@ {-# LANGUAGE TemplateHaskell, DataKinds, PolyKinds, ScopedTypeVariables, TypeFamilies, TypeOperators, GADTs, UndecidableInstances, - FlexibleContexts, DefaultSignatures, BangPatterns, + FlexibleContexts, DefaultSignatures, BangPatterns, TypeInType, InstanceSigs #-} ----------------------------------------------------------------------------- diff --git a/src/Data/Singletons/Prelude/Eq.hs b/src/Data/Singletons/Prelude/Eq.hs --- a/src/Data/Singletons/Prelude/Eq.hs +++ b/src/Data/Singletons/Prelude/Eq.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE TypeOperators, DataKinds, PolyKinds, TypeFamilies, +{-# LANGUAGE TypeOperators, DataKinds, PolyKinds, TypeFamilies, TypeInType, RankNTypes, FlexibleContexts, TemplateHaskell, UndecidableInstances, GADTs, DefaultSignatures #-} @@ -33,7 +33,7 @@ -- | The promoted analogue of 'Eq'. If you supply no definition for '(:==)', -- then it defaults to a use of '(==)', from @Data.Type.Equality@. -class kproxy ~ 'KProxy => PEq (kproxy :: KProxy a) where +class kproxy ~ 'Proxy => PEq (kproxy :: Proxy a) where type (:==) (x :: a) (y :: a) :: Bool type (:/=) (x :: a) (y :: a) :: Bool @@ -47,7 +47,7 @@ -- | The singleton analogue of 'Eq'. Unlike the definition for 'Eq', it is required -- that instances define a body for '(%:==)'. You may also supply a body for '(%:/=)'. -class (kparam ~ 'KProxy) => SEq (kparam :: KProxy k) where +class SEq k where -- | Boolean equality on singletons (%:==) :: forall (a :: k) (b :: k). Sing a -> Sing b -> Sing (a :== b) infix 4 %:== diff --git a/src/Data/Singletons/Prelude/Instances.hs b/src/Data/Singletons/Prelude/Instances.hs --- a/src/Data/Singletons/Prelude/Instances.hs +++ b/src/Data/Singletons/Prelude/Instances.hs @@ -8,7 +8,7 @@ -} -{-# LANGUAGE RankNTypes, DataKinds, PolyKinds, GADTs, TypeFamilies, +{-# LANGUAGE RankNTypes, TypeInType, GADTs, TypeFamilies, FlexibleContexts, TemplateHaskell, ScopedTypeVariables, UndecidableInstances, TypeOperators, FlexibleInstances #-} {-# OPTIONS_GHC -fno-warn-orphans #-} diff --git a/src/Data/Singletons/Prelude/List.hs b/src/Data/Singletons/Prelude/List.hs --- a/src/Data/Singletons/Prelude/List.hs +++ b/src/Data/Singletons/Prelude/List.hs @@ -1,10 +1,7 @@ -{-# LANGUAGE TypeOperators, DataKinds, PolyKinds, TypeFamilies, +{-# LANGUAGE TypeOperators, DataKinds, PolyKinds, TypeFamilies, TypeInType, TemplateHaskell, GADTs, UndecidableInstances, RankNTypes, - ScopedTypeVariables, FlexibleContexts, CPP #-} + ScopedTypeVariables, FlexibleContexts #-} {-# OPTIONS_GHC -O0 #-} -#if __GLASGOW_HASKELL__ >= 711 -{-# LANGUAGE TypeInType #-} -#endif ----------------------------------------------------------------------------- -- | diff --git a/src/Data/Singletons/Prelude/Maybe.hs b/src/Data/Singletons/Prelude/Maybe.hs --- a/src/Data/Singletons/Prelude/Maybe.hs +++ b/src/Data/Singletons/Prelude/Maybe.hs @@ -1,9 +1,5 @@ -{-# LANGUAGE TemplateHaskell, ScopedTypeVariables, TypeFamilies, - DataKinds, PolyKinds, UndecidableInstances, GADTs, - RankNTypes, CPP #-} -#if __GLASGOW_HASKELL__ >= 711 -{-# LANGUAGE TypeInType #-} -#endif +{-# LANGUAGE TemplateHaskell, ScopedTypeVariables, TypeFamilies, TypeInType, + DataKinds, PolyKinds, UndecidableInstances, GADTs, RankNTypes #-} ----------------------------------------------------------------------------- -- | diff --git a/src/Data/Singletons/Prelude/Num.hs b/src/Data/Singletons/Prelude/Num.hs --- a/src/Data/Singletons/Prelude/Num.hs +++ b/src/Data/Singletons/Prelude/Num.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE TemplateHaskell, PolyKinds, DataKinds, TypeFamilies, +{-# LANGUAGE TemplateHaskell, PolyKinds, DataKinds, TypeFamilies, TypeInType, TypeOperators, GADTs, ScopedTypeVariables, UndecidableInstances, DefaultSignatures, FlexibleContexts #-} @@ -36,7 +36,6 @@ import Data.Singletons.TypeLits.Internal import Data.Singletons.Decide import GHC.TypeLits -import Data.Proxy import Unsafe.Coerce $(singletonsOnly [d| @@ -73,7 +72,7 @@ SignumNat 0 = 0 SignumNat x = 1 -instance PNum ('KProxy :: KProxy Nat) where +instance PNum ('Proxy :: Proxy Nat) where type a :+ b = a + b type a :- b = a - b type a :* b = a * b @@ -83,7 +82,7 @@ type FromInteger a = a -- SNum instance -instance SNum ('KProxy :: KProxy Nat) where +instance SNum Nat where sa %:+ sb = let a = fromSing sa b = fromSing sb diff --git a/src/Data/Singletons/Prelude/Ord.hs b/src/Data/Singletons/Prelude/Ord.hs --- a/src/Data/Singletons/Prelude/Ord.hs +++ b/src/Data/Singletons/Prelude/Ord.hs @@ -1,9 +1,6 @@ {-# LANGUAGE TemplateHaskell, DataKinds, PolyKinds, ScopedTypeVariables, TypeFamilies, TypeOperators, GADTs, UndecidableInstances, - FlexibleContexts, DefaultSignatures, InstanceSigs, CPP #-} -#if __GLASGOW_HASKELL__ >= 711 -{-# LANGUAGE TypeInType #-} -#endif + FlexibleContexts, DefaultSignatures, InstanceSigs, TypeInType #-} ----------------------------------------------------------------------------- -- | @@ -44,10 +41,6 @@ import Data.Singletons.Prelude.Eq import Data.Singletons.Prelude.Instances import Data.Singletons.Util - -#if __GLASGOW_HASKELL__ < 711 -import Data.Singletons ( Sing ) -#endif $(singletonsOnly [d| class (Eq a) => Ord a where diff --git a/src/Data/Singletons/Prelude/Tuple.hs b/src/Data/Singletons/Prelude/Tuple.hs --- a/src/Data/Singletons/Prelude/Tuple.hs +++ b/src/Data/Singletons/Prelude/Tuple.hs @@ -1,8 +1,5 @@ {-# LANGUAGE TemplateHaskell, ScopedTypeVariables, DataKinds, PolyKinds, - RankNTypes, TypeFamilies, GADTs, UndecidableInstances, CPP #-} -#if __GLASGOW_HASKELL__ >= 711 -{-# LANGUAGE TypeInType #-} -#endif + RankNTypes, TypeFamilies, GADTs, UndecidableInstances, TypeInType #-} ----------------------------------------------------------------------------- -- | diff --git a/src/Data/Singletons/Promote.hs b/src/Data/Singletons/Promote.hs --- a/src/Data/Singletons/Promote.hs +++ b/src/Data/Singletons/Promote.hs @@ -7,7 +7,7 @@ type level. It is an internal module to the singletons package. -} -{-# LANGUAGE TemplateHaskell, MultiWayIf, LambdaCase, TupleSections, CPP #-} +{-# LANGUAGE TemplateHaskell, MultiWayIf, LambdaCase, TupleSections #-} module Data.Singletons.Promote where @@ -340,12 +340,10 @@ first:_ | not (isHsLetter first) -> "TFHelper" alpha -> alpha family_args -#if __GLASGOW_HASKELL__ >= 711 -- GHC 8 requires bare tyvars to the left of a type family default | Nothing <- m_subst = map DVarT meth_arg_tvs | otherwise -#endif = zipWith (DSigT . DVarT) meth_arg_tvs meth_arg_kis' helperName <- newUniqueName helperNameBase emitDecs [DClosedTypeFamilyD (DTypeFamilyHead diff --git a/src/Data/Singletons/Promote/Monad.hs b/src/Data/Singletons/Promote/Monad.hs --- a/src/Data/Singletons/Promote/Monad.hs +++ b/src/Data/Singletons/Promote/Monad.hs @@ -10,7 +10,7 @@ -} {-# LANGUAGE GeneralizedNewtypeDeriving, StandaloneDeriving, - FlexibleContexts, TypeFamilies, KindSignatures, CPP #-} + FlexibleContexts, TypeFamilies, KindSignatures #-} module Data.Singletons.Promote.Monad ( PrM, promoteM, promoteM_, promoteMDecs, VarPromotions, @@ -26,10 +26,7 @@ import Language.Haskell.TH.Desugar import Data.Singletons.Names import Data.Singletons.Syntax - -#if __GLASGOW_HASKELL__ >= 711 import Control.Monad.Fail ( MonadFail ) -#endif type LetExpansions = Map Name DType -- from **term-level** name @@ -49,10 +46,7 @@ newtype PrM a = PrM (ReaderT PrEnv (WriterT [DDec] Q) a) deriving ( Functor, Applicative, Monad, Quasi , MonadReader PrEnv, MonadWriter [DDec] -#if __GLASGOW_HASKELL__ >= 711 - , MonadFail -#endif - ) + , MonadFail ) instance DsMonad PrM where localDeclarations = asks pr_local_decls diff --git a/src/Data/Singletons/Single.hs b/src/Data/Singletons/Single.hs --- a/src/Data/Singletons/Single.hs +++ b/src/Data/Singletons/Single.hs @@ -264,10 +264,9 @@ (Map.toList default_defns) let fixities' = map (uncurry singInfixDecl) fixities cls_cxt' <- mapM singPred cls_cxt - (kproxies, kproxy_pred) <- mkKProxies (map extractTvbName cls_tvbs) - - return $ DClassD (cls_cxt' ++ kproxy_pred) - (singClassName cls_name) kproxies + return $ DClassD cls_cxt' + (singClassName cls_name) + cls_tvbs cls_fundeps -- they are fine without modification (map DLetDec (sing_sigs ++ sing_meths ++ fixities') ++ default_sigs) where @@ -298,7 +297,7 @@ meths <- concatMapM (uncurry sing_meth) ann_meths return (DInstanceD Nothing cxt' - (foldl DAppT (DConT s_inst_name) (map kindParam inst_kis)) + (foldl DAppT (DConT s_inst_name) inst_kis) meths) where @@ -309,19 +308,8 @@ mb_s_info <- dsReify (singValName name) (s_ty, tyvar_names, m_res_ki) <- case mb_s_info of Just (DVarI _ (DForallT cls_kproxy_tvbs _cls_pred s_ty) _) -> do -#if __GLASGOW_HASKELL__ >= 711 -- GHC 8 quantifies over the kind vars explicitly let class_kvs = [ class_kv | DKindedTV class_kv DStarT <- cls_kproxy_tvbs ] -#else - let class_kvs = map extract_kv cls_kproxy_tvbs - extract_kv (DKindedTV _kproxyVar (DConT _kproxyTy `DAppT` DVarT kv)) = kv - extract_kv k = error $ "sing_meth cannot extract a kind variable" ++ - "\n" ++ show k ++ - "\n" ++ show name ++ - "\n" ++ show (singValName name) ++ - "\n" ++ show mb_s_info -#endif - (sing_tvbs, _pred, _args, res_ty) = unravel s_ty inst_kis <- mapM promoteType inst_tys diff --git a/src/Data/Singletons/Single/Data.hs b/src/Data/Singletons/Single/Data.hs --- a/src/Data/Singletons/Single/Data.hs +++ b/src/Data/Singletons/Single/Data.hs @@ -37,12 +37,11 @@ let singKindInst = DInstanceD Nothing (map (singKindConstraint . DVarT) tvbNames) - (DAppT (DConT singKindClassName) - (kindParam k)) + (DAppT (DConT singKindClassName) k) [ DTySynInstD demoteRepName $ DTySynEqn - [kindParam k] + [k] (foldType (DConT name) - (map (DAppT demote . kindParam . DVarT) tvbNames)) + (map (DAppT demote . DVarT) tvbNames)) , DLetDec $ DFunD fromSingName (fromSingClauses `orIfEmpty` emptyMethod aName) , DLetDec $ DFunD toSingName (toSingClauses `orIfEmpty` emptyMethod aName) ] @@ -98,7 +97,7 @@ mkRecursiveCall :: Name -> DKind -> DExp mkRecursiveCall var_name ki = DSigE (DAppE (DVarE toSingName) (DVarE var_name)) - (DAppT (DConT someSingTypeName) (kindParam ki)) + (DAppT (DConT someSingTypeName) ki) emptyMethod :: Name -> [DClause] emptyMethod n = [DClause [DVarPa n] (DCaseE (DVarE n) emptyMatches)] diff --git a/src/Data/Singletons/Single/Eq.hs b/src/Data/Singletons/Single/Eq.hs --- a/src/Data/Singletons/Single/Eq.hs +++ b/src/Data/Singletons/Single/Eq.hs @@ -30,10 +30,8 @@ then mkEmptyMethClauses else mapM mkMeth ctorPairs return $ DInstanceD Nothing - (map (\kvar -> (DConPr className) `DAppPr` kindParam kvar) - (getKindVars k)) - (DAppT (DConT className) - (kindParam k)) + (map (DAppPr (DConPr className)) (getKindVars k)) + (DAppT (DConT className) k) [DLetDec $ DFunD methName methClauses] where getKindVars :: DKind -> [DKind] getKindVars (DVarT x) = [DVarT x] diff --git a/src/Data/Singletons/Single/Monad.hs b/src/Data/Singletons/Single/Monad.hs --- a/src/Data/Singletons/Single/Monad.hs +++ b/src/Data/Singletons/Single/Monad.hs @@ -8,8 +8,7 @@ The SgM monad allows reading from a SgEnv environment and is wrapped around a Q. -} -{-# LANGUAGE GeneralizedNewtypeDeriving, ParallelListComp, - TemplateHaskell, CPP #-} +{-# LANGUAGE GeneralizedNewtypeDeriving, ParallelListComp, TemplateHaskell #-} module Data.Singletons.Single.Monad ( SgM, bindLets, bindTyVars, bindTyVarsEq, lookupVarE, lookupConE, @@ -30,10 +29,7 @@ import Control.Monad.Reader import Control.Monad.Writer import Control.Applicative - -#if __GLASGOW_HASKELL__ >= 711 import Control.Monad.Fail -#endif -- environment during singling data SgEnv = @@ -50,10 +46,7 @@ newtype SgM a = SgM (ReaderT SgEnv (WriterT [DDec] Q) a) deriving ( Functor, Applicative, Monad , MonadReader SgEnv, MonadWriter [DDec] -#if __GLASGOW_HASKELL__ >= 711 - , MonadFail -#endif - ) + , MonadFail ) liftSgM :: Q a -> SgM a liftSgM = SgM . lift . lift @@ -75,12 +68,10 @@ qGetQ = liftSgM qGetQ qPutQ = liftSgM `comp1` qPutQ -#if __GLASGOW_HASKELL__ >= 711 qReifyFixity = liftSgM `comp1` qReifyFixity qReifyConStrictness = liftSgM `comp1` qReifyConStrictness qIsExtEnabled = liftSgM `comp1` qIsExtEnabled qExtsEnabled = liftSgM qExtsEnabled -#endif qRecover (SgM handler) (SgM body) = do env <- ask diff --git a/src/Data/Singletons/Single/Type.hs b/src/Data/Singletons/Single/Type.hs --- a/src/Data/Singletons/Single/Type.hs +++ b/src/Data/Singletons/Single/Type.hs @@ -51,5 +51,5 @@ | otherwise = do kis <- mapM promoteType ctx let sName = singClassName n - return $ foldl DAppPr (DConPr sName) (map kindParam kis) + return $ foldl DAppPr (DConPr sName) kis singPredRec _ctx DWildCardPr = return DWildCardPr -- it just might work diff --git a/src/Data/Singletons/TH.hs b/src/Data/Singletons/TH.hs --- a/src/Data/Singletons/TH.hs +++ b/src/Data/Singletons/TH.hs @@ -54,7 +54,7 @@ POrd(..), SOrd(..), ThenCmp, sThenCmp, Foldl, sFoldl, Any, SDecide(..), (:~:)(..), Void, Refuted, Decision(..), - Proxy(..), KProxy(..), SomeSing(..), + Proxy(..), SomeSing(..), Error, ErrorSym0, TrueSym0, FalseSym0, diff --git a/src/Data/Singletons/TypeLits/Internal.hs b/src/Data/Singletons/TypeLits/Internal.hs --- a/src/Data/Singletons/TypeLits/Internal.hs +++ b/src/Data/Singletons/TypeLits/Internal.hs @@ -16,7 +16,7 @@ {-# LANGUAGE PolyKinds, DataKinds, TypeFamilies, FlexibleInstances, UndecidableInstances, ScopedTypeVariables, RankNTypes, GADTs, FlexibleContexts, TypeOperators, ConstraintKinds, - TemplateHaskell #-} + TypeInType, TemplateHaskell #-} {-# OPTIONS_GHC -fno-warn-orphans #-} module Data.Singletons.TypeLits.Internal ( @@ -50,8 +50,8 @@ instance KnownNat n => SingI n where sing = SNat -instance SingKind ('KProxy :: KProxy Nat) where - type DemoteRep ('KProxy :: KProxy Nat) = Integer +instance SingKind Nat where + type DemoteRep Nat = Integer fromSing (SNat :: Sing n) = natVal (Proxy :: Proxy n) toSing n = case someNatVal n of Just (SomeNat (_ :: Proxy n)) -> SomeSing (SNat :: Sing n) @@ -62,14 +62,14 @@ instance KnownSymbol n => SingI n where sing = SSym -instance SingKind ('KProxy :: KProxy Symbol) where - type DemoteRep ('KProxy :: KProxy Symbol) = String +instance SingKind Symbol where + type DemoteRep Symbol = String fromSing (SSym :: Sing n) = symbolVal (Proxy :: Proxy n) toSing s = case someSymbolVal s of SomeSymbol (_ :: Proxy n) -> SomeSing (SSym :: Sing n) -- SDecide instances: -instance SDecide ('KProxy :: KProxy Nat) where +instance SDecide Nat where (SNat :: Sing n) %~ (SNat :: Sing m) | natVal (Proxy :: Proxy n) == natVal (Proxy :: Proxy m) = Proved $ unsafeCoerce Refl @@ -77,7 +77,7 @@ = Disproved (\_ -> error errStr) where errStr = "Broken Nat singletons" -instance SDecide ('KProxy :: KProxy Symbol) where +instance SDecide Symbol where (SSym :: Sing n) %~ (SSym :: Sing m) | symbolVal (Proxy :: Proxy n) == symbolVal (Proxy :: Proxy m) = Proved $ unsafeCoerce Refl @@ -86,27 +86,27 @@ where errStr = "Broken Symbol singletons" -- PEq instances -instance PEq ('KProxy :: KProxy Nat) where +instance PEq ('Proxy :: Proxy Nat) where type (a :: Nat) :== (b :: Nat) = a == b -instance PEq ('KProxy :: KProxy Symbol) where +instance PEq ('Proxy :: Proxy Symbol) where type (a :: Symbol) :== (b :: Symbol) = a == b -- need SEq instances for TypeLits kinds -instance SEq ('KProxy :: KProxy Nat) where +instance SEq Nat where a %:== b | fromSing a == fromSing b = unsafeCoerce STrue | otherwise = unsafeCoerce SFalse -instance SEq ('KProxy :: KProxy Symbol) where +instance SEq Symbol where a %:== b | fromSing a == fromSing b = unsafeCoerce STrue | otherwise = unsafeCoerce SFalse -- POrd instances -instance POrd ('KProxy :: KProxy Nat) where +instance POrd ('Proxy :: Proxy Nat) where type (a :: Nat) `Compare` (b :: Nat) = a `TL.CmpNat` b -instance POrd ('KProxy :: KProxy Symbol) where +instance POrd ('Proxy :: Proxy Symbol) where type (a :: Symbol) `Compare` (b :: Symbol) = a `TL.CmpSymbol` b -- | Kind-restricted synonym for 'Sing' for @Nat@s @@ -116,13 +116,13 @@ type SSymbol (x :: Symbol) = Sing x -- SOrd instances -instance SOrd ('KProxy :: KProxy Nat) where +instance SOrd Nat where a `sCompare` b = case fromSing a `compare` fromSing b of LT -> unsafeCoerce SLT EQ -> unsafeCoerce SEQ GT -> unsafeCoerce SGT -instance SOrd ('KProxy :: KProxy Symbol) where +instance SOrd Symbol where a `sCompare` b = case fromSing a `compare` fromSing b of LT -> unsafeCoerce SLT EQ -> unsafeCoerce SEQ diff --git a/src/Data/Singletons/TypeRepStar.hs b/src/Data/Singletons/TypeRepStar.hs --- a/src/Data/Singletons/TypeRepStar.hs +++ b/src/Data/Singletons/TypeRepStar.hs @@ -36,6 +36,7 @@ import Unsafe.Coerce import Data.Singletons.Decide +import Data.Kind import GHC.Exts ( Proxy# ) import Data.Type.Coercion import Data.Type.Equality @@ -45,15 +46,15 @@ instance Typeable a => SingI (a :: *) where sing = STypeRep -instance SingKind ('KProxy :: KProxy *) where - type DemoteRep ('KProxy :: KProxy *) = TypeRep +instance SingKind Type where + type DemoteRep Type = TypeRep fromSing (STypeRep :: Sing a) = typeOf (undefined :: a) toSing = dirty_mk_STypeRep -instance PEq ('KProxy :: KProxy *) where +instance PEq ('Proxy :: Proxy Type) where type (a :: *) :== (b :: *) = a == b -instance SEq ('KProxy :: KProxy *) where +instance SEq Type where (STypeRep :: Sing a) %:== (STypeRep :: Sing b) = case (eqT :: Maybe (a :~: b)) of Just Refl -> STrue @@ -61,7 +62,7 @@ -- the Data.Typeable interface isn't strong enough -- to enable us to define this without unsafeCoerce -instance SDecide ('KProxy :: KProxy *) where +instance SDecide Type where (STypeRep :: Sing a) %~ (STypeRep :: Sing b) = case (eqT :: Maybe (a :~: b)) of Just Refl -> Proved Refl @@ -77,7 +78,7 @@ -- everything below here is private and dirty. Don't look! newtype DI = Don'tInstantiate (forall a. Typeable a => Sing a) -dirty_mk_STypeRep :: TypeRep -> SomeSing ('KProxy :: KProxy *) +dirty_mk_STypeRep :: TypeRep -> SomeSing * dirty_mk_STypeRep rep = let justLikeTypeable :: Proxy# a -> TypeRep justLikeTypeable _ = rep diff --git a/src/Data/Singletons/Util.hs b/src/Data/Singletons/Util.hs --- a/src/Data/Singletons/Util.hs +++ b/src/Data/Singletons/Util.hs @@ -11,7 +11,7 @@ TemplateHaskell, GeneralizedNewtypeDeriving, MultiParamTypeClasses, StandaloneDeriving, UndecidableInstances, MagicHash, UnboxedTuples, - LambdaCase, CPP, NoMonomorphismRestriction #-} + LambdaCase, NoMonomorphismRestriction #-} module Data.Singletons.Util where @@ -23,20 +23,19 @@ import Control.Monad.Writer hiding ( mapM ) import Control.Monad.Reader hiding ( mapM ) import qualified Data.Map as Map +import Data.List.NonEmpty (NonEmpty) import Data.Map ( Map ) import Data.Foldable import Data.Traversable import Data.Generics - -#if __GLASGOW_HASKELL__ >= 711 import Control.Monad.Fail ( MonadFail ) -#endif -- The list of types that singletons processes by default basicTypes :: [Name] basicTypes = [ ''Maybe , ''[] , ''Either + , ''NonEmpty ] ++ boundedBasicTypes boundedBasicTypes :: [Name] @@ -346,10 +345,7 @@ newtype QWithAux m q a = QWA { runQWA :: WriterT m q a } deriving ( Functor, Applicative, Monad, MonadTrans , MonadWriter m, MonadReader r -#if __GLASGOW_HASKELL__ >= 711 - , MonadFail -#endif - ) + , MonadFail ) -- make a Quasi instance for easy lifting instance (Quasi q, Monoid m) => Quasi (QWithAux m q) where @@ -369,12 +365,10 @@ qGetQ = lift qGetQ qPutQ = lift `comp1` qPutQ -#if __GLASGOW_HASKELL__ >= 711 qReifyFixity = lift `comp1` qReifyFixity qReifyConStrictness = lift `comp1` qReifyConStrictness qIsExtEnabled = lift `comp1` qIsExtEnabled qExtsEnabled = lift qExtsEnabled -#endif qRecover exp handler = do (result, aux) <- lift $ qRecover (evalForPair exp) (evalForPair handler) diff --git a/tests/SingletonsTestSuiteUtils.hs b/tests/SingletonsTestSuiteUtils.hs --- a/tests/SingletonsTestSuiteUtils.hs +++ b/tests/SingletonsTestSuiteUtils.hs @@ -51,11 +51,7 @@ includePath = "../../dist/build" ghcVersion :: String -#if __GLASGOW_HASKELL__ >= 711 ghcVersion = ".ghc80" -#else -ghcVersion = ".ghc710" -#endif -- The mtl package made an incompatible change between 2.1.3.1 and 2.2.1. Because -- test files are compiled outside of the cabal infrastructure, we need to check @@ -92,11 +88,7 @@ ghcOpts = extraOpts ++ [ "-v0" , "-c" -#if __GLASGOW_HASKELL__ < 711 - , "-this-package-key " ++ CURRENT_PACKAGE_KEY -- See Note [-this-package-key hack] -#else - , "-this-unit-id " ++ CURRENT_PACKAGE_KEY -#endif + , "-this-unit-id " ++ CURRENT_PACKAGE_KEY -- See Note [-this-unit-id hack] , "-ddump-splices" , "-dsuppress-uniques" , "-fforce-recomp" @@ -123,17 +115,15 @@ , "-XInstanceSigs" , "-XDefaultSignatures" , "-XCPP" -#if __GLASGOW_HASKELL__ >= 711 , "-XTypeInType" -#endif ] --- Note [-this-package-key hack] +-- Note [-this-unit-id hack] -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- -- We want to avoid installing singletons package before running the -- testsuite, because in this way we prevent double compilation of the --- library. To do this we pass -this-package-key option to GHC to convince +-- library. To do this we pass -this-unit-id option to GHC to convince -- it that the test files are actually part of the current -- package. This means that library doesn't have to be installed -- globally and interface files generated during library compilation diff --git a/tests/compile-and-dump/GradingClient/Database.ghc710.template b/tests/compile-and-dump/GradingClient/Database.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/GradingClient/Database.ghc710.template +++ /dev/null @@ -1,4906 +0,0 @@ -GradingClient/Database.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| data Nat - = Zero | Succ Nat - deriving (Eq, Ord) |] - ======> - data Nat - = Zero | Succ Nat - deriving (Eq, Ord) - type family Equals_0123456789 (a :: Nat) (b :: Nat) :: Bool where - Equals_0123456789 Zero Zero = TrueSym0 - Equals_0123456789 (Succ a) (Succ b) = (:==) a b - Equals_0123456789 (a :: Nat) (b :: Nat) = FalseSym0 - instance PEq (KProxy :: KProxy Nat) where - type (:==) (a :: Nat) (b :: Nat) = Equals_0123456789 a b - type ZeroSym0 = Zero - type SuccSym1 (t :: Nat) = Succ t - instance SuppressUnusedWarnings SuccSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.()) - data SuccSym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply SuccSym0 arg) ~ KindOf (SuccSym1 arg) => - SuccSym0KindInference - type instance Apply SuccSym0 l = SuccSym1 l - type family Compare_0123456789 (a :: Nat) - (a :: Nat) :: Ordering where - Compare_0123456789 Zero Zero = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[] - Compare_0123456789 (Succ a_0123456789) (Succ b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[]) - Compare_0123456789 Zero (Succ _z_0123456789) = LTSym0 - Compare_0123456789 (Succ _z_0123456789) Zero = GTSym0 - type Compare_0123456789Sym2 (t :: Nat) (t :: Nat) = - Compare_0123456789 t t - instance SuppressUnusedWarnings Compare_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Compare_0123456789Sym1KindInference GHC.Tuple.()) - data Compare_0123456789Sym1 (l :: Nat) (l :: TyFun Nat Ordering) - = forall arg. KindOf (Apply (Compare_0123456789Sym1 l) arg) ~ KindOf (Compare_0123456789Sym2 l arg) => - Compare_0123456789Sym1KindInference - type instance Apply (Compare_0123456789Sym1 l) l = Compare_0123456789Sym2 l l - instance SuppressUnusedWarnings Compare_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Compare_0123456789Sym0KindInference GHC.Tuple.()) - data Compare_0123456789Sym0 (l :: TyFun Nat (TyFun Nat Ordering - -> *)) - = forall arg. KindOf (Apply Compare_0123456789Sym0 arg) ~ KindOf (Compare_0123456789Sym1 arg) => - Compare_0123456789Sym0KindInference - type instance Apply Compare_0123456789Sym0 l = Compare_0123456789Sym1 l - instance POrd (KProxy :: KProxy Nat) where - type Compare (a :: Nat) (a :: Nat) = Apply (Apply Compare_0123456789Sym0 a) a - data instance Sing (z :: Nat) - = z ~ Zero => SZero | - forall (n :: Nat). z ~ Succ n => SSucc (Sing (n :: Nat)) - type SNat = (Sing :: Nat -> *) - instance SingKind (KProxy :: KProxy Nat) where - type DemoteRep (KProxy :: KProxy Nat) = Nat - fromSing SZero = Zero - fromSing (SSucc b) = Succ (fromSing b) - toSing Zero = SomeSing SZero - toSing (Succ b) - = case toSing b :: SomeSing (KProxy :: KProxy Nat) of { - SomeSing c -> SomeSing (SSucc c) } - instance SEq (KProxy :: KProxy Nat) where - (%:==) SZero SZero = STrue - (%:==) SZero (SSucc _) = SFalse - (%:==) (SSucc _) SZero = SFalse - (%:==) (SSucc a) (SSucc b) = (%:==) a b - instance SDecide (KProxy :: KProxy Nat) where - (%~) SZero SZero = Proved Refl - (%~) SZero (SSucc _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SSucc _) SZero - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SSucc a) (SSucc b) - = case (%~) a b of { - Proved Refl -> Proved Refl - Disproved contra - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) } - instance SOrd (KProxy :: KProxy Nat) => - SOrd (KProxy :: KProxy Nat) where - sCompare :: - forall (t0 :: Nat) (t1 :: Nat). - Sing t0 - -> Sing t1 - -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat (TyFun Nat Ordering - -> *) - -> *) t0 :: TyFun Nat Ordering - -> *) t1 :: Ordering) - sCompare SZero SZero - = let - lambda :: - (t0 ~ ZeroSym0, t1 ~ ZeroSym0) => - Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - = applySing - (applySing - (applySing - (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl) - (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp)) - SEQ) - SNil - in lambda - sCompare (SSucc sA_0123456789) (SSucc sB_0123456789) - = let - lambda :: - forall a_0123456789 - b_0123456789. (t0 ~ Apply SuccSym0 a_0123456789, - t1 ~ Apply SuccSym0 b_0123456789) => - Sing a_0123456789 - -> Sing b_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda a_0123456789 b_0123456789 - = applySing - (applySing - (applySing - (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl) - (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp)) - SEQ) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - SNil) - in lambda sA_0123456789 sB_0123456789 - sCompare SZero (SSucc _s_z_0123456789) - = let - lambda :: - forall _z_0123456789. (t0 ~ ZeroSym0, - t1 ~ Apply SuccSym0 _z_0123456789) => - Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 = SLT - in lambda _s_z_0123456789 - sCompare (SSucc _s_z_0123456789) SZero - = let - lambda :: - forall _z_0123456789. (t0 ~ Apply SuccSym0 _z_0123456789, - t1 ~ ZeroSym0) => - Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 = SGT - in lambda _s_z_0123456789 - instance SingI Zero where - sing = SZero - instance SingI n => SingI (Succ (n :: Nat)) where - sing = SSucc sing -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 GHC.Types.[]) = True - attrNotIn (Attr name u) (Sch ((Attr name' _) GHC.Types.: t)) - = ((name /= name') && (attrNotIn (Attr name u) (Sch t))) - disjoint :: Schema -> Schema -> Bool - disjoint (Sch GHC.Types.[]) _ = True - disjoint (Sch (h GHC.Types.: t)) s - = ((attrNotIn h s) && (disjoint (Sch t) s)) - occurs :: [AChar] -> Schema -> Bool - occurs _ (Sch GHC.Types.[]) = False - occurs name (Sch ((Attr name' _) GHC.Types.: attrs)) - = ((name == name') || (occurs name (Sch attrs))) - lookup :: [AChar] -> Schema -> U - lookup _ (Sch GHC.Types.[]) = undefined - lookup name (Sch ((Attr name' u) GHC.Types.: attrs)) - = if (name == name') then u else lookup name (Sch attrs) - type family Equals_0123456789 (a :: U) (b :: U) :: Bool where - Equals_0123456789 BOOL BOOL = TrueSym0 - Equals_0123456789 STRING STRING = TrueSym0 - Equals_0123456789 NAT NAT = TrueSym0 - Equals_0123456789 (VEC a a) (VEC b b) = (:&&) ((:==) a b) ((:==) a b) - Equals_0123456789 (a :: U) (b :: U) = FalseSym0 - instance PEq (KProxy :: KProxy U) where - type (:==) (a :: U) (b :: U) = Equals_0123456789 a b - type BOOLSym0 = BOOL - type STRINGSym0 = STRING - type NATSym0 = NAT - type VECSym2 (t :: U) (t :: Nat) = VEC t t - instance SuppressUnusedWarnings VECSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) VECSym1KindInference GHC.Tuple.()) - data VECSym1 (l :: U) (l :: TyFun Nat U) - = forall arg. KindOf (Apply (VECSym1 l) arg) ~ KindOf (VECSym2 l arg) => - VECSym1KindInference - type instance Apply (VECSym1 l) l = VECSym2 l l - instance SuppressUnusedWarnings VECSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) VECSym0KindInference GHC.Tuple.()) - data VECSym0 (l :: TyFun U (TyFun Nat U -> *)) - = forall arg. KindOf (Apply VECSym0 arg) ~ KindOf (VECSym1 arg) => - VECSym0KindInference - type instance Apply VECSym0 l = VECSym1 l - type family Equals_0123456789 (a :: AChar) - (b :: AChar) :: Bool where - Equals_0123456789 CA CA = TrueSym0 - Equals_0123456789 CB CB = TrueSym0 - Equals_0123456789 CC CC = TrueSym0 - Equals_0123456789 CD CD = TrueSym0 - Equals_0123456789 CE CE = TrueSym0 - Equals_0123456789 CF CF = TrueSym0 - Equals_0123456789 CG CG = TrueSym0 - Equals_0123456789 CH CH = TrueSym0 - Equals_0123456789 CI CI = TrueSym0 - Equals_0123456789 CJ CJ = TrueSym0 - Equals_0123456789 CK CK = TrueSym0 - Equals_0123456789 CL CL = TrueSym0 - Equals_0123456789 CM CM = TrueSym0 - Equals_0123456789 CN CN = TrueSym0 - Equals_0123456789 CO CO = TrueSym0 - Equals_0123456789 CP CP = TrueSym0 - Equals_0123456789 CQ CQ = TrueSym0 - Equals_0123456789 CR CR = TrueSym0 - Equals_0123456789 CS CS = TrueSym0 - Equals_0123456789 CT CT = TrueSym0 - Equals_0123456789 CU CU = TrueSym0 - Equals_0123456789 CV CV = TrueSym0 - Equals_0123456789 CW CW = TrueSym0 - Equals_0123456789 CX CX = TrueSym0 - Equals_0123456789 CY CY = TrueSym0 - Equals_0123456789 CZ CZ = TrueSym0 - Equals_0123456789 (a :: AChar) (b :: AChar) = FalseSym0 - instance PEq (KProxy :: KProxy AChar) where - type (:==) (a :: AChar) (b :: AChar) = Equals_0123456789 a b - type CASym0 = CA - type CBSym0 = CB - type CCSym0 = CC - type CDSym0 = CD - type CESym0 = CE - type CFSym0 = CF - type CGSym0 = CG - type CHSym0 = CH - type CISym0 = CI - type CJSym0 = CJ - type CKSym0 = CK - type CLSym0 = CL - type CMSym0 = CM - type CNSym0 = CN - type COSym0 = CO - type CPSym0 = CP - type CQSym0 = CQ - type CRSym0 = CR - type CSSym0 = CS - type CTSym0 = CT - type CUSym0 = CU - type CVSym0 = CV - type CWSym0 = CW - type CXSym0 = CX - type CYSym0 = CY - type CZSym0 = CZ - type AttrSym2 (t :: [AChar]) (t :: U) = Attr t t - instance SuppressUnusedWarnings AttrSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) AttrSym1KindInference GHC.Tuple.()) - data AttrSym1 (l :: [AChar]) (l :: TyFun U Attribute) - = forall arg. KindOf (Apply (AttrSym1 l) arg) ~ KindOf (AttrSym2 l arg) => - AttrSym1KindInference - type instance Apply (AttrSym1 l) l = AttrSym2 l l - instance SuppressUnusedWarnings AttrSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) AttrSym0KindInference GHC.Tuple.()) - data AttrSym0 (l :: TyFun [AChar] (TyFun U Attribute -> *)) - = forall arg. KindOf (Apply AttrSym0 arg) ~ KindOf (AttrSym1 arg) => - AttrSym0KindInference - type instance Apply AttrSym0 l = AttrSym1 l - type SchSym1 (t :: [Attribute]) = Sch t - instance SuppressUnusedWarnings SchSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) SchSym0KindInference GHC.Tuple.()) - data SchSym0 (l :: TyFun [Attribute] Schema) - = forall arg. KindOf (Apply SchSym0 arg) ~ KindOf (SchSym1 arg) => - SchSym0KindInference - type instance Apply SchSym0 l = SchSym1 l - type Let0123456789Scrutinee_0123456789Sym4 t t t t = - Let0123456789Scrutinee_0123456789 t t t t - instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym3 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) - Let0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.()) - data Let0123456789Scrutinee_0123456789Sym3 l l l l - = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym4 l l l arg) => - Let0123456789Scrutinee_0123456789Sym3KindInference - type instance Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) l = Let0123456789Scrutinee_0123456789Sym4 l l l l - instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) - Let0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.()) - data Let0123456789Scrutinee_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym3 l l arg) => - Let0123456789Scrutinee_0123456789Sym2KindInference - type instance Apply (Let0123456789Scrutinee_0123456789Sym2 l l) l = Let0123456789Scrutinee_0123456789Sym3 l l l - instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) - Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.()) - data Let0123456789Scrutinee_0123456789Sym1 l l - = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) => - Let0123456789Scrutinee_0123456789Sym1KindInference - type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l - instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) - Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.()) - data Let0123456789Scrutinee_0123456789Sym0 l - = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) => - Let0123456789Scrutinee_0123456789Sym0KindInference - type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l - type family Let0123456789Scrutinee_0123456789 name - name' - u - attrs where - Let0123456789Scrutinee_0123456789 name name' u attrs = Apply (Apply (:==$) name) name' - type family Case_0123456789 name name' u attrs t where - Case_0123456789 name name' u attrs True = u - Case_0123456789 name name' u attrs False = Apply (Apply LookupSym0 name) (Apply SchSym0 attrs) - type LookupSym2 (t :: [AChar]) (t :: Schema) = Lookup t t - instance SuppressUnusedWarnings LookupSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) LookupSym1KindInference GHC.Tuple.()) - data LookupSym1 (l :: [AChar]) (l :: TyFun Schema U) - = forall arg. KindOf (Apply (LookupSym1 l) arg) ~ KindOf (LookupSym2 l arg) => - LookupSym1KindInference - type instance Apply (LookupSym1 l) l = LookupSym2 l l - instance SuppressUnusedWarnings LookupSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) LookupSym0KindInference GHC.Tuple.()) - data LookupSym0 (l :: TyFun [AChar] (TyFun Schema U -> *)) - = forall arg. KindOf (Apply LookupSym0 arg) ~ KindOf (LookupSym1 arg) => - LookupSym0KindInference - type instance Apply LookupSym0 l = LookupSym1 l - type OccursSym2 (t :: [AChar]) (t :: Schema) = Occurs t t - instance SuppressUnusedWarnings OccursSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) OccursSym1KindInference GHC.Tuple.()) - data OccursSym1 (l :: [AChar]) (l :: TyFun Schema Bool) - = forall arg. KindOf (Apply (OccursSym1 l) arg) ~ KindOf (OccursSym2 l arg) => - OccursSym1KindInference - type instance Apply (OccursSym1 l) l = OccursSym2 l l - instance SuppressUnusedWarnings OccursSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) OccursSym0KindInference GHC.Tuple.()) - data OccursSym0 (l :: TyFun [AChar] (TyFun Schema Bool -> *)) - = forall arg. KindOf (Apply OccursSym0 arg) ~ KindOf (OccursSym1 arg) => - OccursSym0KindInference - type instance Apply OccursSym0 l = OccursSym1 l - type AttrNotInSym2 (t :: Attribute) (t :: Schema) = AttrNotIn t t - instance SuppressUnusedWarnings AttrNotInSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) AttrNotInSym1KindInference GHC.Tuple.()) - data AttrNotInSym1 (l :: Attribute) (l :: TyFun Schema Bool) - = forall arg. KindOf (Apply (AttrNotInSym1 l) arg) ~ KindOf (AttrNotInSym2 l arg) => - AttrNotInSym1KindInference - type instance Apply (AttrNotInSym1 l) l = AttrNotInSym2 l l - instance SuppressUnusedWarnings AttrNotInSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) AttrNotInSym0KindInference GHC.Tuple.()) - data AttrNotInSym0 (l :: TyFun Attribute (TyFun Schema Bool -> *)) - = forall arg. KindOf (Apply AttrNotInSym0 arg) ~ KindOf (AttrNotInSym1 arg) => - AttrNotInSym0KindInference - type instance Apply AttrNotInSym0 l = AttrNotInSym1 l - type DisjointSym2 (t :: Schema) (t :: Schema) = Disjoint t t - instance SuppressUnusedWarnings DisjointSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) DisjointSym1KindInference GHC.Tuple.()) - data DisjointSym1 (l :: Schema) (l :: TyFun Schema Bool) - = forall arg. KindOf (Apply (DisjointSym1 l) arg) ~ KindOf (DisjointSym2 l arg) => - DisjointSym1KindInference - type instance Apply (DisjointSym1 l) l = DisjointSym2 l l - instance SuppressUnusedWarnings DisjointSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) DisjointSym0KindInference GHC.Tuple.()) - data DisjointSym0 (l :: TyFun Schema (TyFun Schema Bool -> *)) - = forall arg. KindOf (Apply DisjointSym0 arg) ~ KindOf (DisjointSym1 arg) => - DisjointSym0KindInference - type instance Apply DisjointSym0 l = DisjointSym1 l - type AppendSym2 (t :: Schema) (t :: Schema) = Append t t - instance SuppressUnusedWarnings AppendSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) AppendSym1KindInference GHC.Tuple.()) - data AppendSym1 (l :: Schema) (l :: TyFun Schema Schema) - = forall arg. KindOf (Apply (AppendSym1 l) arg) ~ KindOf (AppendSym2 l arg) => - AppendSym1KindInference - type instance Apply (AppendSym1 l) l = AppendSym2 l l - instance SuppressUnusedWarnings AppendSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) AppendSym0KindInference GHC.Tuple.()) - data AppendSym0 (l :: TyFun Schema (TyFun Schema Schema -> *)) - = forall arg. KindOf (Apply AppendSym0 arg) ~ KindOf (AppendSym1 arg) => - AppendSym0KindInference - type instance Apply AppendSym0 l = AppendSym1 l - type family Lookup (a :: [AChar]) (a :: Schema) :: U where - Lookup _z_0123456789 (Sch '[]) = Any - Lookup name (Sch ((:) (Attr name' u) attrs)) = Case_0123456789 name name' u attrs (Let0123456789Scrutinee_0123456789Sym4 name name' u attrs) - type family Occurs (a :: [AChar]) (a :: Schema) :: Bool where - Occurs _z_0123456789 (Sch '[]) = FalseSym0 - Occurs name (Sch ((:) (Attr name' _z_0123456789) attrs)) = Apply (Apply (:||$) (Apply (Apply (:==$) name) name')) (Apply (Apply OccursSym0 name) (Apply SchSym0 attrs)) - type family AttrNotIn (a :: Attribute) (a :: Schema) :: Bool where - AttrNotIn _z_0123456789 (Sch '[]) = TrueSym0 - AttrNotIn (Attr name u) (Sch ((:) (Attr name' _z_0123456789) t)) = Apply (Apply (:&&$) (Apply (Apply (:/=$) name) name')) (Apply (Apply AttrNotInSym0 (Apply (Apply AttrSym0 name) u)) (Apply SchSym0 t)) - type family Disjoint (a :: Schema) (a :: Schema) :: Bool where - Disjoint (Sch '[]) _z_0123456789 = TrueSym0 - Disjoint (Sch ((:) h t)) s = Apply (Apply (:&&$) (Apply (Apply AttrNotInSym0 h) s)) (Apply (Apply DisjointSym0 (Apply SchSym0 t)) s) - type family Append (a :: Schema) (a :: Schema) :: Schema where - Append (Sch s1) (Sch s2) = Apply SchSym0 (Apply (Apply (:++$) s1) s2) - 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) - sAttrNotIn :: - forall (t :: Attribute) (t :: Schema). - Sing t -> Sing t -> Sing (Apply (Apply AttrNotInSym0 t) t :: Bool) - sDisjoint :: - forall (t :: Schema) (t :: Schema). - Sing t -> Sing t -> Sing (Apply (Apply DisjointSym0 t) t :: Bool) - sAppend :: - forall (t :: Schema) (t :: Schema). - Sing t -> Sing t -> Sing (Apply (Apply AppendSym0 t) t :: Schema) - sLookup _s_z_0123456789 (SSch SNil) - = let - lambda :: - forall _z_0123456789. (t ~ _z_0123456789, t ~ Apply SchSym0 '[]) => - Sing _z_0123456789 -> Sing (Apply (Apply LookupSym0 t) t :: U) - lambda _z_0123456789 = undefined - in lambda _s_z_0123456789 - sLookup sName (SSch (SCons (SAttr sName' sU) sAttrs)) - = let - lambda :: - forall name name' u attrs. (t ~ name, - t ~ Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') u)) attrs)) => - Sing name - -> Sing name' - -> Sing u -> Sing attrs -> Sing (Apply (Apply LookupSym0 t) t :: U) - lambda name name' u attrs - = let - sScrutinee_0123456789 :: - Sing (Let0123456789Scrutinee_0123456789Sym4 name name' u attrs) - sScrutinee_0123456789 - = applySing - (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) name) name' - in case sScrutinee_0123456789 of { - STrue - -> let - lambda :: - TrueSym0 ~ Let0123456789Scrutinee_0123456789Sym4 name name' u attrs => - Sing (Case_0123456789 name name' u attrs TrueSym0 :: U) - lambda = u - in lambda - SFalse - -> let - lambda :: - FalseSym0 ~ Let0123456789Scrutinee_0123456789Sym4 name name' u attrs => - Sing (Case_0123456789 name name' u attrs FalseSym0 :: U) - lambda - = applySing - (applySing (singFun2 (Proxy :: Proxy LookupSym0) sLookup) name) - (applySing (singFun1 (Proxy :: Proxy SchSym0) SSch) attrs) - in lambda } :: - Sing (Case_0123456789 name name' u attrs (Let0123456789Scrutinee_0123456789Sym4 name name' u attrs) :: U) - in lambda sName sName' sU sAttrs - sOccurs _s_z_0123456789 (SSch SNil) - = let - lambda :: - forall _z_0123456789. (t ~ _z_0123456789, t ~ Apply SchSym0 '[]) => - Sing _z_0123456789 -> Sing (Apply (Apply OccursSym0 t) t :: Bool) - lambda _z_0123456789 = SFalse - in lambda _s_z_0123456789 - sOccurs sName (SSch (SCons (SAttr sName' _s_z_0123456789) sAttrs)) - = let - lambda :: - forall name name' _z_0123456789 attrs. (t ~ name, - t ~ Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') _z_0123456789)) attrs)) => - Sing name - -> Sing name' - -> Sing _z_0123456789 - -> Sing attrs -> Sing (Apply (Apply OccursSym0 t) t :: Bool) - lambda name name' _z_0123456789 attrs - = applySing - (applySing - (singFun2 (Proxy :: Proxy (:||$)) (%:||)) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) name) name')) - (applySing - (applySing (singFun2 (Proxy :: Proxy OccursSym0) sOccurs) name) - (applySing (singFun1 (Proxy :: Proxy SchSym0) SSch) attrs)) - in lambda sName sName' _s_z_0123456789 sAttrs - sAttrNotIn _s_z_0123456789 (SSch SNil) - = let - lambda :: - forall _z_0123456789. (t ~ _z_0123456789, t ~ Apply SchSym0 '[]) => - Sing _z_0123456789 - -> Sing (Apply (Apply AttrNotInSym0 t) t :: Bool) - lambda _z_0123456789 = STrue - in lambda _s_z_0123456789 - sAttrNotIn - (SAttr sName sU) - (SSch (SCons (SAttr sName' _s_z_0123456789) sT)) - = let - lambda :: - forall name - u - name' - _z_0123456789 - t. (t ~ Apply (Apply AttrSym0 name) u, - t ~ Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 name') _z_0123456789)) t)) => - Sing name - -> Sing u - -> Sing name' - -> Sing _z_0123456789 - -> Sing t -> Sing (Apply (Apply AttrNotInSym0 t) t :: Bool) - lambda name u name' _z_0123456789 t - = applySing - (applySing - (singFun2 (Proxy :: Proxy (:&&$)) (%:&&)) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:/=$)) (%:/=)) name) name')) - (applySing - (applySing - (singFun2 (Proxy :: Proxy AttrNotInSym0) sAttrNotIn) - (applySing - (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) name) u)) - (applySing (singFun1 (Proxy :: Proxy SchSym0) SSch) t)) - in lambda sName sU sName' _s_z_0123456789 sT - sDisjoint (SSch SNil) _s_z_0123456789 - = let - lambda :: - forall _z_0123456789. (t ~ Apply SchSym0 '[], t ~ _z_0123456789) => - Sing _z_0123456789 -> Sing (Apply (Apply DisjointSym0 t) t :: Bool) - lambda _z_0123456789 = STrue - in lambda _s_z_0123456789 - sDisjoint (SSch (SCons sH sT)) sS - = let - lambda :: - forall h t s. (t ~ Apply SchSym0 (Apply (Apply (:$) h) t), - t ~ s) => - Sing h - -> Sing t - -> Sing s -> Sing (Apply (Apply DisjointSym0 t) t :: Bool) - lambda h t s - = applySing - (applySing - (singFun2 (Proxy :: Proxy (:&&$)) (%:&&)) - (applySing - (applySing (singFun2 (Proxy :: Proxy AttrNotInSym0) sAttrNotIn) h) - s)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy DisjointSym0) sDisjoint) - (applySing (singFun1 (Proxy :: Proxy SchSym0) SSch) t)) - s) - in lambda sH sT sS - sAppend (SSch sS1) (SSch sS2) - = let - lambda :: - forall s1 s2. (t ~ Apply SchSym0 s1, t ~ Apply SchSym0 s2) => - Sing s1 -> Sing s2 -> Sing (Apply (Apply AppendSym0 t) t :: Schema) - lambda s1 s2 - = applySing - (singFun1 (Proxy :: Proxy SchSym0) SSch) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:++$)) (%:++)) s1) s2) - in lambda sS1 sS2 - data instance Sing (z :: U) - = z ~ BOOL => SBOOL | - z ~ STRING => SSTRING | - z ~ NAT => SNAT | - forall (n :: U) (n :: Nat). z ~ VEC n n => - SVEC (Sing (n :: U)) (Sing (n :: Nat)) - type SU = (Sing :: U -> *) - instance SingKind (KProxy :: KProxy U) where - type DemoteRep (KProxy :: KProxy 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 b) - = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy U)) - (toSing b :: SomeSing (KProxy :: KProxy Nat)) - of { - GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SVEC c c) } - instance SEq (KProxy :: KProxy U) where - (%:==) 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 a a) (SVEC b b) = (%:&&) ((%:==) a b) ((%:==) a b) - instance SDecide (KProxy :: KProxy U) where - (%~) SBOOL SBOOL = Proved Refl - (%~) SBOOL SSTRING - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SBOOL SNAT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SBOOL (SVEC _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SSTRING SBOOL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SSTRING SSTRING = Proved Refl - (%~) SSTRING SNAT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SSTRING (SVEC _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SNAT SBOOL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SNAT SSTRING - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SNAT SNAT = Proved Refl - (%~) SNAT (SVEC _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SVEC _ _) SBOOL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SVEC _ _) SSTRING - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SVEC _ _) SNAT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SVEC a a) (SVEC b b) - = case GHC.Tuple.(,) ((%~) a b) ((%~) a b) of { - GHC.Tuple.(,) (Proved Refl) (Proved Refl) -> Proved Refl - GHC.Tuple.(,) (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,) _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) } - data instance Sing (z :: AChar) - = z ~ CA => SCA | - z ~ CB => SCB | - z ~ CC => SCC | - z ~ CD => SCD | - z ~ CE => SCE | - z ~ CF => SCF | - z ~ CG => SCG | - z ~ CH => SCH | - z ~ CI => SCI | - z ~ CJ => SCJ | - z ~ CK => SCK | - z ~ CL => SCL | - z ~ CM => SCM | - z ~ CN => SCN | - z ~ CO => SCO | - z ~ CP => SCP | - z ~ CQ => SCQ | - z ~ CR => SCR | - z ~ CS => SCS | - z ~ CT => SCT | - z ~ CU => SCU | - z ~ CV => SCV | - z ~ CW => SCW | - z ~ CX => SCX | - z ~ CY => SCY | - z ~ CZ => SCZ - type SAChar = (Sing :: AChar -> *) - instance SingKind (KProxy :: KProxy AChar) where - type DemoteRep (KProxy :: KProxy 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 - instance SEq (KProxy :: KProxy AChar) where - (%:==) 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 (KProxy :: KProxy AChar) where - (%~) SCA SCA = Proved Refl - (%~) SCA SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCA SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCB = Proved Refl - (%~) SCB SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCB SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCC = Proved Refl - (%~) SCC SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCC SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCD = Proved Refl - (%~) SCD SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCD SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCE = Proved Refl - (%~) SCE SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCE SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCF = Proved Refl - (%~) SCF SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCF SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCG = Proved Refl - (%~) SCG SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCG SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCH = Proved Refl - (%~) SCH SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCH SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCI = Proved Refl - (%~) SCI SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCI SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCJ = Proved Refl - (%~) SCJ SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCJ SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCK = Proved Refl - (%~) SCK SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCK SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCL = Proved Refl - (%~) SCL SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCL SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCM = Proved Refl - (%~) SCM SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCM SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCN = Proved Refl - (%~) SCN SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCN SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCO = Proved Refl - (%~) SCO SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCO SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCP = Proved Refl - (%~) SCP SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCP SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCQ = Proved Refl - (%~) SCQ SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCQ SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCR = Proved Refl - (%~) SCR SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCR SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCS = Proved Refl - (%~) SCS SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCS SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCT = Proved Refl - (%~) SCT SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCT SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCU = Proved Refl - (%~) SCU SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCU SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCV = Proved Refl - (%~) SCV SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCV SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCW = Proved Refl - (%~) SCW SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCW SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCX = Proved Refl - (%~) SCX SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCX SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCY SCY = Proved Refl - (%~) SCY SCZ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCA - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCB - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCC - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCD - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCE - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCF - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCG - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCH - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCI - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCJ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCK - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCL - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCM - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCN - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCO - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCP - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCQ - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCR - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCS - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCT - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCU - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCV - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCW - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCX - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCY - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SCZ SCZ = Proved Refl - data instance Sing (z :: Attribute) - = forall (n :: [AChar]) (n :: U). z ~ Attr n n => - SAttr (Sing (n :: [AChar])) (Sing (n :: U)) - type SAttribute = (Sing :: Attribute -> *) - instance SingKind (KProxy :: KProxy Attribute) where - type DemoteRep (KProxy :: KProxy Attribute) = Attribute - fromSing (SAttr b b) = Attr (fromSing b) (fromSing b) - toSing (Attr b b) - = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy [AChar])) - (toSing b :: SomeSing (KProxy :: KProxy U)) - of { - GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SAttr c c) } - data instance Sing (z :: Schema) - = forall (n :: [Attribute]). z ~ Sch n => - SSch (Sing (n :: [Attribute])) - type SSchema = (Sing :: Schema -> *) - instance SingKind (KProxy :: KProxy Schema) where - type DemoteRep (KProxy :: KProxy Schema) = Schema - fromSing (SSch b) = Sch (fromSing b) - toSing (Sch b) - = case toSing b :: SomeSing (KProxy :: KProxy [Attribute]) of { - SomeSing c -> SomeSing (SSch c) } - 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 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 => SingI (Sch (n :: [Attribute])) where - sing = SSch sing -GradingClient/Database.hs:0:0:: Splicing declarations - return [] ======> -GradingClient/Database.hs:(0,0)-(0,0): Splicing expression - cases ''Row [| r |] [| changeId (n ++ (getId r)) r |] - ======> - case r of { - EmptyRow _ -> changeId ((++) n (getId r)) r - ConsRow _ _ -> changeId ((++) n (getId r)) r } diff --git a/tests/compile-and-dump/GradingClient/Database.ghc80.template b/tests/compile-and-dump/GradingClient/Database.ghc80.template --- a/tests/compile-and-dump/GradingClient/Database.ghc80.template +++ b/tests/compile-and-dump/GradingClient/Database.ghc80.template @@ -11,7 +11,7 @@ Equals_0123456789 Zero Zero = TrueSym0 Equals_0123456789 (Succ a) (Succ b) = (:==) a b Equals_0123456789 (a :: Nat) (b :: Nat) = FalseSym0 - instance PEq (KProxy :: KProxy Nat) where + instance PEq (Proxy :: Proxy Nat) where type (:==) (a :: Nat) (b :: Nat) = Equals_0123456789 a b type ZeroSym0 = Zero type SuccSym1 (t :: Nat) = Succ t @@ -47,26 +47,26 @@ = forall arg. KindOf (Apply Compare_0123456789Sym0 arg) ~ KindOf (Compare_0123456789Sym1 arg) => Compare_0123456789Sym0KindInference type instance Apply Compare_0123456789Sym0 l = Compare_0123456789Sym1 l - instance POrd (KProxy :: KProxy Nat) where + instance POrd (Proxy :: Proxy Nat) where type Compare (a :: Nat) (a :: Nat) = Apply (Apply Compare_0123456789Sym0 a) a data instance Sing (z :: Nat) = z ~ Zero => SZero | forall (n :: Nat). z ~ Succ n => SSucc (Sing (n :: Nat)) type SNat = (Sing :: Nat -> Type) - instance SingKind (KProxy :: KProxy Nat) where - type DemoteRep (KProxy :: KProxy Nat) = Nat + instance SingKind Nat where + type DemoteRep Nat = Nat fromSing SZero = Zero fromSing (SSucc b) = Succ (fromSing b) toSing Zero = SomeSing SZero toSing (Succ b) - = case toSing b :: SomeSing (KProxy :: KProxy Nat) of { + = case toSing b :: SomeSing Nat of { SomeSing c -> SomeSing (SSucc c) } - instance SEq (KProxy :: KProxy Nat) where + instance SEq Nat where (%:==) SZero SZero = STrue (%:==) SZero (SSucc _) = SFalse (%:==) (SSucc _) SZero = SFalse (%:==) (SSucc a) (SSucc b) = (%:==) a b - instance SDecide (KProxy :: KProxy Nat) where + instance SDecide Nat where (%~) SZero SZero = Proved Refl (%~) SZero (SSucc _) = Disproved @@ -83,8 +83,7 @@ Proved Refl -> Proved Refl Disproved contra -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) } - instance SOrd (KProxy :: KProxy Nat) => - SOrd (KProxy :: KProxy Nat) where + instance SOrd Nat => SOrd Nat where sCompare :: forall (t0 :: Nat) (t1 :: Nat). Sing t0 @@ -265,7 +264,7 @@ Equals_0123456789 NAT NAT = TrueSym0 Equals_0123456789 (VEC a a) (VEC b b) = (:&&) ((:==) a b) ((:==) a b) Equals_0123456789 (a :: U) (b :: U) = FalseSym0 - instance PEq (KProxy :: KProxy U) where + instance PEq (Proxy :: Proxy U) where type (:==) (a :: U) (b :: U) = Equals_0123456789 a b type BOOLSym0 = BOOL type STRINGSym0 = STRING @@ -314,7 +313,7 @@ Equals_0123456789 CY CY = TrueSym0 Equals_0123456789 CZ CZ = TrueSym0 Equals_0123456789 (a :: AChar) (b :: AChar) = FalseSym0 - instance PEq (KProxy :: KProxy AChar) where + instance PEq (Proxy :: Proxy AChar) where type (:==) (a :: AChar) (b :: AChar) = Equals_0123456789 a b type CASym0 = CA type CBSym0 = CB @@ -671,8 +670,8 @@ forall (n :: U) (n :: Nat). z ~ VEC n n => SVEC (Sing (n :: U)) (Sing (n :: Nat)) type SU = (Sing :: U -> Type) - instance SingKind (KProxy :: KProxy U) where - type DemoteRep (KProxy :: KProxy U) = U + instance SingKind U where + type DemoteRep U = U fromSing SBOOL = BOOL fromSing SSTRING = STRING fromSing SNAT = NAT @@ -682,12 +681,10 @@ toSing NAT = SomeSing SNAT toSing (VEC b b) = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy U)) - (toSing b :: SomeSing (KProxy :: KProxy Nat)) + GHC.Tuple.(,) (toSing b :: SomeSing U) (toSing b :: SomeSing Nat) of { GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SVEC c c) } - instance SEq (KProxy :: KProxy U) where + instance SEq U where (%:==) SBOOL SBOOL = STrue (%:==) SBOOL SSTRING = SFalse (%:==) SBOOL SNAT = SFalse @@ -704,7 +701,7 @@ (%:==) (SVEC _ _) SSTRING = SFalse (%:==) (SVEC _ _) SNAT = SFalse (%:==) (SVEC a a) (SVEC b b) = (%:&&) ((%:==) a b) ((%:==) a b) - instance SDecide (KProxy :: KProxy U) where + instance SDecide U where (%~) SBOOL SBOOL = Proved Refl (%~) SBOOL SSTRING = Disproved @@ -803,8 +800,8 @@ z ~ CY => SCY | z ~ CZ => SCZ type SAChar = (Sing :: AChar -> Type) - instance SingKind (KProxy :: KProxy AChar) where - type DemoteRep (KProxy :: KProxy AChar) = AChar + instance SingKind AChar where + type DemoteRep AChar = AChar fromSing SCA = CA fromSing SCB = CB fromSing SCC = CC @@ -857,7 +854,7 @@ toSing CX = SomeSing SCX toSing CY = SomeSing SCY toSing CZ = SomeSing SCZ - instance SEq (KProxy :: KProxy AChar) where + instance SEq AChar where (%:==) SCA SCA = STrue (%:==) SCA SCB = SFalse (%:==) SCA SCC = SFalse @@ -1534,7 +1531,7 @@ (%:==) SCZ SCX = SFalse (%:==) SCZ SCY = SFalse (%:==) SCZ SCZ = STrue - instance SDecide (KProxy :: KProxy AChar) where + instance SDecide AChar where (%~) SCA SCA = Proved Refl (%~) SCA SCB = Disproved @@ -4815,25 +4812,24 @@ = forall (n :: [AChar]) (n :: U). z ~ Attr n n => SAttr (Sing (n :: [AChar])) (Sing (n :: U)) type SAttribute = (Sing :: Attribute -> Type) - instance SingKind (KProxy :: KProxy Attribute) where - type DemoteRep (KProxy :: KProxy Attribute) = Attribute + instance SingKind Attribute where + type DemoteRep Attribute = Attribute fromSing (SAttr b b) = Attr (fromSing b) (fromSing b) toSing (Attr b b) = case GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy [AChar])) - (toSing b :: SomeSing (KProxy :: KProxy U)) + (toSing b :: SomeSing [AChar]) (toSing b :: SomeSing U) of { GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SAttr c c) } data instance Sing (z :: Schema) = forall (n :: [Attribute]). z ~ Sch n => SSch (Sing (n :: [Attribute])) type SSchema = (Sing :: Schema -> Type) - instance SingKind (KProxy :: KProxy Schema) where - type DemoteRep (KProxy :: KProxy Schema) = Schema + instance SingKind Schema where + type DemoteRep Schema = Schema fromSing (SSch b) = Sch (fromSing b) toSing (Sch b) - = case toSing b :: SomeSing (KProxy :: KProxy [Attribute]) of { + = case toSing b :: SomeSing [Attribute] of { SomeSing c -> SomeSing (SSch c) } instance SingI BOOL where sing = SBOOL 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 @@ -28,6 +28,7 @@ import Data.Singletons.TH import Control.Monad import Data.List hiding ( tail ) +import Data.Kind #ifdef MODERN_MTL import Control.Monad.Except ( throwError ) @@ -35,9 +36,6 @@ import Control.Monad.Error ( throwError ) #endif -#if __GLASGOW_HASKELL__ >= 711 -import Data.Kind -#endif $(singletons [d| -- Basic Nat type @@ -494,9 +492,6 @@ -- for incomplete pattern matches when the remaining cases are impossible. -- So, we include this case (impossible to reach for any terminated value) -- to suppress the warning. -#if __GLASGOW_HASKELL__ < 711 - _ -> error "Type checking failed" -#endif -- Retrieves the element, looked up by the name of the provided attribute, -- from a row. The explicit quantification is necessary to create the scoped @@ -507,15 +502,9 @@ InElt -> case r of ConsRow h _ -> h -- EmptyRow _ -> undefined <== IMPOSSIBLE -#if __GLASGOW_HASKELL__ < 711 - _ -> error "Type checking failed" -#endif InTail -> case r of ConsRow _ t -> extractElt attr t -- EmptyRow _ -> undefined <== IMPOSSBLE -#if __GLASGOW_HASKELL__ < 711 - _ -> error "Type checking failed" -#endif query (Select expr r) = do rows <- query r @@ -534,10 +523,6 @@ case name %:== name' of STrue -> h SFalse -> withSingI stail (eval (Element (SSch stail) name) t) - _ -> bugInGHC -#if __GLASGOW_HASKELL__ < 711 - _ -> bugInGHC -#endif eval (Equal (e1 :: Expr s' u') e2) row = let v1 = eval e1 row diff --git a/tests/compile-and-dump/GradingClient/Main.ghc710.template b/tests/compile-and-dump/GradingClient/Main.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/GradingClient/Main.ghc710.template +++ /dev/null @@ -1,162 +0,0 @@ -GradingClient/Main.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| lastName, firstName, yearName, gradeName, majorName :: [AChar] - lastName = [CL, CA, CS, CT] - firstName = [CF, CI, CR, CS, CT] - yearName = [CY, CE, CA, CR] - gradeName = [CG, CR, CA, CD, CE] - majorName = [CM, CA, CJ, CO, CR] - gradingSchema :: Schema - gradingSchema - = Sch - [Attr lastName STRING, Attr firstName STRING, Attr yearName NAT, - Attr gradeName NAT, Attr majorName BOOL] - names :: Schema - names = Sch [Attr firstName STRING, Attr lastName STRING] |] - ======> - lastName :: [AChar] - firstName :: [AChar] - yearName :: [AChar] - gradeName :: [AChar] - majorName :: [AChar] - lastName = [CL, CA, CS, CT] - firstName = [CF, CI, CR, CS, CT] - yearName = [CY, CE, CA, CR] - gradeName = [CG, CR, CA, CD, CE] - majorName = [CM, CA, CJ, CO, CR] - gradingSchema :: Schema - gradingSchema - = Sch - [Attr lastName STRING, Attr firstName STRING, Attr yearName NAT, - Attr gradeName NAT, Attr majorName BOOL] - names :: Schema - names = Sch [Attr firstName STRING, Attr lastName STRING] - type MajorNameSym0 = MajorName - type GradeNameSym0 = GradeName - type YearNameSym0 = YearName - type FirstNameSym0 = FirstName - type LastNameSym0 = LastName - type GradingSchemaSym0 = GradingSchema - type NamesSym0 = Names - type family MajorName :: [AChar] where - MajorName = Apply (Apply (:$) CMSym0) (Apply (Apply (:$) CASym0) (Apply (Apply (:$) CJSym0) (Apply (Apply (:$) COSym0) (Apply (Apply (:$) CRSym0) '[])))) - type family GradeName :: [AChar] where - GradeName = Apply (Apply (:$) CGSym0) (Apply (Apply (:$) CRSym0) (Apply (Apply (:$) CASym0) (Apply (Apply (:$) CDSym0) (Apply (Apply (:$) CESym0) '[])))) - type family YearName :: [AChar] where - YearName = Apply (Apply (:$) CYSym0) (Apply (Apply (:$) CESym0) (Apply (Apply (:$) CASym0) (Apply (Apply (:$) CRSym0) '[]))) - type family FirstName :: [AChar] where - FirstName = Apply (Apply (:$) CFSym0) (Apply (Apply (:$) CISym0) (Apply (Apply (:$) CRSym0) (Apply (Apply (:$) CSSym0) (Apply (Apply (:$) CTSym0) '[])))) - type family LastName :: [AChar] where - LastName = Apply (Apply (:$) CLSym0) (Apply (Apply (:$) CASym0) (Apply (Apply (:$) CSSym0) (Apply (Apply (:$) CTSym0) '[]))) - type family GradingSchema :: Schema where - GradingSchema = Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 LastNameSym0) STRINGSym0)) (Apply (Apply (:$) (Apply (Apply AttrSym0 FirstNameSym0) STRINGSym0)) (Apply (Apply (:$) (Apply (Apply AttrSym0 YearNameSym0) NATSym0)) (Apply (Apply (:$) (Apply (Apply AttrSym0 GradeNameSym0) NATSym0)) (Apply (Apply (:$) (Apply (Apply AttrSym0 MajorNameSym0) BOOLSym0)) '[]))))) - type family Names :: Schema where - Names = Apply SchSym0 (Apply (Apply (:$) (Apply (Apply AttrSym0 FirstNameSym0) STRINGSym0)) (Apply (Apply (:$) (Apply (Apply AttrSym0 LastNameSym0) STRINGSym0)) '[])) - sMajorName :: Sing (MajorNameSym0 :: [AChar]) - sGradeName :: Sing (GradeNameSym0 :: [AChar]) - sYearName :: Sing (YearNameSym0 :: [AChar]) - sFirstName :: Sing (FirstNameSym0 :: [AChar]) - sLastName :: Sing (LastNameSym0 :: [AChar]) - sGradingSchema :: Sing (GradingSchemaSym0 :: Schema) - sNames :: Sing (NamesSym0 :: Schema) - sMajorName - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCM) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCA) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCJ) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCO) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCR) SNil)))) - sGradeName - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCG) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCR) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCA) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCD) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCE) SNil)))) - sYearName - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCY) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCE) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCA) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCR) SNil))) - sFirstName - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCF) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCI) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCR) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCS) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCT) SNil)))) - sLastName - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCL) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCA) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCS) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SCT) SNil))) - sGradingSchema - = applySing - (singFun1 (Proxy :: Proxy SchSym0) SSch) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sLastName) - SSTRING)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sFirstName) - SSTRING)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sYearName) - SNAT)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sGradeName) - SNAT)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sMajorName) - SBOOL)) - SNil))))) - sNames - = applySing - (singFun1 (Proxy :: Proxy SchSym0) SSch) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sFirstName) - SSTRING)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing (singFun2 (Proxy :: Proxy AttrSym0) SAttr) sLastName) - SSTRING)) - SNil)) diff --git a/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc710.template b/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc710.template +++ /dev/null @@ -1,234 +0,0 @@ -InsertionSort/InsertionSortImp.hs:(0,0)-(0,0): Splicing declarations - singletons [d| data Nat = Zero | Succ Nat |] - ======> - data Nat = Zero | Succ Nat - type ZeroSym0 = Zero - type SuccSym1 (t :: Nat) = Succ t - instance SuppressUnusedWarnings SuccSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.()) - data SuccSym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply SuccSym0 arg) ~ KindOf (SuccSym1 arg) => - SuccSym0KindInference - type instance Apply SuccSym0 l = SuccSym1 l - data instance Sing (z :: Nat) - = z ~ Zero => SZero | - forall (n :: Nat). z ~ Succ n => SSucc (Sing (n :: Nat)) - type SNat = (Sing :: Nat -> *) - instance SingKind (KProxy :: KProxy Nat) where - type DemoteRep (KProxy :: KProxy Nat) = Nat - fromSing SZero = Zero - fromSing (SSucc b) = Succ (fromSing b) - toSing Zero = SomeSing SZero - toSing (Succ b) - = case toSing b :: SomeSing (KProxy :: KProxy Nat) of { - SomeSing c -> SomeSing (SSucc c) } - instance SingI Zero where - sing = SZero - instance SingI n => SingI (Succ (n :: Nat)) where - sing = SSucc sing -InsertionSort/InsertionSortImp.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| leq :: Nat -> Nat -> Bool - leq Zero _ = True - leq (Succ _) Zero = False - leq (Succ a) (Succ b) = leq a b - insert :: Nat -> [Nat] -> [Nat] - insert n [] = [n] - insert n (h : t) - = if leq n h then (n : h : t) else h : (insert n t) - insertionSort :: [Nat] -> [Nat] - insertionSort [] = [] - insertionSort (h : t) = insert h (insertionSort t) |] - ======> - leq :: Nat -> Nat -> Bool - leq Zero _ = True - leq (Succ _) Zero = False - leq (Succ a) (Succ b) = leq a b - insert :: Nat -> [Nat] -> [Nat] - insert n GHC.Types.[] = [n] - insert n (h GHC.Types.: t) - = if leq n h then - (n GHC.Types.: (h GHC.Types.: t)) - else - (h GHC.Types.: (insert n t)) - insertionSort :: [Nat] -> [Nat] - insertionSort GHC.Types.[] = [] - insertionSort (h GHC.Types.: t) = insert h (insertionSort t) - type Let0123456789Scrutinee_0123456789Sym3 t t t = - Let0123456789Scrutinee_0123456789 t t t - instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) - Let0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.()) - data Let0123456789Scrutinee_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym3 l l arg) => - Let0123456789Scrutinee_0123456789Sym2KindInference - type instance Apply (Let0123456789Scrutinee_0123456789Sym2 l l) l = Let0123456789Scrutinee_0123456789Sym3 l l l - instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) - Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.()) - data Let0123456789Scrutinee_0123456789Sym1 l l - = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) => - Let0123456789Scrutinee_0123456789Sym1KindInference - type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l - instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) - Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.()) - data Let0123456789Scrutinee_0123456789Sym0 l - = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) => - Let0123456789Scrutinee_0123456789Sym0KindInference - type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l - type family Let0123456789Scrutinee_0123456789 n h t where - Let0123456789Scrutinee_0123456789 n h t = Apply (Apply LeqSym0 n) h - type family Case_0123456789 n h t t where - Case_0123456789 n h t True = Apply (Apply (:$) n) (Apply (Apply (:$) h) t) - Case_0123456789 n h t False = Apply (Apply (:$) h) (Apply (Apply InsertSym0 n) t) - type LeqSym2 (t :: Nat) (t :: Nat) = Leq t t - instance SuppressUnusedWarnings LeqSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) LeqSym1KindInference GHC.Tuple.()) - data LeqSym1 (l :: Nat) (l :: TyFun Nat Bool) - = forall arg. KindOf (Apply (LeqSym1 l) arg) ~ KindOf (LeqSym2 l arg) => - LeqSym1KindInference - type instance Apply (LeqSym1 l) l = LeqSym2 l l - instance SuppressUnusedWarnings LeqSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) LeqSym0KindInference GHC.Tuple.()) - data LeqSym0 (l :: TyFun Nat (TyFun Nat Bool -> *)) - = forall arg. KindOf (Apply LeqSym0 arg) ~ KindOf (LeqSym1 arg) => - LeqSym0KindInference - type instance Apply LeqSym0 l = LeqSym1 l - type InsertSym2 (t :: Nat) (t :: [Nat]) = Insert t t - instance SuppressUnusedWarnings InsertSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) InsertSym1KindInference GHC.Tuple.()) - data InsertSym1 (l :: Nat) (l :: TyFun [Nat] [Nat]) - = forall arg. KindOf (Apply (InsertSym1 l) arg) ~ KindOf (InsertSym2 l arg) => - InsertSym1KindInference - type instance Apply (InsertSym1 l) l = InsertSym2 l l - instance SuppressUnusedWarnings InsertSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) InsertSym0KindInference GHC.Tuple.()) - data InsertSym0 (l :: TyFun Nat (TyFun [Nat] [Nat] -> *)) - = forall arg. KindOf (Apply InsertSym0 arg) ~ KindOf (InsertSym1 arg) => - InsertSym0KindInference - type instance Apply InsertSym0 l = InsertSym1 l - type InsertionSortSym1 (t :: [Nat]) = InsertionSort t - instance SuppressUnusedWarnings InsertionSortSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) InsertionSortSym0KindInference GHC.Tuple.()) - data InsertionSortSym0 (l :: TyFun [Nat] [Nat]) - = forall arg. KindOf (Apply InsertionSortSym0 arg) ~ KindOf (InsertionSortSym1 arg) => - InsertionSortSym0KindInference - type instance Apply InsertionSortSym0 l = InsertionSortSym1 l - type family Leq (a :: Nat) (a :: Nat) :: Bool where - Leq Zero _z_0123456789 = TrueSym0 - Leq (Succ _z_0123456789) Zero = FalseSym0 - Leq (Succ a) (Succ b) = Apply (Apply LeqSym0 a) b - type family Insert (a :: Nat) (a :: [Nat]) :: [Nat] where - Insert n '[] = Apply (Apply (:$) n) '[] - Insert n ((:) h t) = Case_0123456789 n h t (Let0123456789Scrutinee_0123456789Sym3 n h t) - type family InsertionSort (a :: [Nat]) :: [Nat] where - InsertionSort '[] = '[] - InsertionSort ((:) h t) = Apply (Apply InsertSym0 h) (Apply InsertionSortSym0 t) - sLeq :: - forall (t :: Nat) (t :: Nat). - Sing t -> Sing t -> Sing (Apply (Apply LeqSym0 t) t :: Bool) - sInsert :: - forall (t :: Nat) (t :: [Nat]). - Sing t -> Sing t -> Sing (Apply (Apply InsertSym0 t) t :: [Nat]) - sInsertionSort :: - forall (t :: [Nat]). - Sing t -> Sing (Apply InsertionSortSym0 t :: [Nat]) - sLeq SZero _s_z_0123456789 - = let - lambda :: - forall _z_0123456789. (t ~ ZeroSym0, t ~ _z_0123456789) => - Sing _z_0123456789 -> Sing (Apply (Apply LeqSym0 t) t :: Bool) - lambda _z_0123456789 = STrue - in lambda _s_z_0123456789 - sLeq (SSucc _s_z_0123456789) SZero - = let - lambda :: - forall _z_0123456789. (t ~ Apply SuccSym0 _z_0123456789, - t ~ ZeroSym0) => - Sing _z_0123456789 -> Sing (Apply (Apply LeqSym0 t) t :: Bool) - lambda _z_0123456789 = SFalse - in lambda _s_z_0123456789 - sLeq (SSucc sA) (SSucc sB) - = let - lambda :: - forall a b. (t ~ Apply SuccSym0 a, t ~ Apply SuccSym0 b) => - Sing a -> Sing b -> Sing (Apply (Apply LeqSym0 t) t :: Bool) - lambda a b - = applySing - (applySing (singFun2 (Proxy :: Proxy LeqSym0) sLeq) a) b - in lambda sA sB - sInsert sN SNil - = let - lambda :: - forall n. (t ~ n, t ~ '[]) => - Sing n -> Sing (Apply (Apply InsertSym0 t) t :: [Nat]) - lambda n - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) n) SNil - in lambda sN - sInsert sN (SCons sH sT) - = let - lambda :: - forall n h t. (t ~ n, t ~ Apply (Apply (:$) h) t) => - Sing n - -> Sing h -> Sing t -> Sing (Apply (Apply InsertSym0 t) t :: [Nat]) - lambda n h t - = let - sScrutinee_0123456789 :: - Sing (Let0123456789Scrutinee_0123456789Sym3 n h t) - sScrutinee_0123456789 - = applySing - (applySing (singFun2 (Proxy :: Proxy LeqSym0) sLeq) n) h - in case sScrutinee_0123456789 of { - STrue - -> let - lambda :: - TrueSym0 ~ Let0123456789Scrutinee_0123456789Sym3 n h t => - Sing (Case_0123456789 n h t TrueSym0 :: [Nat]) - lambda - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) n) - (applySing (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) h) t) - in lambda - SFalse - -> let - lambda :: - FalseSym0 ~ Let0123456789Scrutinee_0123456789Sym3 n h t => - Sing (Case_0123456789 n h t FalseSym0 :: [Nat]) - lambda - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) h) - (applySing - (applySing (singFun2 (Proxy :: Proxy InsertSym0) sInsert) n) t) - in lambda } :: - Sing (Case_0123456789 n h t (Let0123456789Scrutinee_0123456789Sym3 n h t) :: [Nat]) - in lambda sN sH sT - sInsertionSort SNil - = let - lambda :: t ~ '[] => Sing (Apply InsertionSortSym0 t :: [Nat]) - lambda = SNil - in lambda - sInsertionSort (SCons sH sT) - = let - lambda :: - forall h t. t ~ Apply (Apply (:$) h) t => - Sing h -> Sing t -> Sing (Apply InsertionSortSym0 t :: [Nat]) - lambda h t - = applySing - (applySing (singFun2 (Proxy :: Proxy InsertSym0) sInsert) h) - (applySing - (singFun1 (Proxy :: Proxy InsertionSortSym0) sInsertionSort) t) - in lambda sH sT diff --git a/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc80.template b/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc80.template --- a/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc80.template +++ b/tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc80.template @@ -15,13 +15,13 @@ = z ~ Zero => SZero | forall (n :: Nat). z ~ Succ n => SSucc (Sing (n :: Nat)) type SNat = (Sing :: Nat -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy Nat) where - type DemoteRep (KProxy :: KProxy Nat) = Nat + instance SingKind Nat where + type DemoteRep Nat = Nat fromSing SZero = Zero fromSing (SSucc b) = Succ (fromSing b) toSing Zero = SomeSing SZero toSing (Succ b) - = case toSing b :: SomeSing (KProxy :: KProxy Nat) of { + = case toSing b :: SomeSing Nat of { SomeSing c -> SomeSing (SSucc c) } instance SingI Zero where sing = SZero diff --git a/tests/compile-and-dump/InsertionSort/InsertionSortImp.hs b/tests/compile-and-dump/InsertionSort/InsertionSortImp.hs --- a/tests/compile-and-dump/InsertionSort/InsertionSortImp.hs +++ b/tests/compile-and-dump/InsertionSort/InsertionSortImp.hs @@ -27,17 +27,14 @@ -} -{-# LANGUAGE IncoherentInstances, ConstraintKinds, CPP, TypeFamilies, +{-# LANGUAGE IncoherentInstances, ConstraintKinds, TypeFamilies, TemplateHaskell, RankNTypes, ScopedTypeVariables, GADTs, TypeOperators, DataKinds, PolyKinds, MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, UndecidableInstances #-} module InsertionSort.InsertionSortImp where -#if __GLASGOW_HASKELL__ >= 711 import Data.Kind (type (*)) -#endif - import Data.Singletons.Prelude import Data.Singletons.SuppressUnusedWarnings import Data.Singletons.TH @@ -131,9 +128,6 @@ -- (SSucc _, SZero) -> undefined <== IMPOSSIBLE (SSucc a', SSucc b') -> case sLeq_true__le a' b' of Dict -> Dict -#if __GLASGOW_HASKELL__ < 711 - _ -> error "type checking failed" -#endif -- A lemma that states if sLeq a b is SFalse, then (b :<=: a) sLeq_false__nle :: (Leq a b ~ False) => SNat a -> SNat b -> Dict (b :<=: a) @@ -143,9 +137,6 @@ (SSucc _, SZero) -> Dict (SSucc a', SSucc b') -> case sLeq_false__nle a' b' of Dict -> Dict -#if __GLASGOW_HASKELL__ < 711 - _ -> error "type checking failed" -#endif -- A lemma that states that inserting into an ascending list produces an -- ascending list @@ -159,9 +150,6 @@ SCons h _ -> case sLeq n h of -- then check if n is <= h STrue -> case sLeq_true__le n h of Dict -> Dict -- if so, we're done SFalse -> case sLeq_false__nle n h of Dict -> Dict -- if not, we're done -#if __GLASGOW_HASKELL__ < 711 - _ -> error "type checking failed" -#endif AscCons -> case lst of -- Otherwise, if lst is more than one element... -- SNil -> undefined <== IMPOSSIBLE SCons h t -> case sLeq n h of -- then check if n is <= h @@ -174,10 +162,6 @@ case sLeq_true__le n h2 of Dict -> Dict SFalse -> -- otherwise, show that (Insert n t) is sorted case insert_ascending n t of Dict -> Dict -- and we're done -#if __GLASGOW_HASKELL__ < 711 - _ -> error "type checking failed" - _ -> error "type checking failed" -#endif -- A lemma that states that inserting n into lst produces a new list with n -- inserted into lst. diff --git a/tests/compile-and-dump/Promote/Constructors.ghc710.template b/tests/compile-and-dump/Promote/Constructors.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Promote/Constructors.ghc710.template +++ /dev/null @@ -1,79 +0,0 @@ -Promote/Constructors.hs:(0,0)-(0,0): Splicing declarations - promote - [d| data Foo = Foo | Foo :+ Foo - data Bar = Bar Bar Bar Bar Bar Foo |] - ======> - data Foo = Foo | Foo :+ Foo - data Bar = Bar Bar Bar Bar Bar Foo - type FooSym0 = Foo - type (:+$$$) (t :: Foo) (t :: Foo) = (:+) t t - instance SuppressUnusedWarnings (:+$$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.()) - data (:+$$) (l :: Foo) (l :: TyFun Foo Foo) - = forall arg. KindOf (Apply ((:+$$) l) arg) ~ KindOf ((:+$$$) l arg) => - :+$$### - type instance Apply ((:+$$) l) l = (:+$$$) l l - instance SuppressUnusedWarnings (:+$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:+$###) GHC.Tuple.()) - data (:+$) (l :: TyFun Foo (TyFun Foo Foo -> *)) - = forall arg. KindOf (Apply (:+$) arg) ~ KindOf ((:+$$) arg) => - :+$### - type instance Apply (:+$) l = (:+$$) l - type BarSym5 (t :: Bar) - (t :: Bar) - (t :: Bar) - (t :: Bar) - (t :: Foo) = - Bar t t t t t - instance SuppressUnusedWarnings BarSym4 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BarSym4KindInference GHC.Tuple.()) - data BarSym4 (l :: Bar) - (l :: Bar) - (l :: Bar) - (l :: Bar) - (l :: TyFun Foo Bar) - = forall arg. KindOf (Apply (BarSym4 l l l l) arg) ~ KindOf (BarSym5 l l l l arg) => - BarSym4KindInference - type instance Apply (BarSym4 l l l l) l = BarSym5 l l l l l - instance SuppressUnusedWarnings BarSym3 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BarSym3KindInference GHC.Tuple.()) - data BarSym3 (l :: Bar) - (l :: Bar) - (l :: Bar) - (l :: TyFun Bar (TyFun Foo Bar -> *)) - = forall arg. KindOf (Apply (BarSym3 l l l) arg) ~ KindOf (BarSym4 l l l arg) => - BarSym3KindInference - type instance Apply (BarSym3 l l l) l = BarSym4 l l l l - instance SuppressUnusedWarnings BarSym2 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BarSym2KindInference GHC.Tuple.()) - data BarSym2 (l :: Bar) - (l :: Bar) - (l :: TyFun Bar (TyFun Bar (TyFun Foo Bar -> *) -> *)) - = forall arg. KindOf (Apply (BarSym2 l l) arg) ~ KindOf (BarSym3 l l arg) => - BarSym2KindInference - type instance Apply (BarSym2 l l) l = BarSym3 l l l - instance SuppressUnusedWarnings BarSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BarSym1KindInference GHC.Tuple.()) - data BarSym1 (l :: Bar) - (l :: TyFun Bar (TyFun Bar (TyFun Bar (TyFun Foo Bar -> *) -> *) - -> *)) - = forall arg. KindOf (Apply (BarSym1 l) arg) ~ KindOf (BarSym2 l arg) => - BarSym1KindInference - type instance Apply (BarSym1 l) l = BarSym2 l l - instance SuppressUnusedWarnings BarSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.()) - data BarSym0 (l :: TyFun Bar (TyFun Bar (TyFun Bar (TyFun Bar (TyFun Foo Bar - -> *) - -> *) - -> *) - -> *)) - = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) => - BarSym0KindInference - type instance Apply BarSym0 l = BarSym1 l diff --git a/tests/compile-and-dump/Promote/GenDefunSymbols.ghc710.template b/tests/compile-and-dump/Promote/GenDefunSymbols.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Promote/GenDefunSymbols.ghc710.template +++ /dev/null @@ -1,46 +0,0 @@ -Promote/GenDefunSymbols.hs:0:0:: Splicing declarations - genDefunSymbols [''LiftMaybe, ''NatT, '':+] - ======> - type LiftMaybeSym2 (t :: TyFun a0123456789 b0123456789 -> *) - (t :: Maybe a0123456789) = - LiftMaybe t t - instance SuppressUnusedWarnings LiftMaybeSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) LiftMaybeSym1KindInference GHC.Tuple.()) - data LiftMaybeSym1 (l :: TyFun a0123456789 b0123456789 -> *) - (l :: TyFun (Maybe a0123456789) (Maybe b0123456789)) - = forall arg. Data.Singletons.KindOf (Apply (LiftMaybeSym1 l) arg) ~ Data.Singletons.KindOf (LiftMaybeSym2 l arg) => - LiftMaybeSym1KindInference - type instance Apply (LiftMaybeSym1 l) l = LiftMaybeSym2 l l - instance SuppressUnusedWarnings LiftMaybeSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) LiftMaybeSym0KindInference GHC.Tuple.()) - data LiftMaybeSym0 (l :: TyFun (TyFun a0123456789 b0123456789 - -> *) (TyFun (Maybe a0123456789) (Maybe b0123456789) -> *)) - = forall arg. Data.Singletons.KindOf (Apply LiftMaybeSym0 arg) ~ Data.Singletons.KindOf (LiftMaybeSym1 arg) => - LiftMaybeSym0KindInference - type instance Apply LiftMaybeSym0 l = LiftMaybeSym1 l - type ZeroSym0 = Zero - type SuccSym1 (t :: NatT) = Succ t - instance SuppressUnusedWarnings SuccSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.()) - data SuccSym0 (l :: TyFun NatT NatT) - = forall arg. Data.Singletons.KindOf (Apply SuccSym0 arg) ~ Data.Singletons.KindOf (SuccSym1 arg) => - SuccSym0KindInference - type instance Apply SuccSym0 l = SuccSym1 l - type (:+$$$) (t :: Nat) (t :: Nat) = (:+) t t - instance SuppressUnusedWarnings (:+$$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.()) - data (:+$$) (l :: Nat) l - = forall arg. Data.Singletons.KindOf (Apply ((:+$$) l) arg) ~ Data.Singletons.KindOf ((:+$$$) l arg) => - :+$$### - type instance Apply ((:+$$) l) l = (:+$$$) l l - instance SuppressUnusedWarnings (:+$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:+$###) GHC.Tuple.()) - data (:+$) l - = forall arg. Data.Singletons.KindOf (Apply (:+$) arg) ~ Data.Singletons.KindOf ((:+$$) arg) => - :+$### - type instance Apply (:+$) l = (:+$$) l diff --git a/tests/compile-and-dump/Promote/GenDefunSymbols.hs b/tests/compile-and-dump/Promote/GenDefunSymbols.hs --- a/tests/compile-and-dump/Promote/GenDefunSymbols.hs +++ b/tests/compile-and-dump/Promote/GenDefunSymbols.hs @@ -6,10 +6,7 @@ import Data.Singletons.Promote import Data.Singletons.SuppressUnusedWarnings import GHC.TypeLits hiding (type (*)) - -#if __GLASGOW_HASKELL__ >= 711 import Data.Kind -#endif type family LiftMaybe (f :: TyFun a b -> *) (x :: Maybe a) :: Maybe b where LiftMaybe f Nothing = Nothing diff --git a/tests/compile-and-dump/Promote/Newtypes.ghc710.template b/tests/compile-and-dump/Promote/Newtypes.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Promote/Newtypes.ghc710.template +++ /dev/null @@ -1,42 +0,0 @@ -Promote/Newtypes.hs:(0,0)-(0,0): Splicing declarations - promote - [d| newtype Foo - = Foo Nat - deriving (Eq) - newtype Bar = Bar {unBar :: Nat} |] - ======> - newtype Foo - = Foo Nat - deriving (Eq) - newtype Bar = Bar {unBar :: Nat} - type UnBarSym1 (t :: Bar) = UnBar t - instance SuppressUnusedWarnings UnBarSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) UnBarSym0KindInference GHC.Tuple.()) - data UnBarSym0 (l :: TyFun Bar Nat) - = forall arg. KindOf (Apply UnBarSym0 arg) ~ KindOf (UnBarSym1 arg) => - UnBarSym0KindInference - type instance Apply UnBarSym0 l = UnBarSym1 l - type family UnBar (a :: Bar) :: Nat where - UnBar (Bar field) = field - type family Equals_0123456789 (a :: Foo) (b :: Foo) :: Bool where - Equals_0123456789 (Foo a) (Foo b) = (:==) a b - Equals_0123456789 (a :: Foo) (b :: Foo) = FalseSym0 - instance PEq (KProxy :: KProxy Foo) where - type (:==) (a :: Foo) (b :: Foo) = Equals_0123456789 a b - type FooSym1 (t :: Nat) = Foo t - instance SuppressUnusedWarnings FooSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.()) - data FooSym0 (l :: TyFun Nat Foo) - = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) => - FooSym0KindInference - type instance Apply FooSym0 l = FooSym1 l - type BarSym1 (t :: Nat) = Bar t - instance SuppressUnusedWarnings BarSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.()) - data BarSym0 (l :: TyFun Nat Bar) - = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) => - BarSym0KindInference - type instance Apply BarSym0 l = BarSym1 l diff --git a/tests/compile-and-dump/Promote/Newtypes.ghc80.template b/tests/compile-and-dump/Promote/Newtypes.ghc80.template --- a/tests/compile-and-dump/Promote/Newtypes.ghc80.template +++ b/tests/compile-and-dump/Promote/Newtypes.ghc80.template @@ -22,7 +22,7 @@ type family Equals_0123456789 (a :: Foo) (b :: Foo) :: Bool where Equals_0123456789 (Foo a) (Foo b) = (:==) a b Equals_0123456789 (a :: Foo) (b :: Foo) = FalseSym0 - instance PEq (KProxy :: KProxy Foo) where + instance PEq (Proxy :: Proxy Foo) where type (:==) (a :: Foo) (b :: Foo) = Equals_0123456789 a b type FooSym1 (t :: Nat) = Foo t instance SuppressUnusedWarnings FooSym0 where diff --git a/tests/compile-and-dump/Promote/Pragmas.ghc710.template b/tests/compile-and-dump/Promote/Pragmas.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Promote/Pragmas.ghc710.template +++ /dev/null @@ -1,12 +0,0 @@ -Promote/Pragmas.hs:(0,0)-(0,0): Splicing declarations - promote - [d| {-# INLINE foo #-} - foo :: Bool - foo = True |] - ======> - {-# INLINE foo #-} - foo :: Bool - foo = True - type FooSym0 = Foo - type family Foo :: Bool where - Foo = TrueSym0 diff --git a/tests/compile-and-dump/Promote/Prelude.ghc710.template b/tests/compile-and-dump/Promote/Prelude.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Promote/Prelude.ghc710.template +++ /dev/null @@ -1,17 +0,0 @@ -Promote/Prelude.hs:(0,0)-(0,0): Splicing declarations - promoteOnly - [d| odd :: Nat -> Bool - odd 0 = False - odd n = not . odd $ n - 1 |] - ======> - type OddSym1 (t :: Nat) = Odd t - instance SuppressUnusedWarnings OddSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) OddSym0KindInference GHC.Tuple.()) - data OddSym0 (l :: TyFun Nat Bool) - = forall arg. Data.Singletons.KindOf (Apply OddSym0 arg) ~ Data.Singletons.KindOf (OddSym1 arg) => - OddSym0KindInference - type instance Apply OddSym0 l = OddSym1 l - type family Odd (a :: Nat) :: 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/Singletons/AsPattern.ghc710.template b/tests/compile-and-dump/Singletons/AsPattern.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/AsPattern.ghc710.template +++ /dev/null @@ -1,383 +0,0 @@ -Singletons/AsPattern.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| maybePlus :: Maybe Nat -> Maybe Nat - maybePlus (Just n) = Just (plus (Succ Zero) n) - maybePlus p@Nothing = p - bar :: Maybe Nat -> Maybe Nat - bar x@(Just _) = x - bar Nothing = Nothing - baz_ :: Maybe Baz -> Maybe Baz - baz_ p@Nothing = p - baz_ p@(Just (Baz _ _ _)) = p - tup :: (Nat, Nat) -> (Nat, Nat) - tup p@(_, _) = p - foo :: [Nat] -> [Nat] - foo p@[] = p - foo p@[_] = p - foo p@(_ : _ : _) = p - - data Baz = Baz Nat Nat Nat |] - ======> - maybePlus :: Maybe Nat -> Maybe Nat - maybePlus (Just n) = Just (plus (Succ Zero) n) - maybePlus p@Nothing = p - bar :: Maybe Nat -> Maybe Nat - bar x@(Just _) = x - bar Nothing = Nothing - data Baz = Baz Nat Nat Nat - baz_ :: Maybe Baz -> Maybe Baz - baz_ p@Nothing = p - baz_ p@(Just (Baz _ _ _)) = p - tup :: (Nat, Nat) -> (Nat, Nat) - tup p@(_, _) = p - foo :: [Nat] -> [Nat] - foo p@GHC.Types.[] = p - foo p@[_] = p - foo p@(_ GHC.Types.: (_ GHC.Types.: _)) = p - type BazSym3 (t :: Nat) (t :: Nat) (t :: Nat) = Baz t t t - instance SuppressUnusedWarnings BazSym2 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BazSym2KindInference GHC.Tuple.()) - data BazSym2 (l :: Nat) (l :: Nat) (l :: TyFun Nat Baz) - = forall arg. KindOf (Apply (BazSym2 l l) arg) ~ KindOf (BazSym3 l l arg) => - BazSym2KindInference - type instance Apply (BazSym2 l l) l = BazSym3 l l l - instance SuppressUnusedWarnings BazSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BazSym1KindInference GHC.Tuple.()) - data BazSym1 (l :: Nat) (l :: TyFun Nat (TyFun Nat Baz -> *)) - = forall arg. KindOf (Apply (BazSym1 l) arg) ~ KindOf (BazSym2 l arg) => - BazSym1KindInference - type instance Apply (BazSym1 l) l = BazSym2 l l - instance SuppressUnusedWarnings BazSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BazSym0KindInference GHC.Tuple.()) - data BazSym0 (l :: TyFun Nat (TyFun Nat (TyFun Nat Baz -> *) -> *)) - = forall arg. KindOf (Apply BazSym0 arg) ~ KindOf (BazSym1 arg) => - BazSym0KindInference - type instance Apply BazSym0 l = BazSym1 l - type Let0123456789PSym0 = Let0123456789P - type family Let0123456789P where - Let0123456789P = '[] - type Let0123456789PSym1 t = Let0123456789P t - instance SuppressUnusedWarnings Let0123456789PSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.()) - data Let0123456789PSym0 l - = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) => - Let0123456789PSym0KindInference - type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l - type family Let0123456789P wild_0123456789 where - Let0123456789P wild_0123456789 = Apply (Apply (:$) wild_0123456789) '[] - type Let0123456789PSym3 t t t = Let0123456789P t t t - instance SuppressUnusedWarnings Let0123456789PSym2 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789PSym2KindInference GHC.Tuple.()) - data Let0123456789PSym2 l l l - = forall arg. KindOf (Apply (Let0123456789PSym2 l l) arg) ~ KindOf (Let0123456789PSym3 l l arg) => - Let0123456789PSym2KindInference - type instance Apply (Let0123456789PSym2 l l) l = Let0123456789PSym3 l l l - instance SuppressUnusedWarnings Let0123456789PSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789PSym1KindInference GHC.Tuple.()) - data Let0123456789PSym1 l l - = forall arg. KindOf (Apply (Let0123456789PSym1 l) arg) ~ KindOf (Let0123456789PSym2 l arg) => - Let0123456789PSym1KindInference - type instance Apply (Let0123456789PSym1 l) l = Let0123456789PSym2 l l - instance SuppressUnusedWarnings Let0123456789PSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.()) - data Let0123456789PSym0 l - = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) => - Let0123456789PSym0KindInference - type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l - type family Let0123456789P wild_0123456789 - wild_0123456789 - wild_0123456789 where - Let0123456789P wild_0123456789 wild_0123456789 wild_0123456789 = Apply (Apply (:$) wild_0123456789) (Apply (Apply (:$) wild_0123456789) wild_0123456789) - type Let0123456789PSym2 t t = Let0123456789P t t - instance SuppressUnusedWarnings Let0123456789PSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789PSym1KindInference GHC.Tuple.()) - data Let0123456789PSym1 l l - = forall arg. KindOf (Apply (Let0123456789PSym1 l) arg) ~ KindOf (Let0123456789PSym2 l arg) => - Let0123456789PSym1KindInference - type instance Apply (Let0123456789PSym1 l) l = Let0123456789PSym2 l l - instance SuppressUnusedWarnings Let0123456789PSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.()) - data Let0123456789PSym0 l - = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) => - Let0123456789PSym0KindInference - type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l - type family Let0123456789P wild_0123456789 wild_0123456789 where - Let0123456789P wild_0123456789 wild_0123456789 = Apply (Apply Tuple2Sym0 wild_0123456789) wild_0123456789 - type Let0123456789PSym0 = Let0123456789P - type family Let0123456789P where - Let0123456789P = NothingSym0 - type Let0123456789PSym3 t t t = Let0123456789P t t t - instance SuppressUnusedWarnings Let0123456789PSym2 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789PSym2KindInference GHC.Tuple.()) - data Let0123456789PSym2 l l l - = forall arg. KindOf (Apply (Let0123456789PSym2 l l) arg) ~ KindOf (Let0123456789PSym3 l l arg) => - Let0123456789PSym2KindInference - type instance Apply (Let0123456789PSym2 l l) l = Let0123456789PSym3 l l l - instance SuppressUnusedWarnings Let0123456789PSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789PSym1KindInference GHC.Tuple.()) - data Let0123456789PSym1 l l - = forall arg. KindOf (Apply (Let0123456789PSym1 l) arg) ~ KindOf (Let0123456789PSym2 l arg) => - Let0123456789PSym1KindInference - type instance Apply (Let0123456789PSym1 l) l = Let0123456789PSym2 l l - instance SuppressUnusedWarnings Let0123456789PSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.()) - data Let0123456789PSym0 l - = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) => - Let0123456789PSym0KindInference - type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l - type family Let0123456789P wild_0123456789 - wild_0123456789 - wild_0123456789 where - Let0123456789P wild_0123456789 wild_0123456789 wild_0123456789 = Apply JustSym0 (Apply (Apply (Apply BazSym0 wild_0123456789) wild_0123456789) wild_0123456789) - type Let0123456789XSym1 t = Let0123456789X t - instance SuppressUnusedWarnings Let0123456789XSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789XSym0KindInference GHC.Tuple.()) - data Let0123456789XSym0 l - = forall arg. KindOf (Apply Let0123456789XSym0 arg) ~ KindOf (Let0123456789XSym1 arg) => - Let0123456789XSym0KindInference - type instance Apply Let0123456789XSym0 l = Let0123456789XSym1 l - type family Let0123456789X wild_0123456789 where - Let0123456789X wild_0123456789 = Apply JustSym0 wild_0123456789 - type Let0123456789PSym0 = Let0123456789P - type family Let0123456789P where - Let0123456789P = NothingSym0 - type FooSym1 (t :: [Nat]) = Foo t - instance SuppressUnusedWarnings FooSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.()) - data FooSym0 (l :: TyFun [Nat] [Nat]) - = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) => - FooSym0KindInference - type instance Apply FooSym0 l = FooSym1 l - type TupSym1 (t :: (Nat, Nat)) = Tup t - instance SuppressUnusedWarnings TupSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) TupSym0KindInference GHC.Tuple.()) - data TupSym0 (l :: TyFun (Nat, Nat) (Nat, Nat)) - = forall arg. KindOf (Apply TupSym0 arg) ~ KindOf (TupSym1 arg) => - TupSym0KindInference - type instance Apply TupSym0 l = TupSym1 l - type Baz_Sym1 (t :: Maybe Baz) = Baz_ t - instance SuppressUnusedWarnings Baz_Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Baz_Sym0KindInference GHC.Tuple.()) - data Baz_Sym0 (l :: TyFun (Maybe Baz) (Maybe Baz)) - = forall arg. KindOf (Apply Baz_Sym0 arg) ~ KindOf (Baz_Sym1 arg) => - Baz_Sym0KindInference - type instance Apply Baz_Sym0 l = Baz_Sym1 l - type BarSym1 (t :: Maybe Nat) = Bar t - instance SuppressUnusedWarnings BarSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.()) - data BarSym0 (l :: TyFun (Maybe Nat) (Maybe Nat)) - = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) => - BarSym0KindInference - type instance Apply BarSym0 l = BarSym1 l - type MaybePlusSym1 (t :: Maybe Nat) = MaybePlus t - instance SuppressUnusedWarnings MaybePlusSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) MaybePlusSym0KindInference GHC.Tuple.()) - data MaybePlusSym0 (l :: TyFun (Maybe Nat) (Maybe Nat)) - = forall arg. KindOf (Apply MaybePlusSym0 arg) ~ KindOf (MaybePlusSym1 arg) => - MaybePlusSym0KindInference - type instance Apply MaybePlusSym0 l = MaybePlusSym1 l - type family Foo (a :: [Nat]) :: [Nat] where - Foo '[] = Let0123456789PSym0 - Foo '[wild_0123456789] = Let0123456789PSym1 wild_0123456789 - Foo ((:) wild_0123456789 ((:) wild_0123456789 wild_0123456789)) = Let0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789 - type family Tup (a :: (Nat, Nat)) :: (Nat, Nat) where - Tup '(wild_0123456789, - wild_0123456789) = Let0123456789PSym2 wild_0123456789 wild_0123456789 - type family Baz_ (a :: Maybe Baz) :: Maybe Baz where - Baz_ Nothing = Let0123456789PSym0 - Baz_ (Just (Baz wild_0123456789 wild_0123456789 wild_0123456789)) = Let0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789 - type family Bar (a :: Maybe Nat) :: Maybe Nat where - Bar (Just wild_0123456789) = Let0123456789XSym1 wild_0123456789 - Bar Nothing = NothingSym0 - type family MaybePlus (a :: Maybe Nat) :: Maybe Nat where - MaybePlus (Just n) = Apply JustSym0 (Apply (Apply PlusSym0 (Apply SuccSym0 ZeroSym0)) n) - MaybePlus Nothing = Let0123456789PSym0 - sFoo :: - forall (t :: [Nat]). Sing t -> Sing (Apply FooSym0 t :: [Nat]) - sTup :: - 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) - sBar :: - 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) - sFoo SNil - = let - lambda :: t ~ '[] => Sing (Apply FooSym0 t :: [Nat]) - lambda - = let - sP :: Sing Let0123456789PSym0 - sP = SNil - in sP - in lambda - sFoo (SCons sWild_0123456789 SNil) - = let - lambda :: - forall wild_0123456789. t ~ Apply (Apply (:$) wild_0123456789) '[] => - Sing wild_0123456789 -> Sing (Apply FooSym0 t :: [Nat]) - lambda wild_0123456789 - = let - sP :: Sing (Let0123456789PSym1 wild_0123456789) - sP - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) wild_0123456789) - SNil - in sP - in lambda sWild_0123456789 - sFoo - (SCons sWild_0123456789 (SCons sWild_0123456789 sWild_0123456789)) - = let - lambda :: - forall wild_0123456789 - wild_0123456789 - wild_0123456789. t ~ Apply (Apply (:$) wild_0123456789) (Apply (Apply (:$) wild_0123456789) wild_0123456789) => - Sing wild_0123456789 - -> Sing wild_0123456789 - -> Sing wild_0123456789 -> Sing (Apply FooSym0 t :: [Nat]) - lambda wild_0123456789 wild_0123456789 wild_0123456789 - = let - sP :: - Sing (Let0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789) - sP - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) wild_0123456789) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) wild_0123456789) - wild_0123456789) - in sP - in lambda sWild_0123456789 sWild_0123456789 sWild_0123456789 - sTup (STuple2 sWild_0123456789 sWild_0123456789) - = let - lambda :: - forall wild_0123456789 - wild_0123456789. t ~ Apply (Apply Tuple2Sym0 wild_0123456789) wild_0123456789 => - Sing wild_0123456789 - -> Sing wild_0123456789 -> Sing (Apply TupSym0 t :: (Nat, Nat)) - lambda wild_0123456789 wild_0123456789 - = let - sP :: Sing (Let0123456789PSym2 wild_0123456789 wild_0123456789) - sP - = applySing - (applySing - (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) wild_0123456789) - wild_0123456789 - in sP - in lambda sWild_0123456789 sWild_0123456789 - sBaz_ SNothing - = let - lambda :: t ~ NothingSym0 => Sing (Apply Baz_Sym0 t :: Maybe Baz) - lambda - = let - sP :: Sing Let0123456789PSym0 - sP = SNothing - in sP - in lambda - sBaz_ - (SJust (SBaz sWild_0123456789 sWild_0123456789 sWild_0123456789)) - = let - lambda :: - forall wild_0123456789 - wild_0123456789 - wild_0123456789. t ~ Apply JustSym0 (Apply (Apply (Apply BazSym0 wild_0123456789) wild_0123456789) wild_0123456789) => - Sing wild_0123456789 - -> Sing wild_0123456789 - -> Sing wild_0123456789 -> Sing (Apply Baz_Sym0 t :: Maybe Baz) - lambda wild_0123456789 wild_0123456789 wild_0123456789 - = let - sP :: - Sing (Let0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789) - sP - = applySing - (singFun1 (Proxy :: Proxy JustSym0) SJust) - (applySing - (applySing - (applySing - (singFun3 (Proxy :: Proxy BazSym0) SBaz) wild_0123456789) - wild_0123456789) - wild_0123456789) - in sP - in lambda sWild_0123456789 sWild_0123456789 sWild_0123456789 - sBar (SJust sWild_0123456789) - = let - lambda :: - forall wild_0123456789. t ~ Apply JustSym0 wild_0123456789 => - Sing wild_0123456789 -> Sing (Apply BarSym0 t :: Maybe Nat) - lambda wild_0123456789 - = let - sX :: Sing (Let0123456789XSym1 wild_0123456789) - sX - = applySing - (singFun1 (Proxy :: Proxy JustSym0) SJust) wild_0123456789 - in sX - in lambda sWild_0123456789 - sBar SNothing - = let - lambda :: t ~ NothingSym0 => Sing (Apply BarSym0 t :: Maybe Nat) - lambda = SNothing - in lambda - sMaybePlus (SJust sN) - = let - lambda :: - forall n. t ~ Apply JustSym0 n => - Sing n -> Sing (Apply MaybePlusSym0 t :: Maybe Nat) - lambda n - = applySing - (singFun1 (Proxy :: Proxy JustSym0) SJust) - (applySing - (applySing - (singFun2 (Proxy :: Proxy PlusSym0) sPlus) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)) - n) - in lambda sN - sMaybePlus SNothing - = let - lambda :: - t ~ NothingSym0 => Sing (Apply MaybePlusSym0 t :: Maybe Nat) - lambda - = let - sP :: Sing Let0123456789PSym0 - sP = SNothing - in sP - in lambda - data instance Sing (z :: Baz) - = forall (n :: Nat) (n :: Nat) (n :: Nat). z ~ Baz n n n => - SBaz (Sing (n :: Nat)) (Sing (n :: Nat)) (Sing (n :: Nat)) - type SBaz = (Sing :: Baz -> *) - instance SingKind (KProxy :: KProxy Baz) where - type DemoteRep (KProxy :: KProxy Baz) = Baz - fromSing (SBaz b b b) = Baz (fromSing b) (fromSing b) (fromSing b) - toSing (Baz b b b) - = case - GHC.Tuple.(,,) - (toSing b :: SomeSing (KProxy :: KProxy Nat)) - (toSing b :: SomeSing (KProxy :: KProxy Nat)) - (toSing b :: SomeSing (KProxy :: KProxy Nat)) - of { - GHC.Tuple.(,,) (SomeSing c) (SomeSing c) (SomeSing 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 diff --git a/tests/compile-and-dump/Singletons/AsPattern.ghc80.template b/tests/compile-and-dump/Singletons/AsPattern.ghc80.template --- a/tests/compile-and-dump/Singletons/AsPattern.ghc80.template +++ b/tests/compile-and-dump/Singletons/AsPattern.ghc80.template @@ -370,15 +370,15 @@ = forall (n :: Nat) (n :: Nat) (n :: Nat). z ~ Baz n n n => SBaz (Sing (n :: Nat)) (Sing (n :: Nat)) (Sing (n :: Nat)) type SBaz = (Sing :: Baz -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy Baz) where - type DemoteRep (KProxy :: KProxy Baz) = Baz + instance SingKind Baz where + type DemoteRep Baz = Baz fromSing (SBaz b b b) = Baz (fromSing b) (fromSing b) (fromSing b) toSing (Baz b b b) = case GHC.Tuple.(,,) - (toSing b :: SomeSing (KProxy :: KProxy Nat)) - (toSing b :: SomeSing (KProxy :: KProxy Nat)) - (toSing b :: SomeSing (KProxy :: KProxy Nat)) + (toSing b :: SomeSing Nat) + (toSing b :: SomeSing Nat) + (toSing b :: SomeSing Nat) of { GHC.Tuple.(,,) (SomeSing c) (SomeSing c) (SomeSing c) -> SomeSing (SBaz c c c) } diff --git a/tests/compile-and-dump/Singletons/BadBoundedDeriving.ghc710.template b/tests/compile-and-dump/Singletons/BadBoundedDeriving.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/BadBoundedDeriving.ghc710.template +++ /dev/null @@ -1,3 +0,0 @@ - -Singletons/BadBoundedDeriving.hs:0:0: - Can't derive Bounded instance for Foo_0 a_1. diff --git a/tests/compile-and-dump/Singletons/BadEnumDeriving.ghc710.template b/tests/compile-and-dump/Singletons/BadEnumDeriving.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/BadEnumDeriving.ghc710.template +++ /dev/null @@ -1,3 +0,0 @@ - -Singletons/BadEnumDeriving.hs:0:0: - Can't derive Enum instance for Foo_0 a_1. diff --git a/tests/compile-and-dump/Singletons/BoundedDeriving.ghc710.template b/tests/compile-and-dump/Singletons/BoundedDeriving.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/BoundedDeriving.ghc710.template +++ /dev/null @@ -1,265 +0,0 @@ -Singletons/BoundedDeriving.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| data Foo1 - = Foo1 - deriving (Bounded) - data Foo2 - = A | B | C | D | E - deriving (Bounded) - data Foo3 a - = Foo3 a - deriving (Bounded) - data Foo4 (a :: *) (b :: *) - = Foo41 | Foo42 - deriving (Bounded) - data Pair - = Pair Bool Bool - deriving (Bounded) |] - ======> - data Foo1 - = Foo1 - deriving (Bounded) - data Foo2 - = A | B | C | D | E - deriving (Bounded) - data Foo3 a - = Foo3 a - deriving (Bounded) - data Foo4 (a :: *) (b :: *) - = Foo41 | Foo42 - deriving (Bounded) - data Pair - = Pair Bool Bool - deriving (Bounded) - type Foo1Sym0 = Foo1 - type ASym0 = A - type BSym0 = B - type CSym0 = C - type DSym0 = D - type ESym0 = E - type Foo3Sym1 (t :: a0123456789) = Foo3 t - instance SuppressUnusedWarnings Foo3Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.()) - data Foo3Sym0 (l :: TyFun a0123456789 (Foo3 a0123456789)) - = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) => - Foo3Sym0KindInference - type instance Apply Foo3Sym0 l = Foo3Sym1 l - type Foo41Sym0 = Foo41 - type Foo42Sym0 = Foo42 - type PairSym2 (t :: Bool) (t :: Bool) = Pair t t - instance SuppressUnusedWarnings PairSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) PairSym1KindInference GHC.Tuple.()) - data PairSym1 (l :: Bool) (l :: TyFun Bool Pair) - = forall arg. KindOf (Apply (PairSym1 l) arg) ~ KindOf (PairSym2 l arg) => - PairSym1KindInference - type instance Apply (PairSym1 l) l = PairSym2 l l - instance SuppressUnusedWarnings PairSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) PairSym0KindInference GHC.Tuple.()) - data PairSym0 (l :: TyFun Bool (TyFun Bool Pair -> *)) - = forall arg. KindOf (Apply PairSym0 arg) ~ KindOf (PairSym1 arg) => - PairSym0KindInference - type instance Apply PairSym0 l = PairSym1 l - type family MinBound_0123456789 :: Foo1 where - MinBound_0123456789 = Foo1Sym0 - type MinBound_0123456789Sym0 = MinBound_0123456789 - type family MaxBound_0123456789 :: Foo1 where - MaxBound_0123456789 = Foo1Sym0 - type MaxBound_0123456789Sym0 = MaxBound_0123456789 - instance PBounded (KProxy :: KProxy Foo1) where - type MinBound = MinBound_0123456789Sym0 - type MaxBound = MaxBound_0123456789Sym0 - type family MinBound_0123456789 :: Foo2 where - MinBound_0123456789 = ASym0 - type MinBound_0123456789Sym0 = MinBound_0123456789 - type family MaxBound_0123456789 :: Foo2 where - MaxBound_0123456789 = ESym0 - type MaxBound_0123456789Sym0 = MaxBound_0123456789 - instance PBounded (KProxy :: KProxy Foo2) where - type MinBound = MinBound_0123456789Sym0 - type MaxBound = MaxBound_0123456789Sym0 - type family MinBound_0123456789 :: Foo3 a where - MinBound_0123456789 = Apply Foo3Sym0 MinBoundSym0 - type MinBound_0123456789Sym0 = MinBound_0123456789 - type family MaxBound_0123456789 :: Foo3 a where - MaxBound_0123456789 = Apply Foo3Sym0 MaxBoundSym0 - type MaxBound_0123456789Sym0 = MaxBound_0123456789 - instance PBounded (KProxy :: KProxy (Foo3 a)) where - type MinBound = MinBound_0123456789Sym0 - type MaxBound = MaxBound_0123456789Sym0 - type family MinBound_0123456789 :: Foo4 a b where - MinBound_0123456789 = Foo41Sym0 - type MinBound_0123456789Sym0 = MinBound_0123456789 - type family MaxBound_0123456789 :: Foo4 a b where - MaxBound_0123456789 = Foo42Sym0 - type MaxBound_0123456789Sym0 = MaxBound_0123456789 - instance PBounded (KProxy :: KProxy (Foo4 a b)) where - type MinBound = MinBound_0123456789Sym0 - type MaxBound = MaxBound_0123456789Sym0 - type family MinBound_0123456789 :: Pair where - MinBound_0123456789 = Apply (Apply PairSym0 MinBoundSym0) MinBoundSym0 - type MinBound_0123456789Sym0 = MinBound_0123456789 - type family MaxBound_0123456789 :: Pair where - MaxBound_0123456789 = Apply (Apply PairSym0 MaxBoundSym0) MaxBoundSym0 - type MaxBound_0123456789Sym0 = MaxBound_0123456789 - instance PBounded (KProxy :: KProxy Pair) where - type MinBound = MinBound_0123456789Sym0 - type MaxBound = MaxBound_0123456789Sym0 - data instance Sing (z :: Foo1) = z ~ Foo1 => SFoo1 - type SFoo1 = (Sing :: Foo1 -> *) - instance SingKind (KProxy :: KProxy Foo1) where - type DemoteRep (KProxy :: KProxy Foo1) = Foo1 - fromSing SFoo1 = Foo1 - toSing Foo1 = SomeSing SFoo1 - data instance Sing (z :: Foo2) - = z ~ A => SA | - z ~ B => SB | - z ~ C => SC | - z ~ D => SD | - z ~ E => SE - type SFoo2 = (Sing :: Foo2 -> *) - instance SingKind (KProxy :: KProxy Foo2) where - type DemoteRep (KProxy :: KProxy Foo2) = Foo2 - fromSing SA = A - fromSing SB = B - fromSing SC = C - fromSing SD = D - fromSing SE = E - toSing A = SomeSing SA - toSing B = SomeSing SB - toSing C = SomeSing SC - toSing D = SomeSing SD - toSing E = SomeSing SE - data instance Sing (z :: Foo3 a) - = forall (n :: a). z ~ Foo3 n => SFoo3 (Sing (n :: a)) - type SFoo3 = (Sing :: Foo3 a -> *) - instance SingKind (KProxy :: KProxy a) => - SingKind (KProxy :: KProxy (Foo3 a)) where - type DemoteRep (KProxy :: KProxy (Foo3 a)) = Foo3 (DemoteRep (KProxy :: KProxy a)) - fromSing (SFoo3 b) = Foo3 (fromSing b) - toSing (Foo3 b) - = case toSing b :: SomeSing (KProxy :: KProxy a) of { - SomeSing c -> SomeSing (SFoo3 c) } - data instance Sing (z :: Foo4 a b) - = z ~ Foo41 => SFoo41 | z ~ Foo42 => SFoo42 - type SFoo4 = (Sing :: Foo4 a b -> *) - instance (SingKind (KProxy :: KProxy a), - SingKind (KProxy :: KProxy b)) => - SingKind (KProxy :: KProxy (Foo4 a b)) where - type DemoteRep (KProxy :: KProxy (Foo4 a b)) = Foo4 (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b)) - fromSing SFoo41 = Foo41 - fromSing SFoo42 = Foo42 - toSing Foo41 = SomeSing SFoo41 - toSing Foo42 = SomeSing SFoo42 - data instance Sing (z :: Pair) - = forall (n :: Bool) (n :: Bool). z ~ Pair n n => - SPair (Sing (n :: Bool)) (Sing (n :: Bool)) - type SPair = (Sing :: Pair -> *) - instance SingKind (KProxy :: KProxy Pair) where - type DemoteRep (KProxy :: KProxy Pair) = Pair - fromSing (SPair b b) = Pair (fromSing b) (fromSing b) - toSing (Pair b b) - = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy Bool)) - (toSing b :: SomeSing (KProxy :: KProxy Bool)) - of { - GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SPair c c) } - instance SBounded (KProxy :: KProxy Foo1) where - sMinBound :: Sing (MinBoundSym0 :: Foo1) - sMaxBound :: Sing (MaxBoundSym0 :: Foo1) - sMinBound - = let - lambda :: Sing (MinBoundSym0 :: Foo1) - lambda = SFoo1 - in lambda - sMaxBound - = let - lambda :: Sing (MaxBoundSym0 :: Foo1) - lambda = SFoo1 - in lambda - instance SBounded (KProxy :: KProxy Foo2) where - sMinBound :: Sing (MinBoundSym0 :: Foo2) - sMaxBound :: Sing (MaxBoundSym0 :: Foo2) - sMinBound - = let - lambda :: Sing (MinBoundSym0 :: Foo2) - lambda = SA - in lambda - sMaxBound - = let - lambda :: Sing (MaxBoundSym0 :: Foo2) - lambda = SE - in lambda - instance SBounded (KProxy :: KProxy a) => - SBounded (KProxy :: KProxy (Foo3 a)) where - sMinBound :: Sing (MinBoundSym0 :: Foo3 a) - sMaxBound :: Sing (MaxBoundSym0 :: Foo3 a) - sMinBound - = let - lambda :: Sing (MinBoundSym0 :: Foo3 a) - lambda - = applySing (singFun1 (Proxy :: Proxy Foo3Sym0) SFoo3) sMinBound - in lambda - sMaxBound - = let - lambda :: Sing (MaxBoundSym0 :: Foo3 a) - lambda - = applySing (singFun1 (Proxy :: Proxy Foo3Sym0) SFoo3) sMaxBound - in lambda - instance SBounded (KProxy :: KProxy (Foo4 a b)) where - sMinBound :: Sing (MinBoundSym0 :: Foo4 a b) - sMaxBound :: Sing (MaxBoundSym0 :: Foo4 a b) - sMinBound - = let - lambda :: Sing (MinBoundSym0 :: Foo4 a b) - lambda = SFoo41 - in lambda - sMaxBound - = let - lambda :: Sing (MaxBoundSym0 :: Foo4 a b) - lambda = SFoo42 - in lambda - instance SBounded (KProxy :: KProxy Bool) => - SBounded (KProxy :: KProxy Pair) where - sMinBound :: Sing (MinBoundSym0 :: Pair) - sMaxBound :: Sing (MaxBoundSym0 :: Pair) - sMinBound - = let - lambda :: Sing (MinBoundSym0 :: Pair) - lambda - = applySing - (applySing (singFun2 (Proxy :: Proxy PairSym0) SPair) sMinBound) - sMinBound - in lambda - sMaxBound - = let - lambda :: Sing (MaxBoundSym0 :: Pair) - lambda - = applySing - (applySing (singFun2 (Proxy :: Proxy PairSym0) SPair) sMaxBound) - sMaxBound - in lambda - instance SingI Foo1 where - sing = SFoo1 - instance SingI A where - sing = SA - instance SingI B where - sing = SB - instance SingI C where - sing = SC - instance SingI D where - sing = SD - instance SingI E where - sing = SE - instance SingI n => SingI (Foo3 (n :: a)) where - sing = SFoo3 sing - instance SingI Foo41 where - sing = SFoo41 - instance SingI Foo42 where - sing = SFoo42 - instance (SingI n, SingI n) => - SingI (Pair (n :: Bool) (n :: Bool)) where - sing = SPair sing sing diff --git a/tests/compile-and-dump/Singletons/BoundedDeriving.ghc80.template b/tests/compile-and-dump/Singletons/BoundedDeriving.ghc80.template --- a/tests/compile-and-dump/Singletons/BoundedDeriving.ghc80.template +++ b/tests/compile-and-dump/Singletons/BoundedDeriving.ghc80.template @@ -68,7 +68,7 @@ type family MaxBound_0123456789 :: Foo1 where MaxBound_0123456789 = Foo1Sym0 type MaxBound_0123456789Sym0 = MaxBound_0123456789 - instance PBounded (KProxy :: KProxy Foo1) where + instance PBounded (Proxy :: Proxy Foo1) where type MinBound = MinBound_0123456789Sym0 type MaxBound = MaxBound_0123456789Sym0 type family MinBound_0123456789 :: Foo2 where @@ -77,7 +77,7 @@ type family MaxBound_0123456789 :: Foo2 where MaxBound_0123456789 = ESym0 type MaxBound_0123456789Sym0 = MaxBound_0123456789 - instance PBounded (KProxy :: KProxy Foo2) where + instance PBounded (Proxy :: Proxy Foo2) where type MinBound = MinBound_0123456789Sym0 type MaxBound = MaxBound_0123456789Sym0 type family MinBound_0123456789 :: Foo3 a where @@ -86,7 +86,7 @@ type family MaxBound_0123456789 :: Foo3 a where MaxBound_0123456789 = Apply Foo3Sym0 MaxBoundSym0 type MaxBound_0123456789Sym0 = MaxBound_0123456789 - instance PBounded (KProxy :: KProxy (Foo3 a)) where + instance PBounded (Proxy :: Proxy (Foo3 a)) where type MinBound = MinBound_0123456789Sym0 type MaxBound = MaxBound_0123456789Sym0 type family MinBound_0123456789 :: Foo4 a b where @@ -95,7 +95,7 @@ type family MaxBound_0123456789 :: Foo4 a b where MaxBound_0123456789 = Foo42Sym0 type MaxBound_0123456789Sym0 = MaxBound_0123456789 - instance PBounded (KProxy :: KProxy (Foo4 a b)) where + instance PBounded (Proxy :: Proxy (Foo4 a b)) where type MinBound = MinBound_0123456789Sym0 type MaxBound = MaxBound_0123456789Sym0 type family MinBound_0123456789 :: Pair where @@ -104,13 +104,13 @@ type family MaxBound_0123456789 :: Pair where MaxBound_0123456789 = Apply (Apply PairSym0 MaxBoundSym0) MaxBoundSym0 type MaxBound_0123456789Sym0 = MaxBound_0123456789 - instance PBounded (KProxy :: KProxy Pair) where + instance PBounded (Proxy :: Proxy Pair) where type MinBound = MinBound_0123456789Sym0 type MaxBound = MaxBound_0123456789Sym0 data instance Sing (z :: Foo1) = z ~ Foo1 => SFoo1 type SFoo1 = (Sing :: Foo1 -> Type) - instance SingKind (KProxy :: KProxy Foo1) where - type DemoteRep (KProxy :: KProxy Foo1) = Foo1 + instance SingKind Foo1 where + type DemoteRep Foo1 = Foo1 fromSing SFoo1 = Foo1 toSing Foo1 = SomeSing SFoo1 data instance Sing (z :: Foo2) @@ -120,8 +120,8 @@ z ~ D => SD | z ~ E => SE type SFoo2 = (Sing :: Foo2 -> Type) - instance SingKind (KProxy :: KProxy Foo2) where - type DemoteRep (KProxy :: KProxy Foo2) = Foo2 + instance SingKind Foo2 where + type DemoteRep Foo2 = Foo2 fromSing SA = A fromSing SB = B fromSing SC = C @@ -135,20 +135,17 @@ data instance Sing (z :: Foo3 a) = forall (n :: a). z ~ Foo3 n => SFoo3 (Sing (n :: a)) type SFoo3 = (Sing :: Foo3 a -> Type) - instance SingKind (KProxy :: KProxy a) => - SingKind (KProxy :: KProxy (Foo3 a)) where - type DemoteRep (KProxy :: KProxy (Foo3 a)) = Foo3 (DemoteRep (KProxy :: KProxy a)) + instance SingKind a => SingKind (Foo3 a) where + type DemoteRep (Foo3 a) = Foo3 (DemoteRep a) fromSing (SFoo3 b) = Foo3 (fromSing b) toSing (Foo3 b) - = case toSing b :: SomeSing (KProxy :: KProxy a) of { + = case toSing b :: SomeSing a of { SomeSing c -> SomeSing (SFoo3 c) } data instance Sing (z :: Foo4 a b) = z ~ Foo41 => SFoo41 | z ~ Foo42 => SFoo42 type SFoo4 = (Sing :: Foo4 a b -> Type) - instance (SingKind (KProxy :: KProxy a), - SingKind (KProxy :: KProxy b)) => - SingKind (KProxy :: KProxy (Foo4 a b)) where - type DemoteRep (KProxy :: KProxy (Foo4 a b)) = Foo4 (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b)) + instance (SingKind a, SingKind b) => SingKind (Foo4 a b) where + type DemoteRep (Foo4 a b) = Foo4 (DemoteRep a) (DemoteRep b) fromSing SFoo41 = Foo41 fromSing SFoo42 = Foo42 toSing Foo41 = SomeSing SFoo41 @@ -157,17 +154,16 @@ = forall (n :: Bool) (n :: Bool). z ~ Pair n n => SPair (Sing (n :: Bool)) (Sing (n :: Bool)) type SPair = (Sing :: Pair -> Type) - instance SingKind (KProxy :: KProxy Pair) where - type DemoteRep (KProxy :: KProxy Pair) = Pair + instance SingKind Pair where + type DemoteRep Pair = Pair fromSing (SPair b b) = Pair (fromSing b) (fromSing b) toSing (Pair b b) = case GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy Bool)) - (toSing b :: SomeSing (KProxy :: KProxy Bool)) + (toSing b :: SomeSing Bool) (toSing b :: SomeSing Bool) of { GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SPair c c) } - instance SBounded (KProxy :: KProxy Foo1) where + instance SBounded Foo1 where sMinBound :: Sing (MinBoundSym0 :: Foo1) sMaxBound :: Sing (MaxBoundSym0 :: Foo1) sMinBound @@ -180,7 +176,7 @@ lambda :: Sing (MaxBoundSym0 :: Foo1) lambda = SFoo1 in lambda - instance SBounded (KProxy :: KProxy Foo2) where + instance SBounded Foo2 where sMinBound :: Sing (MinBoundSym0 :: Foo2) sMaxBound :: Sing (MaxBoundSym0 :: Foo2) sMinBound @@ -193,8 +189,7 @@ lambda :: Sing (MaxBoundSym0 :: Foo2) lambda = SE in lambda - instance SBounded (KProxy :: KProxy a) => - SBounded (KProxy :: KProxy (Foo3 a)) where + instance SBounded a => SBounded (Foo3 a) where sMinBound :: Sing (MinBoundSym0 :: Foo3 a) sMaxBound :: Sing (MaxBoundSym0 :: Foo3 a) sMinBound @@ -209,7 +204,7 @@ lambda = applySing (singFun1 (Proxy :: Proxy Foo3Sym0) SFoo3) sMaxBound in lambda - instance SBounded (KProxy :: KProxy (Foo4 a b)) where + instance SBounded (Foo4 a b) where sMinBound :: Sing (MinBoundSym0 :: Foo4 a b) sMaxBound :: Sing (MaxBoundSym0 :: Foo4 a b) sMinBound @@ -222,8 +217,7 @@ lambda :: Sing (MaxBoundSym0 :: Foo4 a b) lambda = SFoo42 in lambda - instance SBounded (KProxy :: KProxy Bool) => - SBounded (KProxy :: KProxy Pair) where + instance SBounded Bool => SBounded Pair where sMinBound :: Sing (MinBoundSym0 :: Pair) sMaxBound :: Sing (MaxBoundSym0 :: Pair) sMinBound diff --git a/tests/compile-and-dump/Singletons/BoundedDeriving.hs b/tests/compile-and-dump/Singletons/BoundedDeriving.hs --- a/tests/compile-and-dump/Singletons/BoundedDeriving.hs +++ b/tests/compile-and-dump/Singletons/BoundedDeriving.hs @@ -2,10 +2,7 @@ import Data.Singletons.Prelude import Data.Singletons.TH - -#if __GLASGOW_HASKELL__ >= 711 import Data.Kind -#endif $(singletons [d| data Foo1 = Foo1 deriving (Bounded) diff --git a/tests/compile-and-dump/Singletons/BoxUnBox.ghc710.template b/tests/compile-and-dump/Singletons/BoxUnBox.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/BoxUnBox.ghc710.template +++ /dev/null @@ -1,49 +0,0 @@ -Singletons/BoxUnBox.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| unBox :: Box a -> a - unBox (FBox a) = a - - data Box a = FBox a |] - ======> - data Box a = FBox a - unBox :: forall a. Box a -> a - unBox (FBox a) = a - type FBoxSym1 (t :: a0123456789) = FBox t - instance SuppressUnusedWarnings FBoxSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FBoxSym0KindInference GHC.Tuple.()) - data FBoxSym0 (l :: TyFun a0123456789 (Box a0123456789)) - = forall arg. KindOf (Apply FBoxSym0 arg) ~ KindOf (FBoxSym1 arg) => - FBoxSym0KindInference - type instance Apply FBoxSym0 l = FBoxSym1 l - type UnBoxSym1 (t :: Box a0123456789) = UnBox t - instance SuppressUnusedWarnings UnBoxSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) UnBoxSym0KindInference GHC.Tuple.()) - data UnBoxSym0 (l :: TyFun (Box a0123456789) a0123456789) - = forall arg. KindOf (Apply UnBoxSym0 arg) ~ KindOf (UnBoxSym1 arg) => - UnBoxSym0KindInference - type instance Apply UnBoxSym0 l = UnBoxSym1 l - type family UnBox (a :: Box a) :: a where - UnBox (FBox a) = a - sUnBox :: - forall (t :: Box a). Sing t -> Sing (Apply UnBoxSym0 t :: a) - sUnBox (SFBox sA) - = let - lambda :: - forall a. t ~ Apply FBoxSym0 a => - Sing a -> Sing (Apply UnBoxSym0 t :: a) - lambda a = a - in lambda sA - data instance Sing (z :: Box a) - = forall (n :: a). z ~ FBox n => SFBox (Sing (n :: a)) - type SBox = (Sing :: Box a -> *) - instance SingKind (KProxy :: KProxy a) => - SingKind (KProxy :: KProxy (Box a)) where - type DemoteRep (KProxy :: KProxy (Box a)) = Box (DemoteRep (KProxy :: KProxy a)) - fromSing (SFBox b) = FBox (fromSing b) - toSing (FBox b) - = case toSing b :: SomeSing (KProxy :: KProxy a) of { - SomeSing c -> SomeSing (SFBox c) } - instance SingI n => SingI (FBox (n :: a)) where - sing = SFBox sing diff --git a/tests/compile-and-dump/Singletons/BoxUnBox.ghc80.template b/tests/compile-and-dump/Singletons/BoxUnBox.ghc80.template --- a/tests/compile-and-dump/Singletons/BoxUnBox.ghc80.template +++ b/tests/compile-and-dump/Singletons/BoxUnBox.ghc80.template @@ -38,12 +38,11 @@ data instance Sing (z :: Box a) = forall (n :: a). z ~ FBox n => SFBox (Sing (n :: a)) type SBox = (Sing :: Box a -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy a) => - SingKind (KProxy :: KProxy (Box a)) where - type DemoteRep (KProxy :: KProxy (Box a)) = Box (DemoteRep (KProxy :: KProxy a)) + instance SingKind a => SingKind (Box a) where + type DemoteRep (Box a) = Box (DemoteRep a) fromSing (SFBox b) = FBox (fromSing b) toSing (FBox b) - = case toSing b :: SomeSing (KProxy :: KProxy a) of { + = case toSing b :: SomeSing a of { SomeSing c -> SomeSing (SFBox c) } instance SingI n => SingI (FBox (n :: a)) where sing = SFBox sing diff --git a/tests/compile-and-dump/Singletons/CaseExpressions.ghc710.template b/tests/compile-and-dump/Singletons/CaseExpressions.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/CaseExpressions.ghc710.template +++ /dev/null @@ -1,352 +0,0 @@ -Singletons/CaseExpressions.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| foo1 :: a -> Maybe a -> a - foo1 d x - = case x of { - Just y -> y - Nothing -> d } - foo2 :: a -> Maybe a -> a - foo2 d _ = case (Just d) of { Just y -> y } - foo3 :: a -> b -> a - foo3 a b = case (a, b) of { (p, _) -> p } - foo4 :: forall a. a -> a - foo4 x - = case x of { - y -> let - z :: a - z = y - in z } - foo5 :: a -> a - foo5 x = case x of { y -> (\ _ -> x) y } |] - ======> - foo1 :: forall a. a -> Maybe a -> a - foo1 d x - = case x of { - Just y -> y - Nothing -> d } - foo2 :: forall a. a -> Maybe a -> a - foo2 d _ = case Just d of { Just y -> y } - foo3 :: forall a b. a -> b -> a - foo3 a b = case (a, b) of { (p, _) -> p } - foo4 :: forall a. a -> a - foo4 x - = case x of { - y -> let - z :: a - z = y - in z } - foo5 :: forall a. a -> a - foo5 x = case x of { y -> \ _ -> x y } - type family Case_0123456789 x y arg_0123456789 t where - Case_0123456789 x y arg_0123456789 _z_0123456789 = x - type family Lambda_0123456789 x y t where - Lambda_0123456789 x y arg_0123456789 = Case_0123456789 x y arg_0123456789 arg_0123456789 - type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type family Case_0123456789 x t where - Case_0123456789 x y = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) y - type Let0123456789ZSym2 t t = Let0123456789Z t t - instance SuppressUnusedWarnings Let0123456789ZSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789ZSym1KindInference GHC.Tuple.()) - data Let0123456789ZSym1 l l - = forall arg. KindOf (Apply (Let0123456789ZSym1 l) arg) ~ KindOf (Let0123456789ZSym2 l arg) => - Let0123456789ZSym1KindInference - type instance Apply (Let0123456789ZSym1 l) l = Let0123456789ZSym2 l l - instance SuppressUnusedWarnings Let0123456789ZSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.()) - data Let0123456789ZSym0 l - = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) => - Let0123456789ZSym0KindInference - type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l - type family Let0123456789Z x y :: a where - Let0123456789Z x y = y - type family Case_0123456789 x t where - Case_0123456789 x y = Let0123456789ZSym2 x y - type Let0123456789Scrutinee_0123456789Sym2 t t = - Let0123456789Scrutinee_0123456789 t t - instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) - Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.()) - data Let0123456789Scrutinee_0123456789Sym1 l l - = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) => - Let0123456789Scrutinee_0123456789Sym1KindInference - type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l - instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) - Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.()) - data Let0123456789Scrutinee_0123456789Sym0 l - = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) => - Let0123456789Scrutinee_0123456789Sym0KindInference - type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l - type family Let0123456789Scrutinee_0123456789 a b where - Let0123456789Scrutinee_0123456789 a b = Apply (Apply Tuple2Sym0 a) b - type family Case_0123456789 a b t where - Case_0123456789 a b '(p, _z_0123456789) = p - type Let0123456789Scrutinee_0123456789Sym2 t t = - Let0123456789Scrutinee_0123456789 t t - instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) - Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.()) - data Let0123456789Scrutinee_0123456789Sym1 l l - = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) => - Let0123456789Scrutinee_0123456789Sym1KindInference - type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l - instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) - Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.()) - data Let0123456789Scrutinee_0123456789Sym0 l - = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) => - Let0123456789Scrutinee_0123456789Sym0KindInference - type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l - type family Let0123456789Scrutinee_0123456789 d _z_0123456789 where - Let0123456789Scrutinee_0123456789 d _z_0123456789 = Apply JustSym0 d - type family Case_0123456789 d _z_0123456789 t where - Case_0123456789 d _z_0123456789 (Just y) = y - type family Case_0123456789 d x t where - Case_0123456789 d x (Just y) = y - Case_0123456789 d x Nothing = d - type Foo5Sym1 (t :: a0123456789) = Foo5 t - instance SuppressUnusedWarnings Foo5Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo5Sym0KindInference GHC.Tuple.()) - data Foo5Sym0 (l :: TyFun a0123456789 a0123456789) - = forall arg. KindOf (Apply Foo5Sym0 arg) ~ KindOf (Foo5Sym1 arg) => - Foo5Sym0KindInference - type instance Apply Foo5Sym0 l = Foo5Sym1 l - type Foo4Sym1 (t :: a0123456789) = Foo4 t - instance SuppressUnusedWarnings Foo4Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo4Sym0KindInference GHC.Tuple.()) - data Foo4Sym0 (l :: TyFun a0123456789 a0123456789) - = forall arg. KindOf (Apply Foo4Sym0 arg) ~ KindOf (Foo4Sym1 arg) => - Foo4Sym0KindInference - type instance Apply Foo4Sym0 l = Foo4Sym1 l - type Foo3Sym2 (t :: a0123456789) (t :: b0123456789) = Foo3 t t - instance SuppressUnusedWarnings Foo3Sym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo3Sym1KindInference GHC.Tuple.()) - data Foo3Sym1 (l :: a0123456789) - (l :: TyFun b0123456789 a0123456789) - = forall arg. KindOf (Apply (Foo3Sym1 l) arg) ~ KindOf (Foo3Sym2 l arg) => - Foo3Sym1KindInference - type instance Apply (Foo3Sym1 l) l = Foo3Sym2 l l - instance SuppressUnusedWarnings Foo3Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.()) - data Foo3Sym0 (l :: TyFun a0123456789 (TyFun b0123456789 a0123456789 - -> *)) - = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) => - Foo3Sym0KindInference - type instance Apply Foo3Sym0 l = Foo3Sym1 l - type Foo2Sym2 (t :: a0123456789) (t :: Maybe a0123456789) = - Foo2 t t - instance SuppressUnusedWarnings Foo2Sym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo2Sym1KindInference GHC.Tuple.()) - data Foo2Sym1 (l :: a0123456789) - (l :: TyFun (Maybe a0123456789) a0123456789) - = forall arg. KindOf (Apply (Foo2Sym1 l) arg) ~ KindOf (Foo2Sym2 l arg) => - Foo2Sym1KindInference - type instance Apply (Foo2Sym1 l) l = Foo2Sym2 l l - instance SuppressUnusedWarnings Foo2Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.()) - data Foo2Sym0 (l :: TyFun a0123456789 (TyFun (Maybe a0123456789) a0123456789 - -> *)) - = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) => - Foo2Sym0KindInference - type instance Apply Foo2Sym0 l = Foo2Sym1 l - type Foo1Sym2 (t :: a0123456789) (t :: Maybe a0123456789) = - Foo1 t t - instance SuppressUnusedWarnings Foo1Sym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo1Sym1KindInference GHC.Tuple.()) - data Foo1Sym1 (l :: a0123456789) - (l :: TyFun (Maybe a0123456789) a0123456789) - = forall arg. KindOf (Apply (Foo1Sym1 l) arg) ~ KindOf (Foo1Sym2 l arg) => - Foo1Sym1KindInference - type instance Apply (Foo1Sym1 l) l = Foo1Sym2 l l - instance SuppressUnusedWarnings Foo1Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.()) - data Foo1Sym0 (l :: TyFun a0123456789 (TyFun (Maybe a0123456789) a0123456789 - -> *)) - = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) => - Foo1Sym0KindInference - type instance Apply Foo1Sym0 l = Foo1Sym1 l - type family Foo5 (a :: a) :: a where - Foo5 x = Case_0123456789 x x - type family Foo4 (a :: a) :: a where - Foo4 x = Case_0123456789 x x - type family Foo3 (a :: a) (a :: b) :: a where - Foo3 a b = Case_0123456789 a b (Let0123456789Scrutinee_0123456789Sym2 a b) - type family Foo2 (a :: a) (a :: Maybe a) :: a where - Foo2 d _z_0123456789 = Case_0123456789 d _z_0123456789 (Let0123456789Scrutinee_0123456789Sym2 d _z_0123456789) - type family Foo1 (a :: a) (a :: Maybe a) :: a where - Foo1 d x = Case_0123456789 d x x - sFoo5 :: forall (t :: a). Sing t -> Sing (Apply Foo5Sym0 t :: a) - sFoo4 :: forall (t :: a). Sing t -> Sing (Apply Foo4Sym0 t :: a) - sFoo3 :: - forall (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a) - sFoo2 :: - forall (t :: a) (t :: Maybe a). - Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a) - sFoo1 :: - forall (t :: a) (t :: Maybe a). - Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a) - sFoo5 sX - = let - lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo5Sym0 t :: a) - lambda x - = case x of { - sY - -> let - lambda :: - forall y. y ~ x => Sing y -> Sing (Case_0123456789 x y :: a) - lambda y - = applySing - (singFun1 - (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 x) y)) - (\ sArg_0123456789 - -> let - lambda :: - forall arg_0123456789. - Sing arg_0123456789 - -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) arg_0123456789) - lambda arg_0123456789 - = case arg_0123456789 of { - _s_z_0123456789 - -> let - lambda :: - forall _z_0123456789. _z_0123456789 ~ arg_0123456789 => - Sing _z_0123456789 - -> Sing (Case_0123456789 x y arg_0123456789 _z_0123456789) - lambda _z_0123456789 = x - in lambda _s_z_0123456789 } :: - Sing (Case_0123456789 x y arg_0123456789 arg_0123456789) - in lambda sArg_0123456789)) - y - in lambda sY } :: - Sing (Case_0123456789 x x :: a) - in lambda sX - sFoo4 sX - = let - lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo4Sym0 t :: a) - lambda x - = case x of { - sY - -> let - lambda :: - forall y. y ~ x => Sing y -> Sing (Case_0123456789 x y :: a) - lambda y - = let - sZ :: Sing (Let0123456789ZSym2 x y :: a) - sZ = y - in sZ - in lambda sY } :: - Sing (Case_0123456789 x x :: a) - in lambda sX - sFoo3 sA sB - = let - lambda :: - forall a b. (t ~ a, t ~ b) => - Sing a -> Sing b -> Sing (Apply (Apply Foo3Sym0 t) t :: a) - lambda a b - = let - sScrutinee_0123456789 :: - Sing (Let0123456789Scrutinee_0123456789Sym2 a b) - sScrutinee_0123456789 - = applySing - (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) a) b - in case sScrutinee_0123456789 of { - STuple2 sP _s_z_0123456789 - -> let - lambda :: - forall p - _z_0123456789. Apply (Apply Tuple2Sym0 p) _z_0123456789 ~ Let0123456789Scrutinee_0123456789Sym2 a b => - Sing p - -> Sing _z_0123456789 - -> Sing (Case_0123456789 a b (Apply (Apply Tuple2Sym0 p) _z_0123456789) :: a) - lambda p _z_0123456789 = p - in lambda sP _s_z_0123456789 } :: - Sing (Case_0123456789 a b (Let0123456789Scrutinee_0123456789Sym2 a b) :: a) - in lambda sA sB - sFoo2 sD _s_z_0123456789 - = let - lambda :: - forall d _z_0123456789. (t ~ d, t ~ _z_0123456789) => - Sing d - -> Sing _z_0123456789 -> Sing (Apply (Apply Foo2Sym0 t) t :: a) - lambda d _z_0123456789 - = let - sScrutinee_0123456789 :: - Sing (Let0123456789Scrutinee_0123456789Sym2 d _z_0123456789) - sScrutinee_0123456789 - = applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) d - in case sScrutinee_0123456789 of { - SJust sY - -> let - lambda :: - forall y. Apply JustSym0 y ~ Let0123456789Scrutinee_0123456789Sym2 d _z_0123456789 => - Sing y - -> Sing (Case_0123456789 d _z_0123456789 (Apply JustSym0 y) :: a) - lambda y = y - in lambda sY } :: - Sing (Case_0123456789 d _z_0123456789 (Let0123456789Scrutinee_0123456789Sym2 d _z_0123456789) :: a) - in lambda sD _s_z_0123456789 - sFoo1 sD sX - = let - lambda :: - forall d x. (t ~ d, t ~ x) => - Sing d -> Sing x -> Sing (Apply (Apply Foo1Sym0 t) t :: a) - lambda d x - = case x of { - SJust sY - -> let - lambda :: - forall y. Apply JustSym0 y ~ x => - Sing y -> Sing (Case_0123456789 d x (Apply JustSym0 y) :: a) - lambda y = y - in lambda sY - SNothing - -> let - lambda :: - NothingSym0 ~ x => Sing (Case_0123456789 d x NothingSym0 :: a) - lambda = d - in lambda } :: - Sing (Case_0123456789 d x x :: a) - in lambda sD sX diff --git a/tests/compile-and-dump/Singletons/Classes.ghc710.template b/tests/compile-and-dump/Singletons/Classes.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/Classes.ghc710.template +++ /dev/null @@ -1,654 +0,0 @@ -Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| infix 4 <=> - - const :: a -> b -> a - const x _ = x - fooCompare :: Foo -> Foo -> Ordering - fooCompare A A = EQ - fooCompare A B = LT - fooCompare B B = GT - fooCompare B A = EQ - - class MyOrd a where - mycompare :: a -> a -> Ordering - (<=>) :: a -> a -> Ordering - (<=>) = mycompare - infix 4 <=> - data Foo = A | B - data Foo2 = F | G - - instance Eq Foo2 where - F == F = True - G == G = True - F == G = False - G == F = False - instance MyOrd Foo where - mycompare = fooCompare - instance MyOrd () where - mycompare _ = const EQ - instance MyOrd Nat where - Zero `mycompare` Zero = EQ - Zero `mycompare` (Succ _) = LT - (Succ _) `mycompare` Zero = GT - (Succ n) `mycompare` (Succ m) = m `mycompare` n |] - ======> - const :: forall a b. a -> b -> a - const x _ = x - class MyOrd a where - mycompare :: a -> a -> Ordering - (<=>) :: a -> a -> Ordering - (<=>) = mycompare - infix 4 <=> - instance MyOrd Nat where - mycompare Zero Zero = EQ - mycompare Zero (Succ _) = LT - mycompare (Succ _) Zero = GT - mycompare (Succ n) (Succ m) = (m `mycompare` n) - instance MyOrd () where - mycompare _ = const EQ - data Foo = A | B - fooCompare :: Foo -> Foo -> Ordering - fooCompare A A = EQ - fooCompare A B = LT - fooCompare B B = GT - fooCompare B A = EQ - instance MyOrd Foo where - mycompare = fooCompare - data Foo2 = F | G - instance Eq Foo2 where - (==) F F = True - (==) G G = True - (==) F G = False - (==) G F = False - type ASym0 = A - type BSym0 = B - type FSym0 = F - type GSym0 = G - type FooCompareSym2 (t :: Foo) (t :: Foo) = FooCompare t t - instance SuppressUnusedWarnings FooCompareSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FooCompareSym1KindInference GHC.Tuple.()) - data FooCompareSym1 (l :: Foo) (l :: TyFun Foo Ordering) - = forall arg. KindOf (Apply (FooCompareSym1 l) arg) ~ KindOf (FooCompareSym2 l arg) => - FooCompareSym1KindInference - type instance Apply (FooCompareSym1 l) l = FooCompareSym2 l l - instance SuppressUnusedWarnings FooCompareSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FooCompareSym0KindInference GHC.Tuple.()) - data FooCompareSym0 (l :: TyFun Foo (TyFun Foo Ordering -> *)) - = forall arg. KindOf (Apply FooCompareSym0 arg) ~ KindOf (FooCompareSym1 arg) => - FooCompareSym0KindInference - type instance Apply FooCompareSym0 l = FooCompareSym1 l - type ConstSym2 (t :: a0123456789) (t :: b0123456789) = Const t t - instance SuppressUnusedWarnings ConstSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ConstSym1KindInference GHC.Tuple.()) - data ConstSym1 (l :: a0123456789) - (l :: TyFun b0123456789 a0123456789) - = forall arg. KindOf (Apply (ConstSym1 l) arg) ~ KindOf (ConstSym2 l arg) => - ConstSym1KindInference - type instance Apply (ConstSym1 l) l = ConstSym2 l l - instance SuppressUnusedWarnings ConstSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ConstSym0KindInference GHC.Tuple.()) - data ConstSym0 (l :: TyFun a0123456789 (TyFun b0123456789 a0123456789 - -> *)) - = forall arg. KindOf (Apply ConstSym0 arg) ~ KindOf (ConstSym1 arg) => - ConstSym0KindInference - type instance Apply ConstSym0 l = ConstSym1 l - type family FooCompare (a :: Foo) (a :: Foo) :: Ordering where - FooCompare A A = EQSym0 - FooCompare A B = LTSym0 - FooCompare B B = GTSym0 - FooCompare B A = EQSym0 - type family Const (a :: a) (a :: b) :: a where - Const x _z_0123456789 = x - infix 4 :<=> - type MycompareSym2 (t :: a0123456789) (t :: a0123456789) = - Mycompare t t - instance SuppressUnusedWarnings MycompareSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) MycompareSym1KindInference GHC.Tuple.()) - data MycompareSym1 (l :: a0123456789) - (l :: TyFun a0123456789 Ordering) - = forall arg. KindOf (Apply (MycompareSym1 l) arg) ~ KindOf (MycompareSym2 l arg) => - MycompareSym1KindInference - type instance Apply (MycompareSym1 l) l = MycompareSym2 l l - instance SuppressUnusedWarnings MycompareSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) MycompareSym0KindInference GHC.Tuple.()) - data MycompareSym0 (l :: TyFun a0123456789 (TyFun a0123456789 Ordering - -> *)) - = forall arg. KindOf (Apply MycompareSym0 arg) ~ KindOf (MycompareSym1 arg) => - MycompareSym0KindInference - type instance Apply MycompareSym0 l = MycompareSym1 l - type (:<=>$$$) (t :: a0123456789) (t :: a0123456789) = (:<=>) t t - instance SuppressUnusedWarnings (:<=>$$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:<=>$$###) GHC.Tuple.()) - data (:<=>$$) (l :: a0123456789) (l :: TyFun a0123456789 Ordering) - = forall arg. KindOf (Apply ((:<=>$$) l) arg) ~ KindOf ((:<=>$$$) l arg) => - :<=>$$### - type instance Apply ((:<=>$$) l) l = (:<=>$$$) l l - instance SuppressUnusedWarnings (:<=>$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:<=>$###) GHC.Tuple.()) - data (:<=>$) (l :: TyFun a0123456789 (TyFun a0123456789 Ordering - -> *)) - = forall arg. KindOf (Apply (:<=>$) arg) ~ KindOf ((:<=>$$) arg) => - :<=>$### - type instance Apply (:<=>$) l = (:<=>$$) l - type family TFHelper_0123456789 (a :: a) (a :: a) :: Ordering where - TFHelper_0123456789 a_0123456789 a_0123456789 = Apply (Apply MycompareSym0 a_0123456789) a_0123456789 - type TFHelper_0123456789Sym2 (t :: a0123456789) - (t :: a0123456789) = - TFHelper_0123456789 t t - instance SuppressUnusedWarnings TFHelper_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) TFHelper_0123456789Sym1KindInference GHC.Tuple.()) - data TFHelper_0123456789Sym1 (l :: a0123456789) - (l :: TyFun a0123456789 Ordering) - = forall arg. KindOf (Apply (TFHelper_0123456789Sym1 l) arg) ~ KindOf (TFHelper_0123456789Sym2 l arg) => - TFHelper_0123456789Sym1KindInference - type instance Apply (TFHelper_0123456789Sym1 l) l = TFHelper_0123456789Sym2 l l - instance SuppressUnusedWarnings TFHelper_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) TFHelper_0123456789Sym0KindInference GHC.Tuple.()) - data TFHelper_0123456789Sym0 (l :: TyFun a0123456789 (TyFun a0123456789 Ordering - -> *)) - = forall arg. KindOf (Apply TFHelper_0123456789Sym0 arg) ~ KindOf (TFHelper_0123456789Sym1 arg) => - TFHelper_0123456789Sym0KindInference - type instance Apply TFHelper_0123456789Sym0 l = TFHelper_0123456789Sym1 l - class kproxy ~ KProxy => PMyOrd (kproxy :: KProxy a) where - type family Mycompare (arg :: a) (arg :: a) :: Ordering - type family (:<=>) (arg :: a) (arg :: a) :: Ordering - (:<=>) (a :: a) - (a :: a) = Apply (Apply TFHelper_0123456789Sym0 a) a - type family Mycompare_0123456789 (a :: Nat) - (a :: Nat) :: Ordering where - Mycompare_0123456789 Zero Zero = EQSym0 - Mycompare_0123456789 Zero (Succ _z_0123456789) = LTSym0 - Mycompare_0123456789 (Succ _z_0123456789) Zero = GTSym0 - Mycompare_0123456789 (Succ n) (Succ m) = Apply (Apply MycompareSym0 m) n - type Mycompare_0123456789Sym2 (t :: Nat) (t :: Nat) = - Mycompare_0123456789 t t - instance SuppressUnusedWarnings Mycompare_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Mycompare_0123456789Sym1KindInference GHC.Tuple.()) - data Mycompare_0123456789Sym1 (l :: Nat) (l :: TyFun Nat Ordering) - = forall arg. KindOf (Apply (Mycompare_0123456789Sym1 l) arg) ~ KindOf (Mycompare_0123456789Sym2 l arg) => - Mycompare_0123456789Sym1KindInference - type instance Apply (Mycompare_0123456789Sym1 l) l = Mycompare_0123456789Sym2 l l - instance SuppressUnusedWarnings Mycompare_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Mycompare_0123456789Sym0KindInference GHC.Tuple.()) - data Mycompare_0123456789Sym0 (l :: TyFun Nat (TyFun Nat Ordering - -> *)) - = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) => - Mycompare_0123456789Sym0KindInference - type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l - instance PMyOrd (KProxy :: KProxy Nat) where - type Mycompare (a :: Nat) (a :: Nat) = Apply (Apply Mycompare_0123456789Sym0 a) a - type family Mycompare_0123456789 (a :: ()) - (a :: ()) :: Ordering where - Mycompare_0123456789 _z_0123456789 a_0123456789 = Apply (Apply ConstSym0 EQSym0) a_0123456789 - type Mycompare_0123456789Sym2 (t :: ()) (t :: ()) = - Mycompare_0123456789 t t - instance SuppressUnusedWarnings Mycompare_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Mycompare_0123456789Sym1KindInference GHC.Tuple.()) - data Mycompare_0123456789Sym1 (l :: ()) (l :: TyFun () Ordering) - = forall arg. KindOf (Apply (Mycompare_0123456789Sym1 l) arg) ~ KindOf (Mycompare_0123456789Sym2 l arg) => - Mycompare_0123456789Sym1KindInference - type instance Apply (Mycompare_0123456789Sym1 l) l = Mycompare_0123456789Sym2 l l - instance SuppressUnusedWarnings Mycompare_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Mycompare_0123456789Sym0KindInference GHC.Tuple.()) - data Mycompare_0123456789Sym0 (l :: TyFun () (TyFun () Ordering - -> *)) - = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) => - Mycompare_0123456789Sym0KindInference - type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l - instance PMyOrd (KProxy :: KProxy ()) where - type Mycompare (a :: ()) (a :: ()) = Apply (Apply Mycompare_0123456789Sym0 a) a - type family Mycompare_0123456789 (a :: Foo) - (a :: Foo) :: Ordering where - Mycompare_0123456789 a_0123456789 a_0123456789 = Apply (Apply FooCompareSym0 a_0123456789) a_0123456789 - type Mycompare_0123456789Sym2 (t :: Foo) (t :: Foo) = - Mycompare_0123456789 t t - instance SuppressUnusedWarnings Mycompare_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Mycompare_0123456789Sym1KindInference GHC.Tuple.()) - data Mycompare_0123456789Sym1 (l :: Foo) (l :: TyFun Foo Ordering) - = forall arg. KindOf (Apply (Mycompare_0123456789Sym1 l) arg) ~ KindOf (Mycompare_0123456789Sym2 l arg) => - Mycompare_0123456789Sym1KindInference - type instance Apply (Mycompare_0123456789Sym1 l) l = Mycompare_0123456789Sym2 l l - instance SuppressUnusedWarnings Mycompare_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Mycompare_0123456789Sym0KindInference GHC.Tuple.()) - data Mycompare_0123456789Sym0 (l :: TyFun Foo (TyFun Foo Ordering - -> *)) - = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) => - Mycompare_0123456789Sym0KindInference - type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l - instance PMyOrd (KProxy :: KProxy Foo) where - type Mycompare (a :: Foo) (a :: Foo) = Apply (Apply Mycompare_0123456789Sym0 a) a - type family TFHelper_0123456789 (a :: Foo2) - (a :: Foo2) :: Bool where - TFHelper_0123456789 F F = TrueSym0 - TFHelper_0123456789 G G = TrueSym0 - TFHelper_0123456789 F G = FalseSym0 - TFHelper_0123456789 G F = FalseSym0 - type TFHelper_0123456789Sym2 (t :: Foo2) (t :: Foo2) = - TFHelper_0123456789 t t - instance SuppressUnusedWarnings TFHelper_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) TFHelper_0123456789Sym1KindInference GHC.Tuple.()) - data TFHelper_0123456789Sym1 (l :: Foo2) (l :: TyFun Foo2 Bool) - = forall arg. KindOf (Apply (TFHelper_0123456789Sym1 l) arg) ~ KindOf (TFHelper_0123456789Sym2 l arg) => - TFHelper_0123456789Sym1KindInference - type instance Apply (TFHelper_0123456789Sym1 l) l = TFHelper_0123456789Sym2 l l - instance SuppressUnusedWarnings TFHelper_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) TFHelper_0123456789Sym0KindInference GHC.Tuple.()) - data TFHelper_0123456789Sym0 (l :: TyFun Foo2 (TyFun Foo2 Bool - -> *)) - = forall arg. KindOf (Apply TFHelper_0123456789Sym0 arg) ~ KindOf (TFHelper_0123456789Sym1 arg) => - TFHelper_0123456789Sym0KindInference - type instance Apply TFHelper_0123456789Sym0 l = TFHelper_0123456789Sym1 l - instance PEq (KProxy :: KProxy Foo2) where - type (:==) (a :: Foo2) (a :: Foo2) = Apply (Apply TFHelper_0123456789Sym0 a) a - infix 4 %:<=> - sFooCompare :: - forall (t :: Foo) (t :: Foo). - Sing t - -> Sing t -> Sing (Apply (Apply FooCompareSym0 t) t :: Ordering) - sConst :: - forall (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply ConstSym0 t) t :: a) - sFooCompare SA SA - = let - lambda :: - (t ~ ASym0, t ~ ASym0) => - Sing (Apply (Apply FooCompareSym0 t) t :: Ordering) - lambda = SEQ - in lambda - sFooCompare SA SB - = let - lambda :: - (t ~ ASym0, t ~ BSym0) => - Sing (Apply (Apply FooCompareSym0 t) t :: Ordering) - lambda = SLT - in lambda - sFooCompare SB SB - = let - lambda :: - (t ~ BSym0, t ~ BSym0) => - Sing (Apply (Apply FooCompareSym0 t) t :: Ordering) - lambda = SGT - in lambda - sFooCompare SB SA - = let - lambda :: - (t ~ BSym0, t ~ ASym0) => - Sing (Apply (Apply FooCompareSym0 t) t :: Ordering) - lambda = SEQ - in lambda - sConst sX _s_z_0123456789 - = let - lambda :: - forall x _z_0123456789. (t ~ x, t ~ _z_0123456789) => - Sing x - -> Sing _z_0123456789 -> Sing (Apply (Apply ConstSym0 t) t :: a) - lambda x _z_0123456789 = x - in lambda sX _s_z_0123456789 - data instance Sing (z :: Foo) = z ~ A => SA | z ~ B => SB - type SFoo = (Sing :: Foo -> *) - instance SingKind (KProxy :: KProxy Foo) where - type DemoteRep (KProxy :: KProxy Foo) = Foo - fromSing SA = A - fromSing SB = B - toSing A = SomeSing SA - toSing B = SomeSing SB - data instance Sing (z :: Foo2) = z ~ F => SF | z ~ G => SG - type SFoo2 = (Sing :: Foo2 -> *) - instance SingKind (KProxy :: KProxy Foo2) where - type DemoteRep (KProxy :: KProxy Foo2) = Foo2 - fromSing SF = F - fromSing SG = G - toSing F = SomeSing SF - toSing G = SomeSing SG - class kproxy ~ KProxy => SMyOrd (kproxy :: KProxy 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 (:<=>$) t) t :: Ordering) - default (%:<=>) :: - forall (t :: a) - (t :: a). Apply (Apply (:<=>$) t) t ~ Apply (Apply TFHelper_0123456789Sym0 t) t => - Sing t -> Sing t -> Sing (Apply (Apply (:<=>$) t) t :: Ordering) - (%:<=>) sA_0123456789 sA_0123456789 - = let - lambda :: - forall a_0123456789 a_0123456789. (t ~ a_0123456789, - t ~ a_0123456789) => - Sing a_0123456789 - -> Sing a_0123456789 - -> Sing (Apply (Apply (:<=>$) t) t :: Ordering) - lambda a_0123456789 a_0123456789 - = applySing - (applySing - (singFun2 (Proxy :: Proxy MycompareSym0) sMycompare) a_0123456789) - a_0123456789 - in lambda sA_0123456789 sA_0123456789 - instance SMyOrd (KProxy :: KProxy Nat) where - sMycompare :: - forall (t :: Nat) (t :: Nat). - Sing t - -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) - sMycompare SZero SZero - = let - lambda :: - (t ~ ZeroSym0, t ~ ZeroSym0) => - Sing (Apply (Apply MycompareSym0 t) t :: Ordering) - lambda = SEQ - in lambda - sMycompare SZero (SSucc _s_z_0123456789) - = let - lambda :: - forall _z_0123456789. (t ~ ZeroSym0, - t ~ Apply SuccSym0 _z_0123456789) => - Sing _z_0123456789 - -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) - lambda _z_0123456789 = SLT - in lambda _s_z_0123456789 - sMycompare (SSucc _s_z_0123456789) SZero - = let - lambda :: - forall _z_0123456789. (t ~ Apply SuccSym0 _z_0123456789, - t ~ ZeroSym0) => - Sing _z_0123456789 - -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) - lambda _z_0123456789 = SGT - in lambda _s_z_0123456789 - sMycompare (SSucc sN) (SSucc sM) - = let - lambda :: - forall n m. (t ~ Apply SuccSym0 n, t ~ Apply SuccSym0 m) => - Sing n - -> Sing m -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) - lambda n m - = applySing - (applySing (singFun2 (Proxy :: Proxy MycompareSym0) sMycompare) m) - n - in lambda sN sM - instance SMyOrd (KProxy :: KProxy ()) where - sMycompare :: - forall (t :: ()) (t :: ()). - Sing t - -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) - sMycompare _s_z_0123456789 sA_0123456789 - = let - lambda :: - forall _z_0123456789 a_0123456789. (t ~ _z_0123456789, - t ~ a_0123456789) => - Sing _z_0123456789 - -> Sing a_0123456789 - -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) - lambda _z_0123456789 a_0123456789 - = applySing - (applySing (singFun2 (Proxy :: Proxy ConstSym0) sConst) SEQ) - a_0123456789 - in lambda _s_z_0123456789 sA_0123456789 - instance SMyOrd (KProxy :: KProxy Foo) where - sMycompare :: - forall (t :: Foo) (t :: Foo). - Sing t - -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) - sMycompare sA_0123456789 sA_0123456789 - = let - lambda :: - forall a_0123456789 a_0123456789. (t ~ a_0123456789, - t ~ a_0123456789) => - Sing a_0123456789 - -> Sing a_0123456789 - -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) - lambda a_0123456789 a_0123456789 - = applySing - (applySing - (singFun2 (Proxy :: Proxy FooCompareSym0) sFooCompare) - a_0123456789) - a_0123456789 - in lambda sA_0123456789 sA_0123456789 - instance SEq (KProxy :: KProxy Foo2) where - (%:==) :: - forall (a :: Foo2) (b :: Foo2). - Sing a -> Sing b -> Sing ((:==) a b) - (%:==) SF SF - = let - lambda :: (a ~ FSym0, b ~ FSym0) => Sing (Apply (Apply (:==$) a) b) - lambda = STrue - in lambda - (%:==) SG SG - = let - lambda :: (a ~ GSym0, b ~ GSym0) => Sing (Apply (Apply (:==$) a) b) - lambda = STrue - in lambda - (%:==) SF SG - = let - lambda :: (a ~ FSym0, b ~ GSym0) => Sing (Apply (Apply (:==$) a) b) - lambda = SFalse - in lambda - (%:==) SG SF - = let - lambda :: (a ~ GSym0, b ~ FSym0) => Sing (Apply (Apply (:==$) a) b) - lambda = SFalse - in lambda - instance SingI A where - sing = SA - instance SingI B where - sing = SB - instance SingI F where - sing = SF - instance SingI G where - sing = SG -Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations - promote - [d| instance Ord Foo2 where - F `compare` F = EQ - F `compare` _ = LT - _ `compare` _ = GT - instance MyOrd Foo2 where - F `mycompare` F = EQ - F `mycompare` _ = LT - _ `mycompare` _ = GT |] - ======> - instance MyOrd Foo2 where - mycompare F F = EQ - mycompare F _ = LT - mycompare _ _ = GT - instance Ord Foo2 where - compare F F = EQ - compare F _ = LT - compare _ _ = GT - type family Mycompare_0123456789 (a :: Foo2) - (a :: Foo2) :: Ordering where - Mycompare_0123456789 F F = EQSym0 - Mycompare_0123456789 F _z_0123456789 = LTSym0 - Mycompare_0123456789 _z_0123456789 _z_0123456789 = GTSym0 - type Mycompare_0123456789Sym2 (t :: Foo2) (t :: Foo2) = - Mycompare_0123456789 t t - instance SuppressUnusedWarnings Mycompare_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Mycompare_0123456789Sym1KindInference GHC.Tuple.()) - data Mycompare_0123456789Sym1 (l :: Foo2) - (l :: TyFun Foo2 Ordering) - = forall arg. KindOf (Apply (Mycompare_0123456789Sym1 l) arg) ~ KindOf (Mycompare_0123456789Sym2 l arg) => - Mycompare_0123456789Sym1KindInference - type instance Apply (Mycompare_0123456789Sym1 l) l = Mycompare_0123456789Sym2 l l - instance SuppressUnusedWarnings Mycompare_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Mycompare_0123456789Sym0KindInference GHC.Tuple.()) - data Mycompare_0123456789Sym0 (l :: TyFun Foo2 (TyFun Foo2 Ordering - -> *)) - = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) => - Mycompare_0123456789Sym0KindInference - type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l - instance PMyOrd (KProxy :: KProxy Foo2) where - type Mycompare (a :: Foo2) (a :: Foo2) = Apply (Apply Mycompare_0123456789Sym0 a) a - type family Compare_0123456789 (a :: Foo2) - (a :: Foo2) :: Ordering where - Compare_0123456789 F F = EQSym0 - Compare_0123456789 F _z_0123456789 = LTSym0 - Compare_0123456789 _z_0123456789 _z_0123456789 = GTSym0 - type Compare_0123456789Sym2 (t :: Foo2) (t :: Foo2) = - Compare_0123456789 t t - instance SuppressUnusedWarnings Compare_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Compare_0123456789Sym1KindInference GHC.Tuple.()) - data Compare_0123456789Sym1 (l :: Foo2) (l :: TyFun Foo2 Ordering) - = forall arg. KindOf (Apply (Compare_0123456789Sym1 l) arg) ~ KindOf (Compare_0123456789Sym2 l arg) => - Compare_0123456789Sym1KindInference - type instance Apply (Compare_0123456789Sym1 l) l = Compare_0123456789Sym2 l l - instance SuppressUnusedWarnings Compare_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Compare_0123456789Sym0KindInference GHC.Tuple.()) - data Compare_0123456789Sym0 (l :: TyFun Foo2 (TyFun Foo2 Ordering - -> *)) - = forall arg. KindOf (Apply Compare_0123456789Sym0 arg) ~ KindOf (Compare_0123456789Sym1 arg) => - Compare_0123456789Sym0KindInference - type instance Apply Compare_0123456789Sym0 l = Compare_0123456789Sym1 l - instance POrd (KProxy :: KProxy Foo2) where - type Compare (a :: Foo2) (a :: Foo2) = Apply (Apply Compare_0123456789Sym0 a) a -Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| data Nat' = Zero' | Succ' Nat' - - instance MyOrd Nat' where - Zero' `mycompare` Zero' = EQ - Zero' `mycompare` (Succ' _) = LT - (Succ' _) `mycompare` Zero' = GT - (Succ' n) `mycompare` (Succ' m) = m `mycompare` n |] - ======> - data Nat' = Zero' | Succ' Nat' - instance MyOrd Nat' where - mycompare Zero' Zero' = EQ - mycompare Zero' (Succ' _) = LT - mycompare (Succ' _) Zero' = GT - mycompare (Succ' n) (Succ' m) = (m `mycompare` n) - type Zero'Sym0 = Zero' - type Succ'Sym1 (t :: Nat') = Succ' t - instance SuppressUnusedWarnings Succ'Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Succ'Sym0KindInference GHC.Tuple.()) - data Succ'Sym0 (l :: TyFun Nat' Nat') - = forall arg. KindOf (Apply Succ'Sym0 arg) ~ KindOf (Succ'Sym1 arg) => - Succ'Sym0KindInference - type instance Apply Succ'Sym0 l = Succ'Sym1 l - type family Mycompare_0123456789 (a :: Nat') - (a :: Nat') :: Ordering where - Mycompare_0123456789 Zero' Zero' = EQSym0 - Mycompare_0123456789 Zero' (Succ' _z_0123456789) = LTSym0 - Mycompare_0123456789 (Succ' _z_0123456789) Zero' = GTSym0 - Mycompare_0123456789 (Succ' n) (Succ' m) = Apply (Apply MycompareSym0 m) n - type Mycompare_0123456789Sym2 (t :: Nat') (t :: Nat') = - Mycompare_0123456789 t t - instance SuppressUnusedWarnings Mycompare_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Mycompare_0123456789Sym1KindInference GHC.Tuple.()) - data Mycompare_0123456789Sym1 (l :: Nat') - (l :: TyFun Nat' Ordering) - = forall arg. KindOf (Apply (Mycompare_0123456789Sym1 l) arg) ~ KindOf (Mycompare_0123456789Sym2 l arg) => - Mycompare_0123456789Sym1KindInference - type instance Apply (Mycompare_0123456789Sym1 l) l = Mycompare_0123456789Sym2 l l - instance SuppressUnusedWarnings Mycompare_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Mycompare_0123456789Sym0KindInference GHC.Tuple.()) - data Mycompare_0123456789Sym0 (l :: TyFun Nat' (TyFun Nat' Ordering - -> *)) - = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) => - Mycompare_0123456789Sym0KindInference - type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l - instance PMyOrd (KProxy :: KProxy Nat') where - type Mycompare (a :: Nat') (a :: Nat') = Apply (Apply Mycompare_0123456789Sym0 a) a - data instance Sing (z :: Nat') - = z ~ Zero' => SZero' | - forall (n :: Nat'). z ~ Succ' n => SSucc' (Sing (n :: Nat')) - type SNat' = (Sing :: Nat' -> *) - instance SingKind (KProxy :: KProxy Nat') where - type DemoteRep (KProxy :: KProxy Nat') = Nat' - fromSing SZero' = Zero' - fromSing (SSucc' b) = Succ' (fromSing b) - toSing Zero' = SomeSing SZero' - toSing (Succ' b) - = case toSing b :: SomeSing (KProxy :: KProxy Nat') of { - SomeSing c -> SomeSing (SSucc' c) } - instance SMyOrd (KProxy :: KProxy Nat') where - sMycompare :: - forall (t :: Nat') (t :: Nat'). - Sing t - -> Sing t - -> Sing (Apply (Apply (MycompareSym0 :: TyFun Nat' (TyFun Nat' Ordering - -> *) - -> *) t :: TyFun Nat' Ordering - -> *) t :: Ordering) - sMycompare SZero' SZero' - = let - lambda :: - (t ~ Zero'Sym0, t ~ Zero'Sym0) => - Sing (Apply (Apply MycompareSym0 t) t :: Ordering) - lambda = SEQ - in lambda - sMycompare SZero' (SSucc' _s_z_0123456789) - = let - lambda :: - forall _z_0123456789. (t ~ Zero'Sym0, - t ~ Apply Succ'Sym0 _z_0123456789) => - Sing _z_0123456789 - -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) - lambda _z_0123456789 = SLT - in lambda _s_z_0123456789 - sMycompare (SSucc' _s_z_0123456789) SZero' - = let - lambda :: - forall _z_0123456789. (t ~ Apply Succ'Sym0 _z_0123456789, - t ~ Zero'Sym0) => - Sing _z_0123456789 - -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) - lambda _z_0123456789 = SGT - in lambda _s_z_0123456789 - sMycompare (SSucc' sN) (SSucc' sM) - = let - lambda :: - forall n m. (t ~ Apply Succ'Sym0 n, t ~ Apply Succ'Sym0 m) => - Sing n - -> Sing m -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering) - lambda n m - = applySing - (applySing (singFun2 (Proxy :: Proxy MycompareSym0) sMycompare) m) - n - in lambda sN sM - instance SingI Zero' where - sing = SZero' - instance SingI n => SingI (Succ' (n :: Nat')) where - sing = SSucc' sing diff --git a/tests/compile-and-dump/Singletons/Classes.ghc80.template b/tests/compile-and-dump/Singletons/Classes.ghc80.template --- a/tests/compile-and-dump/Singletons/Classes.ghc80.template +++ b/tests/compile-and-dump/Singletons/Classes.ghc80.template @@ -163,7 +163,7 @@ = forall arg. KindOf (Apply TFHelper_0123456789Sym0 arg) ~ KindOf (TFHelper_0123456789Sym1 arg) => TFHelper_0123456789Sym0KindInference type instance Apply TFHelper_0123456789Sym0 l = TFHelper_0123456789Sym1 l - class kproxy ~ KProxy => PMyOrd (kproxy :: KProxy a) where + class kproxy ~ Proxy => PMyOrd (kproxy :: Proxy a) where type Mycompare (arg :: a) (arg :: a) :: Ordering type (:<=>) (arg :: a) (arg :: a) :: Ordering type (:<=>) a a = Apply (Apply TFHelper_0123456789Sym0 a) a @@ -192,7 +192,7 @@ = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) => Mycompare_0123456789Sym0KindInference type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l - instance PMyOrd (KProxy :: KProxy Nat) where + instance PMyOrd (Proxy :: Proxy Nat) where type Mycompare (a :: Nat) (a :: Nat) = Apply (Apply Mycompare_0123456789Sym0 a) a type family Mycompare_0123456789 (a :: ()) (a :: ()) :: Ordering where @@ -216,7 +216,7 @@ = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) => Mycompare_0123456789Sym0KindInference type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l - instance PMyOrd (KProxy :: KProxy ()) where + instance PMyOrd (Proxy :: Proxy ()) where type Mycompare (a :: ()) (a :: ()) = Apply (Apply Mycompare_0123456789Sym0 a) a type family Mycompare_0123456789 (a :: Foo) (a :: Foo) :: Ordering where @@ -240,7 +240,7 @@ = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) => Mycompare_0123456789Sym0KindInference type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l - instance PMyOrd (KProxy :: KProxy Foo) where + instance PMyOrd (Proxy :: Proxy Foo) where type Mycompare (a :: Foo) (a :: Foo) = Apply (Apply Mycompare_0123456789Sym0 a) a type family TFHelper_0123456789 (a :: Foo2) (a :: Foo2) :: Bool where @@ -267,7 +267,7 @@ = forall arg. KindOf (Apply TFHelper_0123456789Sym0 arg) ~ KindOf (TFHelper_0123456789Sym1 arg) => TFHelper_0123456789Sym0KindInference type instance Apply TFHelper_0123456789Sym0 l = TFHelper_0123456789Sym1 l - instance PEq (KProxy :: KProxy Foo2) where + instance PEq (Proxy :: Proxy Foo2) where type (:==) (a :: Foo2) (a :: Foo2) = Apply (Apply TFHelper_0123456789Sym0 a) a infix 4 %:<=> sFooCompare :: @@ -316,21 +316,21 @@ in lambda sX _s_z_0123456789 data instance Sing (z :: Foo) = z ~ A => SA | z ~ B => SB type SFoo = (Sing :: Foo -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy Foo) where - type DemoteRep (KProxy :: KProxy Foo) = Foo + instance SingKind Foo where + type DemoteRep Foo = Foo fromSing SA = A fromSing SB = B toSing A = SomeSing SA toSing B = SomeSing SB data instance Sing (z :: Foo2) = z ~ F => SF | z ~ G => SG type SFoo2 = (Sing :: Foo2 -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy Foo2) where - type DemoteRep (KProxy :: KProxy Foo2) = Foo2 + instance SingKind Foo2 where + type DemoteRep Foo2 = Foo2 fromSing SF = F fromSing SG = G toSing F = SomeSing SF toSing G = SomeSing SG - class kproxy ~ KProxy => SMyOrd (kproxy :: KProxy a) where + class SMyOrd a where sMycompare :: forall (t :: a) (t :: a). Sing t @@ -356,7 +356,7 @@ (singFun2 (Proxy :: Proxy MycompareSym0) sMycompare) a_0123456789) a_0123456789 in lambda sA_0123456789 sA_0123456789 - instance SMyOrd (KProxy :: KProxy Nat) where + instance SMyOrd Nat where sMycompare :: forall (t :: Nat) (t :: Nat). Sing t @@ -398,7 +398,7 @@ (applySing (singFun2 (Proxy :: Proxy MycompareSym0) sMycompare) m) n in lambda sN sM - instance SMyOrd (KProxy :: KProxy ()) where + instance SMyOrd () where sMycompare :: forall (t :: ()) (t :: ()). Sing t @@ -416,7 +416,7 @@ (applySing (singFun2 (Proxy :: Proxy ConstSym0) sConst) SEQ) a_0123456789 in lambda _s_z_0123456789 sA_0123456789 - instance SMyOrd (KProxy :: KProxy Foo) where + instance SMyOrd Foo where sMycompare :: forall (t :: Foo) (t :: Foo). Sing t @@ -436,7 +436,7 @@ a_0123456789) a_0123456789 in lambda sA_0123456789 sA_0123456789 - instance SEq (KProxy :: KProxy Foo2) where + instance SEq Foo2 where (%:==) :: forall (a :: Foo2) (b :: Foo2). Sing a -> Sing b -> Sing ((:==) a b) @@ -512,7 +512,7 @@ = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) => Mycompare_0123456789Sym0KindInference type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l - instance PMyOrd (KProxy :: KProxy Foo2) where + instance PMyOrd (Proxy :: Proxy Foo2) where type Mycompare (a :: Foo2) (a :: Foo2) = Apply (Apply Mycompare_0123456789Sym0 a) a type family Compare_0123456789 (a :: Foo2) (a :: Foo2) :: Ordering where @@ -538,7 +538,7 @@ = forall arg. KindOf (Apply Compare_0123456789Sym0 arg) ~ KindOf (Compare_0123456789Sym1 arg) => Compare_0123456789Sym0KindInference type instance Apply Compare_0123456789Sym0 l = Compare_0123456789Sym1 l - instance POrd (KProxy :: KProxy Foo2) where + instance POrd (Proxy :: Proxy Foo2) where type Compare (a :: Foo2) (a :: Foo2) = Apply (Apply Compare_0123456789Sym0 a) a Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations singletons @@ -591,21 +591,21 @@ = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) => Mycompare_0123456789Sym0KindInference type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l - instance PMyOrd (KProxy :: KProxy Nat') where + instance PMyOrd (Proxy :: Proxy Nat') where type Mycompare (a :: Nat') (a :: Nat') = Apply (Apply Mycompare_0123456789Sym0 a) a data instance Sing (z :: Nat') = z ~ Zero' => SZero' | forall (n :: Nat'). z ~ Succ' n => SSucc' (Sing (n :: Nat')) type SNat' = (Sing :: Nat' -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy Nat') where - type DemoteRep (KProxy :: KProxy Nat') = Nat' + instance SingKind Nat' where + type DemoteRep Nat' = Nat' fromSing SZero' = Zero' fromSing (SSucc' b) = Succ' (fromSing b) toSing Zero' = SomeSing SZero' toSing (Succ' b) - = case toSing b :: SomeSing (KProxy :: KProxy Nat') of { + = case toSing b :: SomeSing Nat' of { SomeSing c -> SomeSing (SSucc' c) } - instance SMyOrd (KProxy :: KProxy Nat') where + instance SMyOrd Nat' where sMycompare :: forall (t :: Nat') (t :: Nat'). Sing t diff --git a/tests/compile-and-dump/Singletons/Classes2.ghc710.template b/tests/compile-and-dump/Singletons/Classes2.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/Classes2.ghc710.template +++ /dev/null @@ -1,115 +0,0 @@ -Singletons/Classes2.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| data NatFoo = ZeroFoo | SuccFoo NatFoo - - instance MyOrd NatFoo where - ZeroFoo `mycompare` ZeroFoo = EQ - ZeroFoo `mycompare` (SuccFoo _) = LT - (SuccFoo _) `mycompare` ZeroFoo = GT - (SuccFoo n) `mycompare` (SuccFoo m) = m `mycompare` n |] - ======> - data NatFoo = ZeroFoo | SuccFoo NatFoo - instance MyOrd NatFoo where - mycompare ZeroFoo ZeroFoo = EQ - mycompare ZeroFoo (SuccFoo _) = LT - mycompare (SuccFoo _) ZeroFoo = GT - mycompare (SuccFoo n) (SuccFoo m) = (m `mycompare` n) - type ZeroFooSym0 = ZeroFoo - type SuccFooSym1 (t :: NatFoo) = SuccFoo t - instance SuppressUnusedWarnings SuccFooSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) SuccFooSym0KindInference GHC.Tuple.()) - data SuccFooSym0 (l :: TyFun NatFoo NatFoo) - = forall arg. KindOf (Apply SuccFooSym0 arg) ~ KindOf (SuccFooSym1 arg) => - SuccFooSym0KindInference - type instance Apply SuccFooSym0 l = SuccFooSym1 l - type family Mycompare_0123456789 (a :: NatFoo) - (a :: NatFoo) :: Ordering where - Mycompare_0123456789 ZeroFoo ZeroFoo = EQSym0 - Mycompare_0123456789 ZeroFoo (SuccFoo _z_0123456789) = LTSym0 - Mycompare_0123456789 (SuccFoo _z_0123456789) ZeroFoo = GTSym0 - Mycompare_0123456789 (SuccFoo n) (SuccFoo m) = Apply (Apply MycompareSym0 m) n - type Mycompare_0123456789Sym2 (t :: NatFoo) (t :: NatFoo) = - Mycompare_0123456789 t t - instance SuppressUnusedWarnings Mycompare_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Mycompare_0123456789Sym1KindInference GHC.Tuple.()) - data Mycompare_0123456789Sym1 (l :: NatFoo) - (l :: TyFun NatFoo Ordering) - = forall arg. KindOf (Apply (Mycompare_0123456789Sym1 l) arg) ~ KindOf (Mycompare_0123456789Sym2 l arg) => - Mycompare_0123456789Sym1KindInference - type instance Apply (Mycompare_0123456789Sym1 l) l = Mycompare_0123456789Sym2 l l - instance SuppressUnusedWarnings Mycompare_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Mycompare_0123456789Sym0KindInference GHC.Tuple.()) - data Mycompare_0123456789Sym0 (l :: TyFun NatFoo (TyFun NatFoo Ordering - -> *)) - = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) => - Mycompare_0123456789Sym0KindInference - type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l - instance PMyOrd (KProxy :: KProxy NatFoo) where - type Mycompare (a :: NatFoo) (a :: NatFoo) = Apply (Apply Mycompare_0123456789Sym0 a) a - data instance Sing (z :: NatFoo) - = z ~ ZeroFoo => SZeroFoo | - forall (n :: NatFoo). z ~ SuccFoo n => - SSuccFoo (Sing (n :: NatFoo)) - type SNatFoo = (Sing :: NatFoo -> *) - instance SingKind (KProxy :: KProxy NatFoo) where - type DemoteRep (KProxy :: KProxy NatFoo) = NatFoo - fromSing SZeroFoo = ZeroFoo - fromSing (SSuccFoo b) = SuccFoo (fromSing b) - toSing ZeroFoo = SomeSing SZeroFoo - toSing (SuccFoo b) - = case toSing b :: SomeSing (KProxy :: KProxy NatFoo) of { - SomeSing c -> SomeSing (SSuccFoo c) } - instance SMyOrd (KProxy :: KProxy NatFoo) where - sMycompare :: - forall (t0 :: NatFoo) (t1 :: NatFoo). - Sing t0 - -> Sing t1 - -> Sing (Apply (Apply (MycompareSym0 :: TyFun NatFoo (TyFun NatFoo Ordering - -> *) - -> *) t0 :: TyFun NatFoo Ordering - -> *) t1 :: Ordering) - sMycompare SZeroFoo SZeroFoo - = let - lambda :: - (t0 ~ ZeroFooSym0, t1 ~ ZeroFooSym0) => - Sing (Apply (Apply MycompareSym0 t0) t1 :: Ordering) - lambda = SEQ - in lambda - sMycompare SZeroFoo (SSuccFoo _s_z_0123456789) - = let - lambda :: - forall _z_0123456789. (t0 ~ ZeroFooSym0, - t1 ~ Apply SuccFooSym0 _z_0123456789) => - Sing _z_0123456789 - -> Sing (Apply (Apply MycompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 = SLT - in lambda _s_z_0123456789 - sMycompare (SSuccFoo _s_z_0123456789) SZeroFoo - = let - lambda :: - forall _z_0123456789. (t0 ~ Apply SuccFooSym0 _z_0123456789, - t1 ~ ZeroFooSym0) => - Sing _z_0123456789 - -> Sing (Apply (Apply MycompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 = SGT - in lambda _s_z_0123456789 - sMycompare (SSuccFoo sN) (SSuccFoo sM) - = let - lambda :: - forall n m. (t0 ~ Apply SuccFooSym0 n, t1 ~ Apply SuccFooSym0 m) => - Sing n - -> Sing m -> Sing (Apply (Apply MycompareSym0 t0) t1 :: Ordering) - lambda n m - = applySing - (applySing (singFun2 (Proxy :: Proxy MycompareSym0) sMycompare) m) - n - in lambda sN sM - instance SingI ZeroFoo where - sing = SZeroFoo - instance SingI n => SingI (SuccFoo (n :: NatFoo)) where - sing = SSuccFoo sing diff --git a/tests/compile-and-dump/Singletons/Classes2.ghc80.template b/tests/compile-and-dump/Singletons/Classes2.ghc80.template --- a/tests/compile-and-dump/Singletons/Classes2.ghc80.template +++ b/tests/compile-and-dump/Singletons/Classes2.ghc80.template @@ -49,22 +49,22 @@ = forall arg. KindOf (Apply Mycompare_0123456789Sym0 arg) ~ KindOf (Mycompare_0123456789Sym1 arg) => Mycompare_0123456789Sym0KindInference type instance Apply Mycompare_0123456789Sym0 l = Mycompare_0123456789Sym1 l - instance PMyOrd (KProxy :: KProxy NatFoo) where + instance PMyOrd (Proxy :: Proxy NatFoo) where type Mycompare (a :: NatFoo) (a :: NatFoo) = Apply (Apply Mycompare_0123456789Sym0 a) a data instance Sing (z :: NatFoo) = z ~ ZeroFoo => SZeroFoo | forall (n :: NatFoo). z ~ SuccFoo n => SSuccFoo (Sing (n :: NatFoo)) type SNatFoo = (Sing :: NatFoo -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy NatFoo) where - type DemoteRep (KProxy :: KProxy NatFoo) = NatFoo + instance SingKind NatFoo where + type DemoteRep NatFoo = NatFoo fromSing SZeroFoo = ZeroFoo fromSing (SSuccFoo b) = SuccFoo (fromSing b) toSing ZeroFoo = SomeSing SZeroFoo toSing (SuccFoo b) - = case toSing b :: SomeSing (KProxy :: KProxy NatFoo) of { + = case toSing b :: SomeSing NatFoo of { SomeSing c -> SomeSing (SSuccFoo c) } - instance SMyOrd (KProxy :: KProxy NatFoo) where + instance SMyOrd NatFoo where sMycompare :: forall (t0 :: NatFoo) (t1 :: NatFoo). Sing t0 diff --git a/tests/compile-and-dump/Singletons/Contains.ghc710.template b/tests/compile-and-dump/Singletons/Contains.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/Contains.ghc710.template +++ /dev/null @@ -1,57 +0,0 @@ -Singletons/Contains.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| contains :: Eq a => a -> [a] -> Bool - contains _ [] = False - contains elt (h : t) = (elt == h) || (contains elt t) |] - ======> - contains :: forall a. Eq a => a -> [a] -> Bool - contains _ GHC.Types.[] = False - contains elt (h GHC.Types.: t) = ((elt == h) || (contains elt t)) - type ContainsSym2 (t :: a0123456789) (t :: [a0123456789]) = - Contains t t - instance SuppressUnusedWarnings ContainsSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ContainsSym1KindInference GHC.Tuple.()) - data ContainsSym1 (l :: a0123456789) - (l :: TyFun [a0123456789] Bool) - = forall arg. KindOf (Apply (ContainsSym1 l) arg) ~ KindOf (ContainsSym2 l arg) => - ContainsSym1KindInference - type instance Apply (ContainsSym1 l) l = ContainsSym2 l l - instance SuppressUnusedWarnings ContainsSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ContainsSym0KindInference GHC.Tuple.()) - data ContainsSym0 (l :: TyFun a0123456789 (TyFun [a0123456789] Bool - -> *)) - = forall arg. KindOf (Apply ContainsSym0 arg) ~ KindOf (ContainsSym1 arg) => - ContainsSym0KindInference - type instance Apply ContainsSym0 l = ContainsSym1 l - type family Contains (a :: a) (a :: [a]) :: Bool where - Contains _z_0123456789 '[] = FalseSym0 - Contains elt ((:) h t) = Apply (Apply (:||$) (Apply (Apply (:==$) elt) h)) (Apply (Apply ContainsSym0 elt) t) - sContains :: - forall (t :: a) (t :: [a]). SEq (KProxy :: KProxy a) => - Sing t -> Sing t -> Sing (Apply (Apply ContainsSym0 t) t :: Bool) - sContains _s_z_0123456789 SNil - = let - lambda :: - forall _z_0123456789. (t ~ _z_0123456789, t ~ '[]) => - Sing _z_0123456789 -> Sing (Apply (Apply ContainsSym0 t) t :: Bool) - lambda _z_0123456789 = SFalse - in lambda _s_z_0123456789 - sContains sElt (SCons sH sT) - = let - lambda :: - forall elt h t. (t ~ elt, t ~ Apply (Apply (:$) h) t) => - Sing elt - -> Sing h - -> Sing t -> Sing (Apply (Apply ContainsSym0 t) t :: Bool) - lambda elt h t - = applySing - (applySing - (singFun2 (Proxy :: Proxy (:||$)) (%:||)) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) elt) h)) - (applySing - (applySing (singFun2 (Proxy :: Proxy ContainsSym0) sContains) elt) - t) - in lambda sElt sH sT diff --git a/tests/compile-and-dump/Singletons/Contains.ghc80.template b/tests/compile-and-dump/Singletons/Contains.ghc80.template --- a/tests/compile-and-dump/Singletons/Contains.ghc80.template +++ b/tests/compile-and-dump/Singletons/Contains.ghc80.template @@ -30,7 +30,7 @@ Contains elt ((:) h t) = Apply (Apply (:||$) (Apply (Apply (:==$) elt) h)) (Apply (Apply ContainsSym0 elt) t) sContains :: forall (t :: a) (t :: [a]). - SEq (KProxy :: KProxy a) => + SEq a => Sing t -> Sing t -> Sing (Apply (Apply ContainsSym0 t) t :: Bool) sContains _s_z_0123456789 SNil = let diff --git a/tests/compile-and-dump/Singletons/DataValues.ghc710.template b/tests/compile-and-dump/Singletons/DataValues.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/DataValues.ghc710.template +++ /dev/null @@ -1,106 +0,0 @@ -Singletons/DataValues.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| pr = Pair (Succ Zero) ([Zero]) - complex = Pair (Pair (Just Zero) Zero) False - tuple = (False, Just Zero, True) - aList = [Zero, Succ Zero, Succ (Succ Zero)] - - data Pair a b - = Pair a b - deriving (Show) |] - ======> - data Pair a b - = Pair a b - deriving (Show) - pr = Pair (Succ Zero) [Zero] - complex = Pair (Pair (Just Zero) Zero) False - tuple = (False, Just Zero, True) - aList = [Zero, Succ Zero, Succ (Succ Zero)] - type PairSym2 (t :: a0123456789) (t :: b0123456789) = Pair t t - instance SuppressUnusedWarnings PairSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) PairSym1KindInference GHC.Tuple.()) - data PairSym1 (l :: a0123456789) - (l :: TyFun b0123456789 (Pair a0123456789 b0123456789)) - = forall arg. KindOf (Apply (PairSym1 l) arg) ~ KindOf (PairSym2 l arg) => - PairSym1KindInference - type instance Apply (PairSym1 l) l = PairSym2 l l - instance SuppressUnusedWarnings PairSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) PairSym0KindInference GHC.Tuple.()) - data PairSym0 (l :: TyFun a0123456789 (TyFun b0123456789 (Pair a0123456789 b0123456789) - -> *)) - = forall arg. KindOf (Apply PairSym0 arg) ~ KindOf (PairSym1 arg) => - PairSym0KindInference - type instance Apply PairSym0 l = PairSym1 l - type AListSym0 = AList - type TupleSym0 = Tuple - type ComplexSym0 = Complex - type PrSym0 = Pr - type family AList where - AList = Apply (Apply (:$) ZeroSym0) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:$) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))) '[])) - type family Tuple where - Tuple = Apply (Apply (Apply Tuple3Sym0 FalseSym0) (Apply JustSym0 ZeroSym0)) TrueSym0 - type family Complex where - 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) '[]) - sAList :: Sing AListSym0 - sTuple :: Sing TupleSym0 - sComplex :: Sing ComplexSym0 - sPr :: Sing PrSym0 - sAList - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (singFun1 (Proxy :: Proxy SuccSym0) SSucc) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))) - SNil)) - sTuple - = applySing - (applySing - (applySing (singFun3 (Proxy :: Proxy Tuple3Sym0) STuple3) SFalse) - (applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) SZero)) - STrue - sComplex - = applySing - (applySing - (singFun2 (Proxy :: Proxy PairSym0) SPair) - (applySing - (applySing - (singFun2 (Proxy :: Proxy PairSym0) SPair) - (applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) SZero)) - SZero)) - SFalse - sPr - = applySing - (applySing - (singFun2 (Proxy :: Proxy PairSym0) SPair) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero) SNil) - data instance Sing (z :: Pair a b) - = forall (n :: a) (n :: b). z ~ Pair n n => - SPair (Sing (n :: a)) (Sing (n :: b)) - type SPair = (Sing :: Pair a b -> *) - instance (SingKind (KProxy :: KProxy a), - SingKind (KProxy :: KProxy b)) => - SingKind (KProxy :: KProxy (Pair a b)) where - type DemoteRep (KProxy :: KProxy (Pair a b)) = Pair (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b)) - fromSing (SPair b b) = Pair (fromSing b) (fromSing b) - toSing (Pair b b) - = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) - of { - GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SPair c c) } - instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where - sing = SPair sing sing diff --git a/tests/compile-and-dump/Singletons/DataValues.ghc80.template b/tests/compile-and-dump/Singletons/DataValues.ghc80.template --- a/tests/compile-and-dump/Singletons/DataValues.ghc80.template +++ b/tests/compile-and-dump/Singletons/DataValues.ghc80.template @@ -90,16 +90,12 @@ = forall (n :: a) (n :: b). z ~ Pair n n => SPair (Sing (n :: a)) (Sing (n :: b)) type SPair = (Sing :: Pair a b -> GHC.Types.Type) - instance (SingKind (KProxy :: KProxy a), - SingKind (KProxy :: KProxy b)) => - SingKind (KProxy :: KProxy (Pair a b)) where - type DemoteRep (KProxy :: KProxy (Pair a b)) = Pair (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b)) + instance (SingKind a, SingKind b) => SingKind (Pair a b) where + type DemoteRep (Pair a b) = Pair (DemoteRep a) (DemoteRep b) fromSing (SPair b b) = Pair (fromSing b) (fromSing b) toSing (Pair b b) = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) + GHC.Tuple.(,) (toSing b :: SomeSing a) (toSing b :: SomeSing b) of { GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SPair c c) } instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where diff --git a/tests/compile-and-dump/Singletons/Empty.ghc710.template b/tests/compile-and-dump/Singletons/Empty.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/Empty.ghc710.template +++ /dev/null @@ -1,14 +0,0 @@ -Singletons/Empty.hs:(0,0)-(0,0): Splicing declarations - singletons [d| data Empty |] - ======> - data Empty - data instance Sing (z :: Empty) - type SEmpty = (Sing :: Empty -> *) - instance SingKind (KProxy :: KProxy Empty) where - type DemoteRep (KProxy :: KProxy Empty) = Empty - fromSing z - = case z of { - _ -> error "Empty case reached -- this should be impossible" } - toSing z - = case z of { - _ -> error "Empty case reached -- this should be impossible" } diff --git a/tests/compile-and-dump/Singletons/Empty.ghc80.template b/tests/compile-and-dump/Singletons/Empty.ghc80.template --- a/tests/compile-and-dump/Singletons/Empty.ghc80.template +++ b/tests/compile-and-dump/Singletons/Empty.ghc80.template @@ -4,8 +4,8 @@ data Empty data instance Sing (z :: Empty) type SEmpty = (Sing :: Empty -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy Empty) where - type DemoteRep (KProxy :: KProxy Empty) = Empty + instance SingKind Empty where + type DemoteRep Empty = Empty fromSing z = case z of { _ -> error "Empty case reached -- this should be impossible" } diff --git a/tests/compile-and-dump/Singletons/EnumDeriving.ghc710.template b/tests/compile-and-dump/Singletons/EnumDeriving.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/EnumDeriving.ghc710.template +++ /dev/null @@ -1,284 +0,0 @@ -Singletons/EnumDeriving.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| data Foo - = Bar | Baz | Bum - deriving (Enum) - data Quux = Q1 | Q2 |] - ======> - data Foo - = Bar | Baz | Bum - deriving (Enum) - data Quux = Q1 | Q2 - type BarSym0 = Bar - type BazSym0 = Baz - type BumSym0 = Bum - type Q1Sym0 = Q1 - type Q2Sym0 = Q2 - type family Case_0123456789 n t where - Case_0123456789 n True = BumSym0 - Case_0123456789 n False = Apply ErrorSym0 "toEnum: bad argument" - type family Case_0123456789 n t where - Case_0123456789 n True = BazSym0 - Case_0123456789 n False = Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 2)) - type family Case_0123456789 n t where - Case_0123456789 n True = BarSym0 - Case_0123456789 n False = Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 1)) - type family ToEnum_0123456789 (a :: GHC.TypeLits.Nat) :: Foo where - ToEnum_0123456789 n = Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 0)) - type ToEnum_0123456789Sym1 (t :: GHC.TypeLits.Nat) = - ToEnum_0123456789 t - instance SuppressUnusedWarnings ToEnum_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) ToEnum_0123456789Sym0KindInference GHC.Tuple.()) - data ToEnum_0123456789Sym0 (l :: TyFun GHC.TypeLits.Nat Foo) - = forall arg. KindOf (Apply ToEnum_0123456789Sym0 arg) ~ KindOf (ToEnum_0123456789Sym1 arg) => - ToEnum_0123456789Sym0KindInference - type instance Apply ToEnum_0123456789Sym0 l = ToEnum_0123456789Sym1 l - type family FromEnum_0123456789 (a :: Foo) :: GHC.TypeLits.Nat where - FromEnum_0123456789 Bar = FromInteger 0 - FromEnum_0123456789 Baz = FromInteger 1 - FromEnum_0123456789 Bum = FromInteger 2 - type FromEnum_0123456789Sym1 (t :: Foo) = FromEnum_0123456789 t - instance SuppressUnusedWarnings FromEnum_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) FromEnum_0123456789Sym0KindInference GHC.Tuple.()) - data FromEnum_0123456789Sym0 (l :: TyFun Foo GHC.TypeLits.Nat) - = forall arg. KindOf (Apply FromEnum_0123456789Sym0 arg) ~ KindOf (FromEnum_0123456789Sym1 arg) => - FromEnum_0123456789Sym0KindInference - type instance Apply FromEnum_0123456789Sym0 l = FromEnum_0123456789Sym1 l - instance PEnum (KProxy :: KProxy Foo) where - type ToEnum (a :: GHC.TypeLits.Nat) = Apply ToEnum_0123456789Sym0 a - type FromEnum (a :: Foo) = Apply FromEnum_0123456789Sym0 a - data instance Sing (z :: Foo) - = z ~ Bar => SBar | z ~ Baz => SBaz | z ~ Bum => SBum - type SFoo = (Sing :: Foo -> *) - instance SingKind (KProxy :: KProxy Foo) where - type DemoteRep (KProxy :: KProxy Foo) = Foo - fromSing SBar = Bar - fromSing SBaz = Baz - fromSing SBum = Bum - toSing Bar = SomeSing SBar - toSing Baz = SomeSing SBaz - toSing Bum = SomeSing SBum - data instance Sing (z :: Quux) = z ~ Q1 => SQ1 | z ~ Q2 => SQ2 - type SQuux = (Sing :: Quux -> *) - instance SingKind (KProxy :: KProxy Quux) where - type DemoteRep (KProxy :: KProxy Quux) = Quux - fromSing SQ1 = Q1 - fromSing SQ2 = Q2 - toSing Q1 = SomeSing SQ1 - toSing Q2 = SomeSing SQ2 - instance SEnum (KProxy :: KProxy Foo) where - sToEnum :: - forall (t0 :: GHC.TypeLits.Nat). - Sing t0 - -> Sing (Apply (ToEnumSym0 :: TyFun GHC.TypeLits.Nat Foo - -> *) t0 :: Foo) - sFromEnum :: - forall (t0 :: Foo). - Sing t0 - -> Sing (Apply (FromEnumSym0 :: TyFun Foo GHC.TypeLits.Nat - -> *) t0 :: GHC.TypeLits.Nat) - sToEnum sN - = let - lambda :: - forall n. t0 ~ n => Sing n -> Sing (Apply ToEnumSym0 t0 :: Foo) - lambda n - = case - applySing - (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) n) - (sFromInteger (sing :: Sing 0)) - of { - STrue - -> let - lambda :: - TrueSym0 ~ Apply (Apply (:==$) n) (FromInteger 0) => - Sing (Case_0123456789 n TrueSym0 :: Foo) - lambda = SBar - in lambda - SFalse - -> let - lambda :: - FalseSym0 ~ Apply (Apply (:==$) n) (FromInteger 0) => - Sing (Case_0123456789 n FalseSym0 :: Foo) - lambda - = case - applySing - (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) n) - (sFromInteger (sing :: Sing 1)) - of { - STrue - -> let - lambda :: - TrueSym0 ~ Apply (Apply (:==$) n) (FromInteger 1) => - Sing (Case_0123456789 n TrueSym0 :: Foo) - lambda = SBaz - in lambda - SFalse - -> let - lambda :: - FalseSym0 ~ Apply (Apply (:==$) n) (FromInteger 1) => - Sing (Case_0123456789 n FalseSym0 :: Foo) - lambda - = case - applySing - (applySing - (singFun2 (Proxy :: Proxy (:==$)) (%:==)) n) - (sFromInteger (sing :: Sing 2)) - of { - STrue - -> let - lambda :: - TrueSym0 ~ Apply (Apply (:==$) n) (FromInteger 2) => - Sing (Case_0123456789 n TrueSym0 :: Foo) - lambda = SBum - in lambda - SFalse - -> let - lambda :: - FalseSym0 ~ Apply (Apply (:==$) n) (FromInteger 2) => - Sing (Case_0123456789 n FalseSym0 :: Foo) - lambda - = sError (sing :: Sing "toEnum: bad argument") - in lambda } :: - Sing (Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 2)) :: Foo) - in lambda } :: - Sing (Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 1)) :: Foo) - in lambda } :: - Sing (Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 0)) :: Foo) - in lambda sN - sFromEnum SBar - = let - lambda :: - t0 ~ BarSym0 => Sing (Apply FromEnumSym0 t0 :: GHC.TypeLits.Nat) - lambda = sFromInteger (sing :: Sing 0) - in lambda - sFromEnum SBaz - = let - lambda :: - t0 ~ BazSym0 => Sing (Apply FromEnumSym0 t0 :: GHC.TypeLits.Nat) - lambda = sFromInteger (sing :: Sing 1) - in lambda - sFromEnum SBum - = let - lambda :: - t0 ~ BumSym0 => Sing (Apply FromEnumSym0 t0 :: GHC.TypeLits.Nat) - lambda = sFromInteger (sing :: Sing 2) - in lambda - instance SingI Bar where - sing = SBar - instance SingI Baz where - sing = SBaz - instance SingI Bum where - sing = SBum - instance SingI Q1 where - sing = SQ1 - instance SingI Q2 where - sing = SQ2 -Singletons/EnumDeriving.hs:0:0:: Splicing declarations - singEnumInstance ''Quux - ======> - type family Case_0123456789 n t where - Case_0123456789 n True = Q2Sym0 - Case_0123456789 n False = Apply ErrorSym0 "toEnum: bad argument" - type family Case_0123456789 n t where - Case_0123456789 n True = Q1Sym0 - Case_0123456789 n False = Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 1)) - type family ToEnum_0123456789 (a :: GHC.TypeLits.Nat) :: Quux where - ToEnum_0123456789 n = Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 0)) - type ToEnum_0123456789Sym1 (t :: GHC.TypeLits.Nat) = - ToEnum_0123456789 t - instance SuppressUnusedWarnings ToEnum_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) ToEnum_0123456789Sym0KindInference GHC.Tuple.()) - data ToEnum_0123456789Sym0 (l :: TyFun GHC.TypeLits.Nat Quux) - = forall arg. KindOf (Apply ToEnum_0123456789Sym0 arg) ~ KindOf (ToEnum_0123456789Sym1 arg) => - ToEnum_0123456789Sym0KindInference - type instance Apply ToEnum_0123456789Sym0 l = ToEnum_0123456789Sym1 l - type family FromEnum_0123456789 (a :: Quux) :: GHC.TypeLits.Nat where - FromEnum_0123456789 Q1 = FromInteger 0 - FromEnum_0123456789 Q2 = FromInteger 1 - type FromEnum_0123456789Sym1 (t :: Quux) = FromEnum_0123456789 t - instance SuppressUnusedWarnings FromEnum_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) FromEnum_0123456789Sym0KindInference GHC.Tuple.()) - data FromEnum_0123456789Sym0 (l :: TyFun Quux GHC.TypeLits.Nat) - = forall arg. KindOf (Apply FromEnum_0123456789Sym0 arg) ~ KindOf (FromEnum_0123456789Sym1 arg) => - FromEnum_0123456789Sym0KindInference - type instance Apply FromEnum_0123456789Sym0 l = FromEnum_0123456789Sym1 l - instance PEnum (KProxy :: KProxy Quux) where - type ToEnum (a :: GHC.TypeLits.Nat) = Apply ToEnum_0123456789Sym0 a - type FromEnum (a :: Quux) = Apply FromEnum_0123456789Sym0 a - instance SEnum (KProxy :: KProxy Quux) where - sToEnum :: - forall (t0 :: GHC.TypeLits.Nat). - Sing t0 - -> Sing (Apply (ToEnumSym0 :: TyFun GHC.TypeLits.Nat Quux - -> *) t0 :: Quux) - sFromEnum :: - forall (t0 :: Quux). - Sing t0 - -> Sing (Apply (FromEnumSym0 :: TyFun Quux GHC.TypeLits.Nat - -> *) t0 :: GHC.TypeLits.Nat) - sToEnum sN - = let - lambda :: - forall n. t0 ~ n => Sing n -> Sing (Apply ToEnumSym0 t0 :: Quux) - lambda n - = case - applySing - (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) n) - (sFromInteger (sing :: Sing 0)) - of { - STrue - -> let - lambda :: - TrueSym0 ~ Apply (Apply (:==$) n) (FromInteger 0) => - Sing (Case_0123456789 n TrueSym0 :: Quux) - lambda = SQ1 - in lambda - SFalse - -> let - lambda :: - FalseSym0 ~ Apply (Apply (:==$) n) (FromInteger 0) => - Sing (Case_0123456789 n FalseSym0 :: Quux) - lambda - = case - applySing - (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) n) - (sFromInteger (sing :: Sing 1)) - of { - STrue - -> let - lambda :: - TrueSym0 ~ Apply (Apply (:==$) n) (FromInteger 1) => - Sing (Case_0123456789 n TrueSym0 :: Quux) - lambda = SQ2 - in lambda - SFalse - -> let - lambda :: - FalseSym0 ~ Apply (Apply (:==$) n) (FromInteger 1) => - Sing (Case_0123456789 n FalseSym0 :: Quux) - lambda = sError (sing :: Sing "toEnum: bad argument") - in lambda } :: - Sing (Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 1)) :: Quux) - in lambda } :: - Sing (Case_0123456789 n (Apply (Apply (:==$) n) (FromInteger 0)) :: Quux) - in lambda sN - sFromEnum SQ1 - = let - lambda :: - t0 ~ Q1Sym0 => Sing (Apply FromEnumSym0 t0 :: GHC.TypeLits.Nat) - lambda = sFromInteger (sing :: Sing 0) - in lambda - sFromEnum SQ2 - = let - lambda :: - t0 ~ Q2Sym0 => Sing (Apply FromEnumSym0 t0 :: GHC.TypeLits.Nat) - lambda = sFromInteger (sing :: Sing 1) - in lambda diff --git a/tests/compile-and-dump/Singletons/EnumDeriving.ghc80.template b/tests/compile-and-dump/Singletons/EnumDeriving.ghc80.template --- a/tests/compile-and-dump/Singletons/EnumDeriving.ghc80.template +++ b/tests/compile-and-dump/Singletons/EnumDeriving.ghc80.template @@ -48,14 +48,14 @@ = forall arg. KindOf (Apply FromEnum_0123456789Sym0 arg) ~ KindOf (FromEnum_0123456789Sym1 arg) => FromEnum_0123456789Sym0KindInference type instance Apply FromEnum_0123456789Sym0 l = FromEnum_0123456789Sym1 l - instance PEnum (KProxy :: KProxy Foo) where + instance PEnum (Proxy :: Proxy Foo) where type ToEnum (a :: GHC.Types.Nat) = Apply ToEnum_0123456789Sym0 a type FromEnum (a :: Foo) = Apply FromEnum_0123456789Sym0 a data instance Sing (z :: Foo) = z ~ Bar => SBar | z ~ Baz => SBaz | z ~ Bum => SBum type SFoo = (Sing :: Foo -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy Foo) where - type DemoteRep (KProxy :: KProxy Foo) = Foo + instance SingKind Foo where + type DemoteRep Foo = Foo fromSing SBar = Bar fromSing SBaz = Baz fromSing SBum = Bum @@ -64,13 +64,13 @@ toSing Bum = SomeSing SBum data instance Sing (z :: Quux) = z ~ Q1 => SQ1 | z ~ Q2 => SQ2 type SQuux = (Sing :: Quux -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy Quux) where - type DemoteRep (KProxy :: KProxy Quux) = Quux + instance SingKind Quux where + type DemoteRep Quux = Quux fromSing SQ1 = Q1 fromSing SQ2 = Q2 toSing Q1 = SomeSing SQ1 toSing Q2 = SomeSing SQ2 - instance SEnum (KProxy :: KProxy Foo) where + instance SEnum Foo where sToEnum :: forall (t0 :: GHC.Types.Nat). Sing t0 @@ -210,10 +210,10 @@ = forall arg. KindOf (Apply FromEnum_0123456789Sym0 arg) ~ KindOf (FromEnum_0123456789Sym1 arg) => FromEnum_0123456789Sym0KindInference type instance Apply FromEnum_0123456789Sym0 l = FromEnum_0123456789Sym1 l - instance PEnum (KProxy :: KProxy Quux) where + instance PEnum (Proxy :: Proxy Quux) where type ToEnum (a :: GHC.Types.Nat) = Apply ToEnum_0123456789Sym0 a type FromEnum (a :: Quux) = Apply FromEnum_0123456789Sym0 a - instance SEnum (KProxy :: KProxy Quux) where + instance SEnum Quux where sToEnum :: forall (t0 :: GHC.Types.Nat). Sing t0 diff --git a/tests/compile-and-dump/Singletons/EqInstances.ghc710.template b/tests/compile-and-dump/Singletons/EqInstances.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/EqInstances.ghc710.template +++ /dev/null @@ -1,23 +0,0 @@ -Singletons/EqInstances.hs:0:0:: Splicing declarations - singEqInstances [''Foo, ''Empty] - ======> - instance SEq (KProxy :: KProxy Foo) where - (%:==) SFLeaf SFLeaf = STrue - (%:==) SFLeaf ((:%+:) _ _) = SFalse - (%:==) ((:%+:) _ _) SFLeaf = SFalse - (%:==) ((:%+:) a a) ((:%+:) b b) = (%:&&) ((%:==) a b) ((%:==) a b) - type family Equals_0123456789 (a :: Foo) (b :: Foo) :: Bool where - Equals_0123456789 FLeaf FLeaf = TrueSym0 - Equals_0123456789 ((:+:) a a) ((:+:) b b) = (:&&) ((:==) a b) ((:==) a b) - Equals_0123456789 (a :: Foo) (b :: Foo) = FalseSym0 - instance PEq (KProxy :: KProxy Foo) where - type (:==) (a :: Foo) (b :: Foo) = Equals_0123456789 a b - instance SEq (KProxy :: KProxy Empty) where - (%:==) a _ - = case a of { - _ -> error "Empty case reached -- this should be impossible" } - type family Equals_0123456789 (a :: Empty) - (b :: Empty) :: Bool where - Equals_0123456789 (a :: Empty) (b :: Empty) = FalseSym0 - instance PEq (KProxy :: KProxy Empty) where - type (:==) (a :: Empty) (b :: Empty) = Equals_0123456789 a b diff --git a/tests/compile-and-dump/Singletons/EqInstances.ghc80.template b/tests/compile-and-dump/Singletons/EqInstances.ghc80.template --- a/tests/compile-and-dump/Singletons/EqInstances.ghc80.template +++ b/tests/compile-and-dump/Singletons/EqInstances.ghc80.template @@ -1,7 +1,7 @@ Singletons/EqInstances.hs:0:0:: Splicing declarations singEqInstances [''Foo, ''Empty] ======> - instance SEq (KProxy :: KProxy Foo) where + instance SEq Foo where (%:==) SFLeaf SFLeaf = STrue (%:==) SFLeaf ((:%+:) _ _) = SFalse (%:==) ((:%+:) _ _) SFLeaf = SFalse @@ -10,14 +10,14 @@ Equals_0123456789 FLeaf FLeaf = TrueSym0 Equals_0123456789 ((:+:) a a) ((:+:) b b) = (:&&) ((:==) a b) ((:==) a b) Equals_0123456789 (a :: Foo) (b :: Foo) = FalseSym0 - instance PEq (KProxy :: KProxy Foo) where + instance PEq (Proxy :: Proxy Foo) where type (:==) (a :: Foo) (b :: Foo) = Equals_0123456789 a b - instance SEq (KProxy :: KProxy Empty) where + instance SEq Empty where (%:==) a _ = case a of { _ -> error "Empty case reached -- this should be impossible" } type family Equals_0123456789 (a :: Empty) (b :: Empty) :: Bool where Equals_0123456789 (a :: Empty) (b :: Empty) = FalseSym0 - instance PEq (KProxy :: KProxy Empty) where + instance PEq (Proxy :: Proxy Empty) where type (:==) (a :: Empty) (b :: Empty) = Equals_0123456789 a b diff --git a/tests/compile-and-dump/Singletons/Error.ghc710.template b/tests/compile-and-dump/Singletons/Error.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/Error.ghc710.template +++ /dev/null @@ -1,34 +0,0 @@ -Singletons/Error.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| head :: [a] -> a - head (a : _) = a - head [] = error "Data.Singletons.List.head: empty list" |] - ======> - head :: forall a. [a] -> a - head (a GHC.Types.: _) = a - head GHC.Types.[] = error "Data.Singletons.List.head: empty list" - type HeadSym1 (t :: [a0123456789]) = Head t - instance SuppressUnusedWarnings HeadSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) HeadSym0KindInference GHC.Tuple.()) - data HeadSym0 (l :: TyFun [a0123456789] a0123456789) - = forall arg. KindOf (Apply HeadSym0 arg) ~ KindOf (HeadSym1 arg) => - HeadSym0KindInference - type instance Apply HeadSym0 l = HeadSym1 l - type family Head (a :: [a]) :: a where - Head ((:) a _z_0123456789) = a - Head '[] = Apply ErrorSym0 "Data.Singletons.List.head: empty list" - sHead :: forall (t :: [a]). Sing t -> Sing (Apply HeadSym0 t :: a) - sHead (SCons sA _s_z_0123456789) - = let - lambda :: - forall a _z_0123456789. t ~ Apply (Apply (:$) a) _z_0123456789 => - Sing a -> Sing _z_0123456789 -> Sing (Apply HeadSym0 t :: a) - lambda a _z_0123456789 = a - in lambda sA _s_z_0123456789 - sHead SNil - = let - lambda :: t ~ '[] => Sing (Apply HeadSym0 t :: a) - lambda - = sError (sing :: Sing "Data.Singletons.List.head: empty list") - in lambda diff --git a/tests/compile-and-dump/Singletons/Fixity.ghc710.template b/tests/compile-and-dump/Singletons/Fixity.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/Fixity.ghc710.template +++ /dev/null @@ -1,74 +0,0 @@ -Singletons/Fixity.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| infix 4 ==== - infix 4 <=> - - (====) :: a -> a -> a - a ==== _ = a - - class MyOrd a where - (<=>) :: a -> a -> Ordering - infix 4 <=> |] - ======> - class MyOrd a where - (<=>) :: a -> a -> Ordering - infix 4 <=> - (====) :: forall a. a -> a -> a - (====) a _ = a - infix 4 ==== - type (:====$$$) (t :: a0123456789) (t :: a0123456789) = (:====) t t - instance SuppressUnusedWarnings (:====$$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:====$$###) GHC.Tuple.()) - data (:====$$) (l :: a0123456789) - (l :: TyFun a0123456789 a0123456789) - = forall arg. KindOf (Apply ((:====$$) l) arg) ~ KindOf ((:====$$$) l arg) => - :====$$### - type instance Apply ((:====$$) l) l = (:====$$$) l l - instance SuppressUnusedWarnings (:====$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:====$###) GHC.Tuple.()) - data (:====$) (l :: TyFun a0123456789 (TyFun a0123456789 a0123456789 - -> *)) - = forall arg. KindOf (Apply (:====$) arg) ~ KindOf ((:====$$) arg) => - :====$### - type instance Apply (:====$) l = (:====$$) l - type family (:====) (a :: a) (a :: a) :: a where - (:====) a _z_0123456789 = a - infix 4 :==== - infix 4 :<=> - type (:<=>$$$) (t :: a0123456789) (t :: a0123456789) = (:<=>) t t - instance SuppressUnusedWarnings (:<=>$$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:<=>$$###) GHC.Tuple.()) - data (:<=>$$) (l :: a0123456789) (l :: TyFun a0123456789 Ordering) - = forall arg. KindOf (Apply ((:<=>$$) l) arg) ~ KindOf ((:<=>$$$) l arg) => - :<=>$$### - type instance Apply ((:<=>$$) l) l = (:<=>$$$) l l - instance SuppressUnusedWarnings (:<=>$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:<=>$###) GHC.Tuple.()) - data (:<=>$) (l :: TyFun a0123456789 (TyFun a0123456789 Ordering - -> *)) - = forall arg. KindOf (Apply (:<=>$) arg) ~ KindOf ((:<=>$$) arg) => - :<=>$### - type instance Apply (:<=>$) l = (:<=>$$) l - class kproxy ~ KProxy => PMyOrd (kproxy :: KProxy a) where - type family (:<=>) (arg :: a) (arg :: a) :: Ordering - infix 4 %:==== - infix 4 %:<=> - (%:====) :: - forall (t :: a) (t :: a). - Sing t -> Sing t -> Sing (Apply (Apply (:====$) t) t :: a) - (%:====) sA _s_z_0123456789 - = let - lambda :: - forall a _z_0123456789. (t ~ a, t ~ _z_0123456789) => - Sing a - -> Sing _z_0123456789 -> Sing (Apply (Apply (:====$) t) t :: a) - lambda a _z_0123456789 = a - in lambda sA _s_z_0123456789 - class kproxy ~ KProxy => SMyOrd (kproxy :: KProxy a) where - (%:<=>) :: - forall (t :: a) (t :: a). - Sing t -> Sing t -> Sing (Apply (Apply (:<=>$) t) t :: Ordering) diff --git a/tests/compile-and-dump/Singletons/Fixity.ghc80.template b/tests/compile-and-dump/Singletons/Fixity.ghc80.template --- a/tests/compile-and-dump/Singletons/Fixity.ghc80.template +++ b/tests/compile-and-dump/Singletons/Fixity.ghc80.template @@ -53,7 +53,7 @@ = forall arg. KindOf (Apply (:<=>$) arg) ~ KindOf ((:<=>$$) arg) => (:<=>$###) type instance Apply (:<=>$) l = (:<=>$$) l - class kproxy ~ KProxy => PMyOrd (kproxy :: KProxy a) where + class kproxy ~ Proxy => PMyOrd (kproxy :: Proxy a) where type (:<=>) (arg :: a) (arg :: a) :: Ordering infix 4 %:==== infix 4 %:<=> @@ -69,7 +69,7 @@ -> Sing _z_0123456789 -> Sing (Apply (Apply (:====$) t) t :: a) lambda a _z_0123456789 = a in lambda sA _s_z_0123456789 - class kproxy ~ KProxy => SMyOrd (kproxy :: KProxy a) where + class SMyOrd a where (%:<=>) :: forall (t :: a) (t :: a). Sing t -> Sing t -> Sing (Apply (Apply (:<=>$) t) t :: Ordering) diff --git a/tests/compile-and-dump/Singletons/FunDeps.ghc710.template b/tests/compile-and-dump/Singletons/FunDeps.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/FunDeps.ghc710.template +++ /dev/null @@ -1,98 +0,0 @@ -Singletons/FunDeps.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| t1 = meth True - - class FD a b | a -> b where - meth :: a -> a - l2r :: a -> b - - instance FD Bool Nat where - meth = not - l2r False = 0 - l2r True = 1 |] - ======> - class FD a b | a -> b where - meth :: a -> a - l2r :: a -> b - instance FD Bool Nat where - meth = not - l2r False = 0 - l2r True = 1 - t1 = meth True - type T1Sym0 = T1 - type family T1 where - T1 = Apply MethSym0 TrueSym0 - type MethSym1 (t :: a0123456789) = Meth t - instance SuppressUnusedWarnings MethSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) MethSym0KindInference GHC.Tuple.()) - data MethSym0 (l :: TyFun a0123456789 a0123456789) - = forall arg. KindOf (Apply MethSym0 arg) ~ KindOf (MethSym1 arg) => - MethSym0KindInference - type instance Apply MethSym0 l = MethSym1 l - type L2rSym1 (t :: a0123456789) = L2r t - instance SuppressUnusedWarnings L2rSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) L2rSym0KindInference GHC.Tuple.()) - data L2rSym0 (l :: TyFun a0123456789 b0123456789) - = forall arg. KindOf (Apply L2rSym0 arg) ~ KindOf (L2rSym1 arg) => - L2rSym0KindInference - type instance Apply L2rSym0 l = L2rSym1 l - class (kproxy ~ KProxy, - kproxy ~ KProxy) => PFD (kproxy :: KProxy a) - (kproxy :: KProxy b) | a -> b where - type family Meth (arg :: a) :: a - type family L2r (arg :: a) :: b - type family Meth_0123456789 (a :: Bool) :: Bool where - Meth_0123456789 a_0123456789 = Apply NotSym0 a_0123456789 - type Meth_0123456789Sym1 (t :: Bool) = Meth_0123456789 t - instance SuppressUnusedWarnings Meth_0123456789Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Meth_0123456789Sym0KindInference GHC.Tuple.()) - data Meth_0123456789Sym0 (l :: TyFun Bool Bool) - = forall arg. KindOf (Apply Meth_0123456789Sym0 arg) ~ KindOf (Meth_0123456789Sym1 arg) => - Meth_0123456789Sym0KindInference - type instance Apply Meth_0123456789Sym0 l = Meth_0123456789Sym1 l - type family L2r_0123456789 (a :: Bool) :: Nat where - L2r_0123456789 False = FromInteger 0 - L2r_0123456789 True = FromInteger 1 - type L2r_0123456789Sym1 (t :: Bool) = L2r_0123456789 t - instance SuppressUnusedWarnings L2r_0123456789Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) L2r_0123456789Sym0KindInference GHC.Tuple.()) - data L2r_0123456789Sym0 (l :: TyFun Bool Nat) - = forall arg. KindOf (Apply L2r_0123456789Sym0 arg) ~ KindOf (L2r_0123456789Sym1 arg) => - L2r_0123456789Sym0KindInference - type instance Apply L2r_0123456789Sym0 l = L2r_0123456789Sym1 l - instance PFD (KProxy :: KProxy Bool) (KProxy :: KProxy Nat) where - type Meth (a :: Bool) = Apply Meth_0123456789Sym0 a - type L2r (a :: Bool) = Apply L2r_0123456789Sym0 a - sT1 :: Sing T1Sym0 - sT1 = applySing (singFun1 (Proxy :: Proxy MethSym0) sMeth) STrue - class (kproxy ~ KProxy, - kproxy ~ KProxy) => SFD (kproxy :: KProxy a) - (kproxy :: KProxy 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 (KProxy :: KProxy Bool) (KProxy :: KProxy Nat) where - sMeth :: - forall (t :: Bool). Sing t -> Sing (Apply MethSym0 t :: Bool) - sL2r :: forall (t :: Bool). Sing t -> Sing (Apply L2rSym0 t :: Nat) - sMeth sA_0123456789 - = let - lambda :: - forall a_0123456789. t ~ a_0123456789 => - Sing a_0123456789 -> Sing (Apply MethSym0 t :: Bool) - lambda a_0123456789 - = applySing (singFun1 (Proxy :: Proxy NotSym0) sNot) a_0123456789 - in lambda sA_0123456789 - sL2r SFalse - = let - lambda :: t ~ FalseSym0 => Sing (Apply L2rSym0 t :: Nat) - lambda = sFromInteger (sing :: Sing 0) - in lambda - sL2r STrue - = let - lambda :: t ~ TrueSym0 => Sing (Apply L2rSym0 t :: Nat) - lambda = sFromInteger (sing :: Sing 1) - in lambda diff --git a/tests/compile-and-dump/Singletons/FunDeps.ghc80.template b/tests/compile-and-dump/Singletons/FunDeps.ghc80.template --- a/tests/compile-and-dump/Singletons/FunDeps.ghc80.template +++ b/tests/compile-and-dump/Singletons/FunDeps.ghc80.template @@ -38,9 +38,8 @@ = forall arg. KindOf (Apply L2rSym0 arg) ~ KindOf (L2rSym1 arg) => L2rSym0KindInference type instance Apply L2rSym0 l = L2rSym1 l - class (kproxy ~ KProxy, - kproxy ~ KProxy) => PFD (kproxy :: KProxy a) - (kproxy :: KProxy b) | a -> b where + class (kproxy ~ Proxy, kproxy ~ Proxy) => PFD (kproxy :: Proxy a) + (kproxy :: Proxy b) | a -> b where type Meth (arg :: a) :: a type L2r (arg :: a) :: b type family Meth_0123456789 (a :: Bool) :: Bool where @@ -64,17 +63,15 @@ = forall arg. KindOf (Apply L2r_0123456789Sym0 arg) ~ KindOf (L2r_0123456789Sym1 arg) => L2r_0123456789Sym0KindInference type instance Apply L2r_0123456789Sym0 l = L2r_0123456789Sym1 l - instance PFD (KProxy :: KProxy Bool) (KProxy :: KProxy Nat) where + instance PFD (Proxy :: Proxy Bool) (Proxy :: Proxy Nat) where type Meth (a :: Bool) = Apply Meth_0123456789Sym0 a type L2r (a :: Bool) = Apply L2r_0123456789Sym0 a sT1 :: Sing T1Sym0 sT1 = applySing (singFun1 (Proxy :: Proxy MethSym0) sMeth) STrue - class (kproxy ~ KProxy, - kproxy ~ KProxy) => SFD (kproxy :: KProxy a) - (kproxy :: KProxy b) | a -> b where + 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 (KProxy :: KProxy Bool) (KProxy :: KProxy Nat) where + instance SFD Bool Nat where sMeth :: forall (t :: Bool). Sing t -> Sing (Apply MethSym0 t :: Bool) sL2r :: forall (t :: Bool). Sing t -> Sing (Apply L2rSym0 t :: Nat) diff --git a/tests/compile-and-dump/Singletons/HigherOrder.ghc710.template b/tests/compile-and-dump/Singletons/HigherOrder.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/HigherOrder.ghc710.template +++ /dev/null @@ -1,547 +0,0 @@ -Singletons/HigherOrder.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| map :: (a -> b) -> [a] -> [b] - map _ [] = [] - map f (h : t) = (f h) : (map f t) - liftMaybe :: (a -> b) -> Maybe a -> Maybe b - liftMaybe f (Just x) = Just (f x) - liftMaybe _ Nothing = Nothing - zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] - zipWith f (x : xs) (y : ys) = f x y : zipWith f xs ys - zipWith _ [] [] = [] - zipWith _ (_ : _) [] = [] - zipWith _ [] (_ : _) = [] - foo :: ((a -> b) -> a -> b) -> (a -> b) -> a -> b - foo f g a = f g a - splunge :: [Nat] -> [Bool] -> [Nat] - splunge ns bs - = zipWith (\ n b -> if b then Succ (Succ n) else n) ns bs - etad :: [Nat] -> [Bool] -> [Nat] - etad = zipWith (\ n b -> if b then Succ (Succ n) else n) - - data Either a b = Left a | Right b |] - ======> - data Either a b = Left a | Right b - map :: forall a b. (a -> b) -> [a] -> [b] - map _ GHC.Types.[] = [] - map f (h GHC.Types.: t) = ((f h) GHC.Types.: (map f t)) - liftMaybe :: forall a b. (a -> b) -> Maybe a -> Maybe b - liftMaybe f (Just x) = Just (f x) - liftMaybe _ Nothing = Nothing - zipWith :: forall a b c. (a -> b -> c) -> [a] -> [b] -> [c] - zipWith f (x GHC.Types.: xs) (y GHC.Types.: ys) - = ((f x y) GHC.Types.: (zipWith f xs ys)) - zipWith _ GHC.Types.[] GHC.Types.[] = [] - zipWith _ (_ GHC.Types.: _) GHC.Types.[] = [] - zipWith _ GHC.Types.[] (_ GHC.Types.: _) = [] - foo :: forall a b. ((a -> b) -> a -> b) -> (a -> b) -> a -> b - foo f g a = f g a - splunge :: [Nat] -> [Bool] -> [Nat] - splunge ns bs - = zipWith (\ n b -> if b then Succ (Succ n) else n) ns bs - etad :: [Nat] -> [Bool] -> [Nat] - etad = zipWith (\ n b -> if b then Succ (Succ n) else n) - type LeftSym1 (t :: a0123456789) = Left t - instance SuppressUnusedWarnings LeftSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) LeftSym0KindInference GHC.Tuple.()) - data LeftSym0 (l :: TyFun a0123456789 (Either a0123456789 b0123456789)) - = forall arg. KindOf (Apply LeftSym0 arg) ~ KindOf (LeftSym1 arg) => - LeftSym0KindInference - type instance Apply LeftSym0 l = LeftSym1 l - type RightSym1 (t :: b0123456789) = Right t - instance SuppressUnusedWarnings RightSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) RightSym0KindInference GHC.Tuple.()) - data RightSym0 (l :: TyFun b0123456789 (Either a0123456789 b0123456789)) - = forall arg. KindOf (Apply RightSym0 arg) ~ KindOf (RightSym1 arg) => - RightSym0KindInference - type instance Apply RightSym0 l = RightSym1 l - type family Case_0123456789 ns bs n b t where - Case_0123456789 ns bs n b True = Apply SuccSym0 (Apply SuccSym0 n) - Case_0123456789 ns bs n b False = n - type family Lambda_0123456789 ns bs t t where - Lambda_0123456789 ns bs n b = Case_0123456789 ns bs n b b - type Lambda_0123456789Sym4 t t t t = Lambda_0123456789 t t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym3 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.()) - data Lambda_0123456789Sym3 l l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) => - Lambda_0123456789Sym3KindInference - type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type family Case_0123456789 n b a_0123456789 a_0123456789 t where - Case_0123456789 n b a_0123456789 a_0123456789 True = Apply SuccSym0 (Apply SuccSym0 n) - Case_0123456789 n b a_0123456789 a_0123456789 False = n - type family Lambda_0123456789 a_0123456789 a_0123456789 t t where - Lambda_0123456789 a_0123456789 a_0123456789 n b = Case_0123456789 n b a_0123456789 a_0123456789 b - type Lambda_0123456789Sym4 t t t t = Lambda_0123456789 t t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym3 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.()) - data Lambda_0123456789Sym3 l l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) => - Lambda_0123456789Sym3KindInference - type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type FooSym3 (t :: TyFun (TyFun a0123456789 b0123456789 - -> *) (TyFun a0123456789 b0123456789 -> *) - -> *) - (t :: TyFun a0123456789 b0123456789 -> *) - (t :: a0123456789) = - Foo t t t - instance SuppressUnusedWarnings FooSym2 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FooSym2KindInference GHC.Tuple.()) - data FooSym2 (l :: TyFun (TyFun a0123456789 b0123456789 - -> *) (TyFun a0123456789 b0123456789 -> *) - -> *) - (l :: TyFun a0123456789 b0123456789 -> *) - (l :: TyFun a0123456789 b0123456789) - = forall arg. KindOf (Apply (FooSym2 l l) arg) ~ KindOf (FooSym3 l l arg) => - FooSym2KindInference - type instance Apply (FooSym2 l l) l = FooSym3 l l l - instance SuppressUnusedWarnings FooSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FooSym1KindInference GHC.Tuple.()) - data FooSym1 (l :: TyFun (TyFun a0123456789 b0123456789 - -> *) (TyFun a0123456789 b0123456789 -> *) - -> *) - (l :: TyFun (TyFun a0123456789 b0123456789 - -> *) (TyFun a0123456789 b0123456789 -> *)) - = forall arg. KindOf (Apply (FooSym1 l) arg) ~ KindOf (FooSym2 l arg) => - FooSym1KindInference - type instance Apply (FooSym1 l) l = FooSym2 l l - instance SuppressUnusedWarnings FooSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.()) - data FooSym0 (l :: TyFun (TyFun (TyFun a0123456789 b0123456789 - -> *) (TyFun a0123456789 b0123456789 -> *) - -> *) (TyFun (TyFun a0123456789 b0123456789 - -> *) (TyFun a0123456789 b0123456789 -> *) - -> *)) - = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) => - FooSym0KindInference - type instance Apply FooSym0 l = FooSym1 l - type ZipWithSym3 (t :: TyFun a0123456789 (TyFun b0123456789 c0123456789 - -> *) - -> *) - (t :: [a0123456789]) - (t :: [b0123456789]) = - ZipWith t t t - instance SuppressUnusedWarnings ZipWithSym2 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ZipWithSym2KindInference GHC.Tuple.()) - data ZipWithSym2 (l :: TyFun a0123456789 (TyFun b0123456789 c0123456789 - -> *) - -> *) - (l :: [a0123456789]) - (l :: TyFun [b0123456789] [c0123456789]) - = forall arg. KindOf (Apply (ZipWithSym2 l l) arg) ~ KindOf (ZipWithSym3 l l arg) => - ZipWithSym2KindInference - type instance Apply (ZipWithSym2 l l) l = ZipWithSym3 l l l - instance SuppressUnusedWarnings ZipWithSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ZipWithSym1KindInference GHC.Tuple.()) - data ZipWithSym1 (l :: TyFun a0123456789 (TyFun b0123456789 c0123456789 - -> *) - -> *) - (l :: TyFun [a0123456789] (TyFun [b0123456789] [c0123456789] -> *)) - = forall arg. KindOf (Apply (ZipWithSym1 l) arg) ~ KindOf (ZipWithSym2 l arg) => - ZipWithSym1KindInference - type instance Apply (ZipWithSym1 l) l = ZipWithSym2 l l - instance SuppressUnusedWarnings ZipWithSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ZipWithSym0KindInference GHC.Tuple.()) - data ZipWithSym0 (l :: TyFun (TyFun a0123456789 (TyFun b0123456789 c0123456789 - -> *) - -> *) (TyFun [a0123456789] (TyFun [b0123456789] [c0123456789] - -> *) - -> *)) - = forall arg. KindOf (Apply ZipWithSym0 arg) ~ KindOf (ZipWithSym1 arg) => - ZipWithSym0KindInference - type instance Apply ZipWithSym0 l = ZipWithSym1 l - type SplungeSym2 (t :: [Nat]) (t :: [Bool]) = Splunge t t - instance SuppressUnusedWarnings SplungeSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) SplungeSym1KindInference GHC.Tuple.()) - data SplungeSym1 (l :: [Nat]) (l :: TyFun [Bool] [Nat]) - = forall arg. KindOf (Apply (SplungeSym1 l) arg) ~ KindOf (SplungeSym2 l arg) => - SplungeSym1KindInference - type instance Apply (SplungeSym1 l) l = SplungeSym2 l l - instance SuppressUnusedWarnings SplungeSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) SplungeSym0KindInference GHC.Tuple.()) - data SplungeSym0 (l :: TyFun [Nat] (TyFun [Bool] [Nat] -> *)) - = forall arg. KindOf (Apply SplungeSym0 arg) ~ KindOf (SplungeSym1 arg) => - SplungeSym0KindInference - type instance Apply SplungeSym0 l = SplungeSym1 l - type EtadSym2 (t :: [Nat]) (t :: [Bool]) = Etad t t - instance SuppressUnusedWarnings EtadSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) EtadSym1KindInference GHC.Tuple.()) - data EtadSym1 (l :: [Nat]) (l :: TyFun [Bool] [Nat]) - = forall arg. KindOf (Apply (EtadSym1 l) arg) ~ KindOf (EtadSym2 l arg) => - EtadSym1KindInference - type instance Apply (EtadSym1 l) l = EtadSym2 l l - instance SuppressUnusedWarnings EtadSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) EtadSym0KindInference GHC.Tuple.()) - data EtadSym0 (l :: TyFun [Nat] (TyFun [Bool] [Nat] -> *)) - = forall arg. KindOf (Apply EtadSym0 arg) ~ KindOf (EtadSym1 arg) => - EtadSym0KindInference - type instance Apply EtadSym0 l = EtadSym1 l - type LiftMaybeSym2 (t :: TyFun a0123456789 b0123456789 -> *) - (t :: Maybe a0123456789) = - LiftMaybe t t - instance SuppressUnusedWarnings LiftMaybeSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) LiftMaybeSym1KindInference GHC.Tuple.()) - data LiftMaybeSym1 (l :: TyFun a0123456789 b0123456789 -> *) - (l :: TyFun (Maybe a0123456789) (Maybe b0123456789)) - = forall arg. KindOf (Apply (LiftMaybeSym1 l) arg) ~ KindOf (LiftMaybeSym2 l arg) => - LiftMaybeSym1KindInference - type instance Apply (LiftMaybeSym1 l) l = LiftMaybeSym2 l l - instance SuppressUnusedWarnings LiftMaybeSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) LiftMaybeSym0KindInference GHC.Tuple.()) - data LiftMaybeSym0 (l :: TyFun (TyFun a0123456789 b0123456789 - -> *) (TyFun (Maybe a0123456789) (Maybe b0123456789) -> *)) - = forall arg. KindOf (Apply LiftMaybeSym0 arg) ~ KindOf (LiftMaybeSym1 arg) => - LiftMaybeSym0KindInference - type instance Apply LiftMaybeSym0 l = LiftMaybeSym1 l - type MapSym2 (t :: TyFun a0123456789 b0123456789 -> *) - (t :: [a0123456789]) = - Map t t - instance SuppressUnusedWarnings MapSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) MapSym1KindInference GHC.Tuple.()) - data MapSym1 (l :: TyFun a0123456789 b0123456789 -> *) - (l :: TyFun [a0123456789] [b0123456789]) - = forall arg. KindOf (Apply (MapSym1 l) arg) ~ KindOf (MapSym2 l arg) => - MapSym1KindInference - type instance Apply (MapSym1 l) l = MapSym2 l l - instance SuppressUnusedWarnings MapSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) MapSym0KindInference GHC.Tuple.()) - data MapSym0 (l :: TyFun (TyFun a0123456789 b0123456789 - -> *) (TyFun [a0123456789] [b0123456789] -> *)) - = forall arg. KindOf (Apply MapSym0 arg) ~ KindOf (MapSym1 arg) => - MapSym0KindInference - type instance Apply MapSym0 l = MapSym1 l - type family Foo (a :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *) - (a :: TyFun a b -> *) - (a :: a) :: b where - Foo f g a = Apply (Apply f g) a - type family ZipWith (a :: TyFun a (TyFun b c -> *) -> *) - (a :: [a]) - (a :: [b]) :: [c] where - ZipWith f ((:) x xs) ((:) y ys) = Apply (Apply (:$) (Apply (Apply f x) y)) (Apply (Apply (Apply ZipWithSym0 f) xs) ys) - ZipWith _z_0123456789 '[] '[] = '[] - ZipWith _z_0123456789 ((:) _z_0123456789 _z_0123456789) '[] = '[] - ZipWith _z_0123456789 '[] ((:) _z_0123456789 _z_0123456789) = '[] - type family Splunge (a :: [Nat]) (a :: [Bool]) :: [Nat] where - Splunge ns bs = Apply (Apply (Apply ZipWithSym0 (Apply (Apply Lambda_0123456789Sym0 ns) bs)) ns) bs - type family Etad (a :: [Nat]) (a :: [Bool]) :: [Nat] where - Etad a_0123456789 a_0123456789 = Apply (Apply (Apply ZipWithSym0 (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789)) a_0123456789) a_0123456789 - type family LiftMaybe (a :: TyFun a b -> *) - (a :: Maybe a) :: Maybe b where - LiftMaybe f (Just x) = Apply JustSym0 (Apply f x) - LiftMaybe _z_0123456789 Nothing = NothingSym0 - type family Map (a :: TyFun a b -> *) (a :: [a]) :: [b] where - Map _z_0123456789 '[] = '[] - Map f ((:) h t) = Apply (Apply (:$) (Apply f h)) (Apply (Apply MapSym0 f) t) - sFoo :: - forall (t :: TyFun (TyFun a b -> *) (TyFun a b -> *) -> *) - (t :: TyFun a b -> *) - (t :: a). - Sing t - -> Sing t - -> Sing t -> Sing (Apply (Apply (Apply FooSym0 t) t) t :: b) - sZipWith :: - forall (t :: TyFun a (TyFun b c -> *) -> *) (t :: [a]) (t :: [b]). - Sing t - -> Sing t - -> Sing t -> Sing (Apply (Apply (Apply ZipWithSym0 t) t) t :: [c]) - sSplunge :: - forall (t :: [Nat]) (t :: [Bool]). - Sing t -> Sing t -> Sing (Apply (Apply SplungeSym0 t) t :: [Nat]) - sEtad :: - forall (t :: [Nat]) (t :: [Bool]). - Sing t -> Sing t -> Sing (Apply (Apply EtadSym0 t) t :: [Nat]) - sLiftMaybe :: - forall (t :: TyFun a b -> *) (t :: Maybe a). - Sing t - -> Sing t -> Sing (Apply (Apply LiftMaybeSym0 t) t :: Maybe b) - sMap :: - forall (t :: TyFun a b -> *) (t :: [a]). - Sing t -> Sing t -> Sing (Apply (Apply MapSym0 t) t :: [b]) - sFoo sF sG sA - = let - lambda :: - forall f g a. (t ~ f, t ~ g, t ~ a) => - Sing f - -> Sing g - -> Sing a -> Sing (Apply (Apply (Apply FooSym0 t) t) t :: b) - lambda f g a = applySing (applySing f g) a - in lambda sF sG sA - sZipWith sF (SCons sX sXs) (SCons sY sYs) - = let - lambda :: - forall f x xs y ys. (t ~ f, - t ~ Apply (Apply (:$) x) xs, - t ~ Apply (Apply (:$) y) ys) => - Sing f - -> Sing x - -> Sing xs - -> Sing y - -> Sing ys -> Sing (Apply (Apply (Apply ZipWithSym0 t) t) t :: [c]) - lambda f x xs y ys - = applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing (applySing f x) y)) - (applySing - (applySing - (applySing (singFun3 (Proxy :: Proxy ZipWithSym0) sZipWith) f) xs) - ys) - in lambda sF sX sXs sY sYs - sZipWith _s_z_0123456789 SNil SNil - = let - lambda :: - forall _z_0123456789. (t ~ _z_0123456789, t ~ '[], t ~ '[]) => - Sing _z_0123456789 - -> Sing (Apply (Apply (Apply ZipWithSym0 t) t) t :: [c]) - lambda _z_0123456789 = SNil - in lambda _s_z_0123456789 - sZipWith - _s_z_0123456789 - (SCons _s_z_0123456789 _s_z_0123456789) - SNil - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789. (t ~ _z_0123456789, - t ~ Apply (Apply (:$) _z_0123456789) _z_0123456789, - t ~ '[]) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply (Apply ZipWithSym0 t) t) t :: [c]) - lambda _z_0123456789 _z_0123456789 _z_0123456789 = SNil - in lambda _s_z_0123456789 _s_z_0123456789 _s_z_0123456789 - sZipWith - _s_z_0123456789 - SNil - (SCons _s_z_0123456789 _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789. (t ~ _z_0123456789, - t ~ '[], - t ~ Apply (Apply (:$) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply (Apply ZipWithSym0 t) t) t :: [c]) - lambda _z_0123456789 _z_0123456789 _z_0123456789 = SNil - in lambda _s_z_0123456789 _s_z_0123456789 _s_z_0123456789 - sSplunge sNs sBs - = let - lambda :: - forall ns bs. (t ~ ns, t ~ bs) => - Sing ns -> Sing bs -> Sing (Apply (Apply SplungeSym0 t) t :: [Nat]) - lambda ns bs - = applySing - (applySing - (applySing - (singFun3 (Proxy :: Proxy ZipWithSym0) sZipWith) - (singFun2 - (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 ns) bs)) - (\ sN sB - -> let - lambda :: - forall n b. - Sing n - -> Sing b - -> Sing (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 ns) bs) n) b) - lambda n b - = case b of { - STrue - -> let - lambda :: - TrueSym0 ~ b => - Sing (Case_0123456789 ns bs n b TrueSym0) - lambda - = applySing - (singFun1 (Proxy :: Proxy SuccSym0) SSucc) - (applySing - (singFun1 (Proxy :: Proxy SuccSym0) SSucc) n) - in lambda - SFalse - -> let - lambda :: - FalseSym0 ~ b => - Sing (Case_0123456789 ns bs n b FalseSym0) - lambda = n - in lambda } :: - Sing (Case_0123456789 ns bs n b b) - in lambda sN sB))) - ns) - bs - in lambda sNs sBs - sEtad sA_0123456789 sA_0123456789 - = let - lambda :: - forall a_0123456789 a_0123456789. (t ~ a_0123456789, - t ~ a_0123456789) => - Sing a_0123456789 - -> Sing a_0123456789 -> Sing (Apply (Apply EtadSym0 t) t :: [Nat]) - lambda a_0123456789 a_0123456789 - = applySing - (applySing - (applySing - (singFun3 (Proxy :: Proxy ZipWithSym0) sZipWith) - (singFun2 - (Proxy :: - Proxy (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789)) - (\ sN sB - -> let - lambda :: - forall n b. - Sing n - -> Sing b - -> Sing (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789) n) b) - lambda n b - = case b of { - STrue - -> let - lambda :: - TrueSym0 ~ b => - Sing (Case_0123456789 n b a_0123456789 a_0123456789 TrueSym0) - lambda - = applySing - (singFun1 (Proxy :: Proxy SuccSym0) SSucc) - (applySing - (singFun1 (Proxy :: Proxy SuccSym0) SSucc) n) - in lambda - SFalse - -> let - lambda :: - FalseSym0 ~ b => - Sing (Case_0123456789 n b a_0123456789 a_0123456789 FalseSym0) - lambda = n - in lambda } :: - Sing (Case_0123456789 n b a_0123456789 a_0123456789 b) - in lambda sN sB))) - a_0123456789) - a_0123456789 - in lambda sA_0123456789 sA_0123456789 - sLiftMaybe sF (SJust sX) - = let - lambda :: - forall f x. (t ~ f, t ~ Apply JustSym0 x) => - Sing f - -> Sing x -> Sing (Apply (Apply LiftMaybeSym0 t) t :: Maybe b) - lambda f x - = applySing - (singFun1 (Proxy :: Proxy JustSym0) SJust) (applySing f x) - in lambda sF sX - sLiftMaybe _s_z_0123456789 SNothing - = let - lambda :: - forall _z_0123456789. (t ~ _z_0123456789, t ~ NothingSym0) => - Sing _z_0123456789 - -> Sing (Apply (Apply LiftMaybeSym0 t) t :: Maybe b) - lambda _z_0123456789 = SNothing - in lambda _s_z_0123456789 - sMap _s_z_0123456789 SNil - = let - lambda :: - forall _z_0123456789. (t ~ _z_0123456789, t ~ '[]) => - Sing _z_0123456789 -> Sing (Apply (Apply MapSym0 t) t :: [b]) - lambda _z_0123456789 = SNil - in lambda _s_z_0123456789 - sMap sF (SCons sH sT) - = let - lambda :: - forall f h t. (t ~ f, t ~ Apply (Apply (:$) h) t) => - Sing f - -> Sing h -> Sing t -> Sing (Apply (Apply MapSym0 t) t :: [b]) - lambda f h t - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) (applySing f h)) - (applySing - (applySing (singFun2 (Proxy :: Proxy MapSym0) sMap) f) t) - in lambda sF sH sT - data instance Sing (z :: Either a b) - = forall (n :: a). z ~ Left n => SLeft (Sing (n :: a)) | - forall (n :: b). z ~ Right n => SRight (Sing (n :: b)) - type SEither = (Sing :: Either a b -> *) - instance (SingKind (KProxy :: KProxy a), - SingKind (KProxy :: KProxy b)) => - SingKind (KProxy :: KProxy (Either a b)) where - type DemoteRep (KProxy :: KProxy (Either a b)) = Either (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b)) - fromSing (SLeft b) = Left (fromSing b) - fromSing (SRight b) = Right (fromSing b) - toSing (Left b) - = case toSing b :: SomeSing (KProxy :: KProxy a) of { - SomeSing c -> SomeSing (SLeft c) } - toSing (Right b) - = case toSing b :: SomeSing (KProxy :: KProxy b) of { - SomeSing c -> SomeSing (SRight c) } - instance SingI n => SingI (Left (n :: a)) where - sing = SLeft sing - instance SingI n => SingI (Right (n :: b)) where - sing = SRight sing diff --git a/tests/compile-and-dump/Singletons/HigherOrder.ghc80.template b/tests/compile-and-dump/Singletons/HigherOrder.ghc80.template --- a/tests/compile-and-dump/Singletons/HigherOrder.ghc80.template +++ b/tests/compile-and-dump/Singletons/HigherOrder.ghc80.template @@ -557,17 +557,15 @@ = forall (n :: a). z ~ Left n => SLeft (Sing (n :: a)) | forall (n :: b). z ~ Right n => SRight (Sing (n :: b)) type SEither = (Sing :: Either a b -> GHC.Types.Type) - instance (SingKind (KProxy :: KProxy a), - SingKind (KProxy :: KProxy b)) => - SingKind (KProxy :: KProxy (Either a b)) where - type DemoteRep (KProxy :: KProxy (Either a b)) = Either (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b)) + instance (SingKind a, SingKind b) => SingKind (Either a b) where + type DemoteRep (Either a b) = Either (DemoteRep a) (DemoteRep b) fromSing (SLeft b) = Left (fromSing b) fromSing (SRight b) = Right (fromSing b) toSing (Left b) - = case toSing b :: SomeSing (KProxy :: KProxy a) of { + = case toSing b :: SomeSing a of { SomeSing c -> SomeSing (SLeft c) } toSing (Right b) - = case toSing b :: SomeSing (KProxy :: KProxy b) of { + = case toSing b :: SomeSing b of { SomeSing c -> SomeSing (SRight c) } instance SingI n => SingI (Left (n :: a)) where sing = SLeft sing diff --git a/tests/compile-and-dump/Singletons/LambdaCase.ghc710.template b/tests/compile-and-dump/Singletons/LambdaCase.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/LambdaCase.ghc710.template +++ /dev/null @@ -1,294 +0,0 @@ -Singletons/LambdaCase.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| foo1 :: a -> Maybe a -> a - foo1 d x - = (\case { - Just y -> y - Nothing -> d }) - x - foo2 :: a -> Maybe a -> a - foo2 d _ - = (\case { - Just y -> y - Nothing -> d }) - (Just d) - foo3 :: a -> b -> a - foo3 a b = (\case { (p, _) -> p }) (a, b) |] - ======> - foo1 :: forall a. a -> Maybe a -> a - foo1 d x - = \case { - Just y -> y - Nothing -> d } - x - foo2 :: forall a. a -> Maybe a -> a - foo2 d _ - = \case { - Just y -> y - Nothing -> d } - (Just d) - foo3 :: forall a b. a -> b -> a - foo3 a b = \case { (p, _) -> p } (a, b) - type family Case_0123456789 a b x_0123456789 t where - Case_0123456789 a b x_0123456789 '(p, _z_0123456789) = p - type family Lambda_0123456789 a b t where - Lambda_0123456789 a b x_0123456789 = Case_0123456789 a b x_0123456789 x_0123456789 - type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type family Case_0123456789 d x_0123456789 _z_0123456789 t where - Case_0123456789 d x_0123456789 _z_0123456789 (Just y) = y - Case_0123456789 d x_0123456789 _z_0123456789 Nothing = d - type family Lambda_0123456789 d _z_0123456789 t where - Lambda_0123456789 d _z_0123456789 x_0123456789 = Case_0123456789 d x_0123456789 _z_0123456789 x_0123456789 - type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type family Case_0123456789 d x x_0123456789 t where - Case_0123456789 d x x_0123456789 (Just y) = y - Case_0123456789 d x x_0123456789 Nothing = d - type family Lambda_0123456789 d x t where - Lambda_0123456789 d x x_0123456789 = Case_0123456789 d x x_0123456789 x_0123456789 - type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type Foo3Sym2 (t :: a0123456789) (t :: b0123456789) = Foo3 t t - instance SuppressUnusedWarnings Foo3Sym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo3Sym1KindInference GHC.Tuple.()) - data Foo3Sym1 (l :: a0123456789) - (l :: TyFun b0123456789 a0123456789) - = forall arg. KindOf (Apply (Foo3Sym1 l) arg) ~ KindOf (Foo3Sym2 l arg) => - Foo3Sym1KindInference - type instance Apply (Foo3Sym1 l) l = Foo3Sym2 l l - instance SuppressUnusedWarnings Foo3Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.()) - data Foo3Sym0 (l :: TyFun a0123456789 (TyFun b0123456789 a0123456789 - -> *)) - = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) => - Foo3Sym0KindInference - type instance Apply Foo3Sym0 l = Foo3Sym1 l - type Foo2Sym2 (t :: a0123456789) (t :: Maybe a0123456789) = - Foo2 t t - instance SuppressUnusedWarnings Foo2Sym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo2Sym1KindInference GHC.Tuple.()) - data Foo2Sym1 (l :: a0123456789) - (l :: TyFun (Maybe a0123456789) a0123456789) - = forall arg. KindOf (Apply (Foo2Sym1 l) arg) ~ KindOf (Foo2Sym2 l arg) => - Foo2Sym1KindInference - type instance Apply (Foo2Sym1 l) l = Foo2Sym2 l l - instance SuppressUnusedWarnings Foo2Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.()) - data Foo2Sym0 (l :: TyFun a0123456789 (TyFun (Maybe a0123456789) a0123456789 - -> *)) - = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) => - Foo2Sym0KindInference - type instance Apply Foo2Sym0 l = Foo2Sym1 l - type Foo1Sym2 (t :: a0123456789) (t :: Maybe a0123456789) = - Foo1 t t - instance SuppressUnusedWarnings Foo1Sym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo1Sym1KindInference GHC.Tuple.()) - data Foo1Sym1 (l :: a0123456789) - (l :: TyFun (Maybe a0123456789) a0123456789) - = forall arg. KindOf (Apply (Foo1Sym1 l) arg) ~ KindOf (Foo1Sym2 l arg) => - Foo1Sym1KindInference - type instance Apply (Foo1Sym1 l) l = Foo1Sym2 l l - instance SuppressUnusedWarnings Foo1Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.()) - data Foo1Sym0 (l :: TyFun a0123456789 (TyFun (Maybe a0123456789) a0123456789 - -> *)) - = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) => - Foo1Sym0KindInference - type instance Apply Foo1Sym0 l = Foo1Sym1 l - type family Foo3 (a :: a) (a :: b) :: a where - Foo3 a b = Apply (Apply (Apply Lambda_0123456789Sym0 a) b) (Apply (Apply Tuple2Sym0 a) b) - type family Foo2 (a :: a) (a :: Maybe a) :: a where - Foo2 d _z_0123456789 = Apply (Apply (Apply Lambda_0123456789Sym0 d) _z_0123456789) (Apply JustSym0 d) - type family Foo1 (a :: a) (a :: Maybe a) :: a where - Foo1 d x = Apply (Apply (Apply Lambda_0123456789Sym0 d) x) x - sFoo3 :: - forall (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a) - sFoo2 :: - forall (t :: a) (t :: Maybe a). - Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a) - sFoo1 :: - forall (t :: a) (t :: Maybe a). - Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a) - sFoo3 sA sB - = let - lambda :: - forall a b. (t ~ a, t ~ b) => - Sing a -> Sing b -> Sing (Apply (Apply Foo3Sym0 t) t :: a) - lambda a b - = applySing - (singFun1 - (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 a) b)) - (\ sX_0123456789 - -> let - lambda :: - forall x_0123456789. - Sing x_0123456789 - -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 a) b) x_0123456789) - lambda x_0123456789 - = case x_0123456789 of { - STuple2 sP _s_z_0123456789 - -> let - lambda :: - forall p - _z_0123456789. Apply (Apply Tuple2Sym0 p) _z_0123456789 ~ x_0123456789 => - Sing p - -> Sing _z_0123456789 - -> Sing (Case_0123456789 a b x_0123456789 (Apply (Apply Tuple2Sym0 p) _z_0123456789)) - lambda p _z_0123456789 = p - in lambda sP _s_z_0123456789 } :: - Sing (Case_0123456789 a b x_0123456789 x_0123456789) - in lambda sX_0123456789)) - (applySing - (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) a) b) - in lambda sA sB - sFoo2 sD _s_z_0123456789 - = let - lambda :: - forall d _z_0123456789. (t ~ d, t ~ _z_0123456789) => - Sing d - -> Sing _z_0123456789 -> Sing (Apply (Apply Foo2Sym0 t) t :: a) - lambda d _z_0123456789 - = applySing - (singFun1 - (Proxy :: - Proxy (Apply (Apply Lambda_0123456789Sym0 d) _z_0123456789)) - (\ sX_0123456789 - -> let - lambda :: - forall x_0123456789. - Sing x_0123456789 - -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 d) _z_0123456789) x_0123456789) - lambda x_0123456789 - = case x_0123456789 of { - SJust sY - -> let - lambda :: - forall y. Apply JustSym0 y ~ x_0123456789 => - Sing y - -> Sing (Case_0123456789 d x_0123456789 _z_0123456789 (Apply JustSym0 y)) - lambda y = y - in lambda sY - SNothing - -> let - lambda :: - NothingSym0 ~ x_0123456789 => - Sing (Case_0123456789 d x_0123456789 _z_0123456789 NothingSym0) - lambda = d - in lambda } :: - Sing (Case_0123456789 d x_0123456789 _z_0123456789 x_0123456789) - in lambda sX_0123456789)) - (applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) d) - in lambda sD _s_z_0123456789 - sFoo1 sD sX - = let - lambda :: - forall d x. (t ~ d, t ~ x) => - Sing d -> Sing x -> Sing (Apply (Apply Foo1Sym0 t) t :: a) - lambda d x - = applySing - (singFun1 - (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 d) x)) - (\ sX_0123456789 - -> let - lambda :: - forall x_0123456789. - Sing x_0123456789 - -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 d) x) x_0123456789) - lambda x_0123456789 - = case x_0123456789 of { - SJust sY - -> let - lambda :: - forall y. Apply JustSym0 y ~ x_0123456789 => - Sing y - -> Sing (Case_0123456789 d x x_0123456789 (Apply JustSym0 y)) - lambda y = y - in lambda sY - SNothing - -> let - lambda :: - NothingSym0 ~ x_0123456789 => - Sing (Case_0123456789 d x x_0123456789 NothingSym0) - lambda = d - in lambda } :: - Sing (Case_0123456789 d x x_0123456789 x_0123456789) - in lambda sX_0123456789)) - x - in lambda sD sX diff --git a/tests/compile-and-dump/Singletons/Lambdas.ghc710.template b/tests/compile-and-dump/Singletons/Lambdas.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/Lambdas.ghc710.template +++ /dev/null @@ -1,836 +0,0 @@ -Singletons/Lambdas.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| foo0 :: a -> b -> a - foo0 = (\ x y -> x) - foo1 :: a -> b -> a - foo1 x = (\ _ -> x) - foo2 :: a -> b -> a - foo2 x y = (\ _ -> x) y - foo3 :: a -> a - foo3 x = (\ y -> y) x - foo4 :: a -> b -> c -> a - foo4 x y z = (\ _ _ -> x) y z - foo5 :: a -> b -> b - foo5 x y = (\ x -> x) y - foo6 :: a -> b -> a - foo6 a b = (\ x -> \ _ -> x) a b - foo7 :: a -> b -> b - foo7 x y = (\ (_, b) -> b) (x, y) - foo8 :: Foo a b -> a - foo8 x = (\ (Foo a _) -> a) x - - data Foo a b = Foo a b |] - ======> - foo0 :: forall a b. a -> b -> a - foo0 = \ x y -> x - foo1 :: forall a b. a -> b -> a - foo1 x = \ _ -> x - foo2 :: forall a b. a -> b -> a - foo2 x y = \ _ -> x y - foo3 :: forall a. a -> a - foo3 x = \ y -> y x - foo4 :: forall a b c. a -> b -> c -> a - foo4 x y z = \ _ _ -> x y z - foo5 :: forall a b. a -> b -> b - foo5 x y = \ x -> x y - foo6 :: forall a b. a -> b -> a - foo6 a b = \ x -> \ _ -> x a b - foo7 :: forall a b. a -> b -> b - foo7 x y = \ (_, b) -> b (x, y) - data Foo a b = Foo a b - foo8 :: forall a b. Foo a b -> a - foo8 x = \ (Foo a _) -> a x - type FooSym2 (t :: a0123456789) (t :: b0123456789) = Foo t t - instance SuppressUnusedWarnings FooSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FooSym1KindInference GHC.Tuple.()) - data FooSym1 (l :: a0123456789) - (l :: TyFun b0123456789 (Foo a0123456789 b0123456789)) - = forall arg. KindOf (Apply (FooSym1 l) arg) ~ KindOf (FooSym2 l arg) => - FooSym1KindInference - type instance Apply (FooSym1 l) l = FooSym2 l l - instance SuppressUnusedWarnings FooSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.()) - data FooSym0 (l :: TyFun a0123456789 (TyFun b0123456789 (Foo a0123456789 b0123456789) - -> *)) - = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) => - FooSym0KindInference - type instance Apply FooSym0 l = FooSym1 l - type family Case_0123456789 x arg_0123456789 t where - Case_0123456789 x arg_0123456789 (Foo a _z_0123456789) = a - type family Lambda_0123456789 x t where - Lambda_0123456789 x arg_0123456789 = Case_0123456789 x arg_0123456789 arg_0123456789 - type Lambda_0123456789Sym2 t t = Lambda_0123456789 t t - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type family Case_0123456789 x y arg_0123456789 t where - Case_0123456789 x y arg_0123456789 '(_z_0123456789, b) = b - type family Lambda_0123456789 x y t where - Lambda_0123456789 x y arg_0123456789 = Case_0123456789 x y arg_0123456789 arg_0123456789 - type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type family Case_0123456789 a b x arg_0123456789 t where - Case_0123456789 a b x arg_0123456789 _z_0123456789 = x - type family Lambda_0123456789 a b x t where - Lambda_0123456789 a b x arg_0123456789 = Case_0123456789 a b x arg_0123456789 arg_0123456789 - type Lambda_0123456789Sym4 t t t t = Lambda_0123456789 t t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym3 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.()) - data Lambda_0123456789Sym3 l l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) => - Lambda_0123456789Sym3KindInference - type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type family Lambda_0123456789 a b t where - Lambda_0123456789 a b x = Apply (Apply (Apply Lambda_0123456789Sym0 a) b) x - type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type family Lambda_0123456789 x y t where - Lambda_0123456789 x y x = x - type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type family Case_0123456789 x - y - z - arg_0123456789 - arg_0123456789 - t where - Case_0123456789 x y z arg_0123456789 arg_0123456789 '(_z_0123456789, - _z_0123456789) = x - type family Lambda_0123456789 x y z t t where - Lambda_0123456789 x y z arg_0123456789 arg_0123456789 = Case_0123456789 x y z arg_0123456789 arg_0123456789 (Apply (Apply Tuple2Sym0 arg_0123456789) arg_0123456789) - type Lambda_0123456789Sym5 t t t t t = Lambda_0123456789 t t t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym4 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym4KindInference GHC.Tuple.()) - data Lambda_0123456789Sym4 l l l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym4 l l l l) arg) ~ KindOf (Lambda_0123456789Sym5 l l l l arg) => - Lambda_0123456789Sym4KindInference - type instance Apply (Lambda_0123456789Sym4 l l l l) l = Lambda_0123456789Sym5 l l l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym3 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.()) - data Lambda_0123456789Sym3 l l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) => - Lambda_0123456789Sym3KindInference - type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type family Lambda_0123456789 x t where - Lambda_0123456789 x y = y - type Lambda_0123456789Sym2 t t = Lambda_0123456789 t t - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type family Case_0123456789 x y arg_0123456789 t where - Case_0123456789 x y arg_0123456789 _z_0123456789 = x - type family Lambda_0123456789 x y t where - Lambda_0123456789 x y arg_0123456789 = Case_0123456789 x y arg_0123456789 arg_0123456789 - type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type family Case_0123456789 x arg_0123456789 a_0123456789 t where - Case_0123456789 x arg_0123456789 a_0123456789 _z_0123456789 = x - type family Lambda_0123456789 x a_0123456789 t where - Lambda_0123456789 x a_0123456789 arg_0123456789 = Case_0123456789 x arg_0123456789 a_0123456789 arg_0123456789 - type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type family Lambda_0123456789 a_0123456789 a_0123456789 t t where - Lambda_0123456789 a_0123456789 a_0123456789 x y = x - type Lambda_0123456789Sym4 t t t t = Lambda_0123456789 t t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym3 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.()) - data Lambda_0123456789Sym3 l l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) => - Lambda_0123456789Sym3KindInference - type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type Foo8Sym1 (t :: Foo a0123456789 b0123456789) = Foo8 t - instance SuppressUnusedWarnings Foo8Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo8Sym0KindInference GHC.Tuple.()) - data Foo8Sym0 (l :: TyFun (Foo a0123456789 b0123456789) a0123456789) - = forall arg. KindOf (Apply Foo8Sym0 arg) ~ KindOf (Foo8Sym1 arg) => - Foo8Sym0KindInference - type instance Apply Foo8Sym0 l = Foo8Sym1 l - type Foo7Sym2 (t :: a0123456789) (t :: b0123456789) = Foo7 t t - instance SuppressUnusedWarnings Foo7Sym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo7Sym1KindInference GHC.Tuple.()) - data Foo7Sym1 (l :: a0123456789) - (l :: TyFun b0123456789 b0123456789) - = forall arg. KindOf (Apply (Foo7Sym1 l) arg) ~ KindOf (Foo7Sym2 l arg) => - Foo7Sym1KindInference - type instance Apply (Foo7Sym1 l) l = Foo7Sym2 l l - instance SuppressUnusedWarnings Foo7Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo7Sym0KindInference GHC.Tuple.()) - data Foo7Sym0 (l :: TyFun a0123456789 (TyFun b0123456789 b0123456789 - -> *)) - = forall arg. KindOf (Apply Foo7Sym0 arg) ~ KindOf (Foo7Sym1 arg) => - Foo7Sym0KindInference - type instance Apply Foo7Sym0 l = Foo7Sym1 l - type Foo6Sym2 (t :: a0123456789) (t :: b0123456789) = Foo6 t t - instance SuppressUnusedWarnings Foo6Sym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo6Sym1KindInference GHC.Tuple.()) - data Foo6Sym1 (l :: a0123456789) - (l :: TyFun b0123456789 a0123456789) - = forall arg. KindOf (Apply (Foo6Sym1 l) arg) ~ KindOf (Foo6Sym2 l arg) => - Foo6Sym1KindInference - type instance Apply (Foo6Sym1 l) l = Foo6Sym2 l l - instance SuppressUnusedWarnings Foo6Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo6Sym0KindInference GHC.Tuple.()) - data Foo6Sym0 (l :: TyFun a0123456789 (TyFun b0123456789 a0123456789 - -> *)) - = forall arg. KindOf (Apply Foo6Sym0 arg) ~ KindOf (Foo6Sym1 arg) => - Foo6Sym0KindInference - type instance Apply Foo6Sym0 l = Foo6Sym1 l - type Foo5Sym2 (t :: a0123456789) (t :: b0123456789) = Foo5 t t - instance SuppressUnusedWarnings Foo5Sym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo5Sym1KindInference GHC.Tuple.()) - data Foo5Sym1 (l :: a0123456789) - (l :: TyFun b0123456789 b0123456789) - = forall arg. KindOf (Apply (Foo5Sym1 l) arg) ~ KindOf (Foo5Sym2 l arg) => - Foo5Sym1KindInference - type instance Apply (Foo5Sym1 l) l = Foo5Sym2 l l - instance SuppressUnusedWarnings Foo5Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo5Sym0KindInference GHC.Tuple.()) - data Foo5Sym0 (l :: TyFun a0123456789 (TyFun b0123456789 b0123456789 - -> *)) - = forall arg. KindOf (Apply Foo5Sym0 arg) ~ KindOf (Foo5Sym1 arg) => - Foo5Sym0KindInference - type instance Apply Foo5Sym0 l = Foo5Sym1 l - type Foo4Sym3 (t :: a0123456789) - (t :: b0123456789) - (t :: c0123456789) = - Foo4 t t t - instance SuppressUnusedWarnings Foo4Sym2 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo4Sym2KindInference GHC.Tuple.()) - data Foo4Sym2 (l :: a0123456789) - (l :: b0123456789) - (l :: TyFun c0123456789 a0123456789) - = forall arg. KindOf (Apply (Foo4Sym2 l l) arg) ~ KindOf (Foo4Sym3 l l arg) => - Foo4Sym2KindInference - type instance Apply (Foo4Sym2 l l) l = Foo4Sym3 l l l - instance SuppressUnusedWarnings Foo4Sym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo4Sym1KindInference GHC.Tuple.()) - data Foo4Sym1 (l :: a0123456789) - (l :: TyFun b0123456789 (TyFun c0123456789 a0123456789 -> *)) - = forall arg. KindOf (Apply (Foo4Sym1 l) arg) ~ KindOf (Foo4Sym2 l arg) => - Foo4Sym1KindInference - type instance Apply (Foo4Sym1 l) l = Foo4Sym2 l l - instance SuppressUnusedWarnings Foo4Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo4Sym0KindInference GHC.Tuple.()) - data Foo4Sym0 (l :: TyFun a0123456789 (TyFun b0123456789 (TyFun c0123456789 a0123456789 - -> *) - -> *)) - = forall arg. KindOf (Apply Foo4Sym0 arg) ~ KindOf (Foo4Sym1 arg) => - Foo4Sym0KindInference - type instance Apply Foo4Sym0 l = Foo4Sym1 l - type Foo3Sym1 (t :: a0123456789) = Foo3 t - instance SuppressUnusedWarnings Foo3Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.()) - data Foo3Sym0 (l :: TyFun a0123456789 a0123456789) - = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) => - Foo3Sym0KindInference - type instance Apply Foo3Sym0 l = Foo3Sym1 l - type Foo2Sym2 (t :: a0123456789) (t :: b0123456789) = Foo2 t t - instance SuppressUnusedWarnings Foo2Sym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo2Sym1KindInference GHC.Tuple.()) - data Foo2Sym1 (l :: a0123456789) - (l :: TyFun b0123456789 a0123456789) - = forall arg. KindOf (Apply (Foo2Sym1 l) arg) ~ KindOf (Foo2Sym2 l arg) => - Foo2Sym1KindInference - type instance Apply (Foo2Sym1 l) l = Foo2Sym2 l l - instance SuppressUnusedWarnings Foo2Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.()) - data Foo2Sym0 (l :: TyFun a0123456789 (TyFun b0123456789 a0123456789 - -> *)) - = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) => - Foo2Sym0KindInference - type instance Apply Foo2Sym0 l = Foo2Sym1 l - type Foo1Sym2 (t :: a0123456789) (t :: b0123456789) = Foo1 t t - instance SuppressUnusedWarnings Foo1Sym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo1Sym1KindInference GHC.Tuple.()) - data Foo1Sym1 (l :: a0123456789) - (l :: TyFun b0123456789 a0123456789) - = forall arg. KindOf (Apply (Foo1Sym1 l) arg) ~ KindOf (Foo1Sym2 l arg) => - Foo1Sym1KindInference - type instance Apply (Foo1Sym1 l) l = Foo1Sym2 l l - instance SuppressUnusedWarnings Foo1Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.()) - data Foo1Sym0 (l :: TyFun a0123456789 (TyFun b0123456789 a0123456789 - -> *)) - = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) => - Foo1Sym0KindInference - type instance Apply Foo1Sym0 l = Foo1Sym1 l - type Foo0Sym2 (t :: a0123456789) (t :: b0123456789) = Foo0 t t - instance SuppressUnusedWarnings Foo0Sym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo0Sym1KindInference GHC.Tuple.()) - data Foo0Sym1 (l :: a0123456789) - (l :: TyFun b0123456789 a0123456789) - = forall arg. KindOf (Apply (Foo0Sym1 l) arg) ~ KindOf (Foo0Sym2 l arg) => - Foo0Sym1KindInference - type instance Apply (Foo0Sym1 l) l = Foo0Sym2 l l - instance SuppressUnusedWarnings Foo0Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo0Sym0KindInference GHC.Tuple.()) - data Foo0Sym0 (l :: TyFun a0123456789 (TyFun b0123456789 a0123456789 - -> *)) - = forall arg. KindOf (Apply Foo0Sym0 arg) ~ KindOf (Foo0Sym1 arg) => - Foo0Sym0KindInference - type instance Apply Foo0Sym0 l = Foo0Sym1 l - type family Foo8 (a :: Foo a b) :: a where - Foo8 x = Apply (Apply Lambda_0123456789Sym0 x) x - type family Foo7 (a :: a) (a :: b) :: b where - Foo7 x y = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) (Apply (Apply Tuple2Sym0 x) y) - type family Foo6 (a :: a) (a :: b) :: a where - Foo6 a b = Apply (Apply (Apply (Apply Lambda_0123456789Sym0 a) b) a) b - type family Foo5 (a :: a) (a :: b) :: b where - Foo5 x y = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) y - type family Foo4 (a :: a) (a :: b) (a :: c) :: a where - Foo4 x y z = Apply (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) z) y) z - type family Foo3 (a :: a) :: a where - Foo3 x = Apply (Apply Lambda_0123456789Sym0 x) x - type family Foo2 (a :: a) (a :: b) :: a where - Foo2 x y = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) y - type family Foo1 (a :: a) (a :: b) :: a where - Foo1 x a_0123456789 = Apply (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789) a_0123456789 - type family Foo0 (a :: a) (a :: b) :: a where - Foo0 a_0123456789 a_0123456789 = Apply (Apply (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789 - sFoo8 :: - forall (t :: Foo a b). Sing t -> Sing (Apply Foo8Sym0 t :: a) - sFoo7 :: - forall (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo7Sym0 t) t :: b) - sFoo6 :: - forall (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo6Sym0 t) t :: a) - sFoo5 :: - forall (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo5Sym0 t) t :: b) - sFoo4 :: - forall (t :: a) (t :: b) (t :: c). - Sing t - -> Sing t - -> Sing t -> Sing (Apply (Apply (Apply Foo4Sym0 t) t) t :: a) - sFoo3 :: forall (t :: a). Sing t -> Sing (Apply Foo3Sym0 t :: a) - sFoo2 :: - forall (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a) - sFoo1 :: - forall (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a) - sFoo0 :: - forall (t :: a) (t :: b). - Sing t -> Sing t -> Sing (Apply (Apply Foo0Sym0 t) t :: a) - sFoo8 sX - = let - lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo8Sym0 t :: a) - lambda x - = applySing - (singFun1 - (Proxy :: Proxy (Apply Lambda_0123456789Sym0 x)) - (\ sArg_0123456789 - -> let - lambda :: - forall arg_0123456789. - Sing arg_0123456789 - -> Sing (Apply (Apply Lambda_0123456789Sym0 x) arg_0123456789) - lambda arg_0123456789 - = case arg_0123456789 of { - SFoo sA _s_z_0123456789 - -> let - lambda :: - forall a - _z_0123456789. Apply (Apply FooSym0 a) _z_0123456789 ~ arg_0123456789 => - Sing a - -> Sing _z_0123456789 - -> Sing (Case_0123456789 x arg_0123456789 (Apply (Apply FooSym0 a) _z_0123456789)) - lambda a _z_0123456789 = a - in lambda sA _s_z_0123456789 } :: - Sing (Case_0123456789 x arg_0123456789 arg_0123456789) - in lambda sArg_0123456789)) - x - in lambda sX - sFoo7 sX sY - = let - lambda :: - forall x y. (t ~ x, t ~ y) => - Sing x -> Sing y -> Sing (Apply (Apply Foo7Sym0 t) t :: b) - lambda x y - = applySing - (singFun1 - (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 x) y)) - (\ sArg_0123456789 - -> let - lambda :: - forall arg_0123456789. - Sing arg_0123456789 - -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) arg_0123456789) - lambda arg_0123456789 - = case arg_0123456789 of { - STuple2 _s_z_0123456789 sB - -> let - lambda :: - forall _z_0123456789 - b. Apply (Apply Tuple2Sym0 _z_0123456789) b ~ arg_0123456789 => - Sing _z_0123456789 - -> Sing b - -> Sing (Case_0123456789 x y arg_0123456789 (Apply (Apply Tuple2Sym0 _z_0123456789) b)) - lambda _z_0123456789 b = b - in lambda _s_z_0123456789 sB } :: - Sing (Case_0123456789 x y arg_0123456789 arg_0123456789) - in lambda sArg_0123456789)) - (applySing - (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) x) y) - in lambda sX sY - sFoo6 sA sB - = let - lambda :: - forall a b. (t ~ a, t ~ b) => - Sing a -> Sing b -> Sing (Apply (Apply Foo6Sym0 t) t :: a) - lambda a b - = applySing - (applySing - (singFun1 - (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 a) b)) - (\ sX - -> let - lambda :: - forall x. - Sing x -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 a) b) x) - lambda x - = singFun1 - (Proxy :: - Proxy (Apply (Apply (Apply Lambda_0123456789Sym0 a) b) x)) - (\ sArg_0123456789 - -> let - lambda :: - forall arg_0123456789. - Sing arg_0123456789 - -> Sing (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 a) b) x) arg_0123456789) - lambda arg_0123456789 - = case arg_0123456789 of { - _s_z_0123456789 - -> let - lambda :: - forall _z_0123456789. _z_0123456789 ~ arg_0123456789 => - Sing _z_0123456789 - -> Sing (Case_0123456789 a b x arg_0123456789 _z_0123456789) - lambda _z_0123456789 = x - in lambda _s_z_0123456789 } :: - Sing (Case_0123456789 a b x arg_0123456789 arg_0123456789) - in lambda sArg_0123456789) - in lambda sX)) - a) - b - in lambda sA sB - sFoo5 sX sY - = let - lambda :: - forall x y. (t ~ x, t ~ y) => - Sing x -> Sing y -> Sing (Apply (Apply Foo5Sym0 t) t :: b) - lambda x y - = applySing - (singFun1 - (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 x) y)) - (\ sX - -> let - lambda :: - forall x. - Sing x -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) x) - lambda x = x - in lambda sX)) - y - in lambda sX sY - sFoo4 sX sY sZ - = let - lambda :: - forall x y z. (t ~ x, t ~ y, t ~ z) => - Sing x - -> Sing y - -> Sing z -> Sing (Apply (Apply (Apply Foo4Sym0 t) t) t :: a) - lambda x y z - = applySing - (applySing - (singFun2 - (Proxy :: - Proxy (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) z)) - (\ sArg_0123456789 sArg_0123456789 - -> let - lambda :: - forall arg_0123456789 arg_0123456789. - Sing arg_0123456789 - -> Sing arg_0123456789 - -> Sing (Apply (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) z) arg_0123456789) arg_0123456789) - lambda arg_0123456789 arg_0123456789 - = case - applySing - (applySing - (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) - arg_0123456789) - arg_0123456789 - of { - STuple2 _s_z_0123456789 _s_z_0123456789 - -> let - lambda :: - forall _z_0123456789 - _z_0123456789. Apply (Apply Tuple2Sym0 _z_0123456789) _z_0123456789 ~ Apply (Apply Tuple2Sym0 arg_0123456789) arg_0123456789 => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Case_0123456789 x y z arg_0123456789 arg_0123456789 (Apply (Apply Tuple2Sym0 _z_0123456789) _z_0123456789)) - lambda _z_0123456789 _z_0123456789 = x - in lambda _s_z_0123456789 _s_z_0123456789 } :: - Sing (Case_0123456789 x y z arg_0123456789 arg_0123456789 (Apply (Apply Tuple2Sym0 arg_0123456789) arg_0123456789)) - in lambda sArg_0123456789 sArg_0123456789)) - y) - z - in lambda sX sY sZ - sFoo3 sX - = let - lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo3Sym0 t :: a) - lambda x - = applySing - (singFun1 - (Proxy :: Proxy (Apply Lambda_0123456789Sym0 x)) - (\ sY - -> let - lambda :: - forall y. Sing y -> Sing (Apply (Apply Lambda_0123456789Sym0 x) y) - lambda y = y - in lambda sY)) - x - in lambda sX - sFoo2 sX sY - = let - lambda :: - forall x y. (t ~ x, t ~ y) => - Sing x -> Sing y -> Sing (Apply (Apply Foo2Sym0 t) t :: a) - lambda x y - = applySing - (singFun1 - (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 x) y)) - (\ sArg_0123456789 - -> let - lambda :: - forall arg_0123456789. - Sing arg_0123456789 - -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) arg_0123456789) - lambda arg_0123456789 - = case arg_0123456789 of { - _s_z_0123456789 - -> let - lambda :: - forall _z_0123456789. _z_0123456789 ~ arg_0123456789 => - Sing _z_0123456789 - -> Sing (Case_0123456789 x y arg_0123456789 _z_0123456789) - lambda _z_0123456789 = x - in lambda _s_z_0123456789 } :: - Sing (Case_0123456789 x y arg_0123456789 arg_0123456789) - in lambda sArg_0123456789)) - y - in lambda sX sY - sFoo1 sX sA_0123456789 - = let - lambda :: - forall x a_0123456789. (t ~ x, t ~ a_0123456789) => - Sing x - -> Sing a_0123456789 -> Sing (Apply (Apply Foo1Sym0 t) t :: a) - lambda x a_0123456789 - = applySing - (singFun1 - (Proxy :: - Proxy (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789)) - (\ sArg_0123456789 - -> let - lambda :: - forall arg_0123456789. - Sing arg_0123456789 - -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789) arg_0123456789) - lambda arg_0123456789 - = case arg_0123456789 of { - _s_z_0123456789 - -> let - lambda :: - forall _z_0123456789. _z_0123456789 ~ arg_0123456789 => - Sing _z_0123456789 - -> Sing (Case_0123456789 x arg_0123456789 a_0123456789 _z_0123456789) - lambda _z_0123456789 = x - in lambda _s_z_0123456789 } :: - Sing (Case_0123456789 x arg_0123456789 a_0123456789 arg_0123456789) - in lambda sArg_0123456789)) - a_0123456789 - in lambda sX sA_0123456789 - sFoo0 sA_0123456789 sA_0123456789 - = let - lambda :: - forall a_0123456789 a_0123456789. (t ~ a_0123456789, - t ~ a_0123456789) => - Sing a_0123456789 - -> Sing a_0123456789 -> Sing (Apply (Apply Foo0Sym0 t) t :: a) - lambda a_0123456789 a_0123456789 - = applySing - (applySing - (singFun2 - (Proxy :: - Proxy (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789)) - (\ sX sY - -> let - lambda :: - forall x y. - Sing x - -> Sing y - -> Sing (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 a_0123456789) a_0123456789) x) y) - lambda x y = x - in lambda sX sY)) - a_0123456789) - a_0123456789 - in lambda sA_0123456789 sA_0123456789 - data instance Sing (z :: Foo a b) - = forall (n :: a) (n :: b). z ~ Foo n n => - SFoo (Sing (n :: a)) (Sing (n :: b)) - type SFoo = (Sing :: Foo a b -> *) - instance (SingKind (KProxy :: KProxy a), - SingKind (KProxy :: KProxy b)) => - SingKind (KProxy :: KProxy (Foo a b)) where - type DemoteRep (KProxy :: KProxy (Foo a b)) = Foo (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b)) - fromSing (SFoo b b) = Foo (fromSing b) (fromSing b) - toSing (Foo b b) - = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) - of { - GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SFoo c c) } - instance (SingI n, SingI n) => SingI (Foo (n :: a) (n :: b)) where - sing = SFoo sing sing diff --git a/tests/compile-and-dump/Singletons/Lambdas.ghc80.template b/tests/compile-and-dump/Singletons/Lambdas.ghc80.template --- a/tests/compile-and-dump/Singletons/Lambdas.ghc80.template +++ b/tests/compile-and-dump/Singletons/Lambdas.ghc80.template @@ -830,16 +830,12 @@ = forall (n :: a) (n :: b). z ~ Foo n n => SFoo (Sing (n :: a)) (Sing (n :: b)) type SFoo = (Sing :: Foo a b -> GHC.Types.Type) - instance (SingKind (KProxy :: KProxy a), - SingKind (KProxy :: KProxy b)) => - SingKind (KProxy :: KProxy (Foo a b)) where - type DemoteRep (KProxy :: KProxy (Foo a b)) = Foo (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b)) + instance (SingKind a, SingKind b) => SingKind (Foo a b) where + type DemoteRep (Foo a b) = Foo (DemoteRep a) (DemoteRep b) fromSing (SFoo b b) = Foo (fromSing b) (fromSing b) toSing (Foo b b) = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) + GHC.Tuple.(,) (toSing b :: SomeSing a) (toSing b :: SomeSing b) of { GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SFoo c c) } instance (SingI n, SingI n) => SingI (Foo (n :: a) (n :: b)) where diff --git a/tests/compile-and-dump/Singletons/LambdasComprehensive.ghc710.template b/tests/compile-and-dump/Singletons/LambdasComprehensive.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/LambdasComprehensive.ghc710.template +++ /dev/null @@ -1,81 +0,0 @@ -Singletons/LambdasComprehensive.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| foo :: [Nat] - foo - = map (\ x -> either_ pred Succ x) [Left Zero, Right (Succ Zero)] - bar :: [Nat] - bar = map (either_ pred Succ) [Left Zero, Right (Succ Zero)] |] - ======> - foo :: [Nat] - foo - = map (\ x -> either_ pred Succ x) [Left Zero, Right (Succ Zero)] - bar :: [Nat] - bar = map (either_ pred Succ) [Left Zero, Right (Succ Zero)] - type family Lambda_0123456789 t where - Lambda_0123456789 x = Apply (Apply (Apply Either_Sym0 PredSym0) SuccSym0) x - type Lambda_0123456789Sym1 t = Lambda_0123456789 t - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type BarSym0 = Bar - type FooSym0 = Foo - type family Bar :: [Nat] where - Bar = Apply (Apply MapSym0 (Apply (Apply Either_Sym0 PredSym0) SuccSym0)) (Apply (Apply (:$) (Apply LeftSym0 ZeroSym0)) (Apply (Apply (:$) (Apply RightSym0 (Apply SuccSym0 ZeroSym0))) '[])) - type family Foo :: [Nat] where - Foo = Apply (Apply MapSym0 Lambda_0123456789Sym0) (Apply (Apply (:$) (Apply LeftSym0 ZeroSym0)) (Apply (Apply (:$) (Apply RightSym0 (Apply SuccSym0 ZeroSym0))) '[])) - sBar :: Sing (BarSym0 :: [Nat]) - sFoo :: Sing (FooSym0 :: [Nat]) - sBar - = applySing - (applySing - (singFun2 (Proxy :: Proxy MapSym0) sMap) - (applySing - (applySing - (singFun3 (Proxy :: Proxy Either_Sym0) sEither_) - (singFun1 (Proxy :: Proxy PredSym0) sPred)) - (singFun1 (Proxy :: Proxy SuccSym0) SSucc))) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing (singFun1 (Proxy :: Proxy LeftSym0) SLeft) SZero)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (singFun1 (Proxy :: Proxy RightSym0) SRight) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))) - SNil)) - sFoo - = applySing - (applySing - (singFun2 (Proxy :: Proxy MapSym0) sMap) - (singFun1 - (Proxy :: Proxy Lambda_0123456789Sym0) - (\ sX - -> let - lambda :: forall x. Sing x -> Sing (Apply Lambda_0123456789Sym0 x) - lambda x - = applySing - (applySing - (applySing - (singFun3 (Proxy :: Proxy Either_Sym0) sEither_) - (singFun1 (Proxy :: Proxy PredSym0) sPred)) - (singFun1 (Proxy :: Proxy SuccSym0) SSucc)) - x - in lambda sX))) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing (singFun1 (Proxy :: Proxy LeftSym0) SLeft) SZero)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (singFun1 (Proxy :: Proxy RightSym0) SRight) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))) - SNil)) diff --git a/tests/compile-and-dump/Singletons/LetStatements.ghc710.template b/tests/compile-and-dump/Singletons/LetStatements.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/LetStatements.ghc710.template +++ /dev/null @@ -1,1022 +0,0 @@ -Singletons/LetStatements.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| foo1 :: Nat -> Nat - foo1 x - = let - y :: Nat - y = Succ Zero - in y - foo2 :: Nat - foo2 - = let - y = Succ Zero - z = Succ y - in z - foo3 :: Nat -> Nat - foo3 x - = let - y :: Nat - y = Succ x - in y - foo4 :: Nat -> Nat - foo4 x - = let - f :: Nat -> Nat - f y = Succ y - in f x - foo5 :: Nat -> Nat - foo5 x - = let - f :: Nat -> Nat - f y - = let - z :: Nat - z = Succ y - in Succ z - in f x - foo6 :: Nat -> Nat - foo6 x - = let - f :: Nat -> Nat - f y = Succ y in - let - z :: Nat - z = f x - in z - foo7 :: Nat -> Nat - foo7 x - = let - x :: Nat - x = Zero - in x - foo8 :: Nat -> Nat - foo8 x - = let - z :: Nat - z = (\ x -> x) Zero - in z - foo9 :: Nat -> Nat - foo9 x - = let - z :: Nat -> Nat - z = (\ x -> x) - in z x - foo10 :: Nat -> Nat - foo10 x - = let - (+) :: Nat -> Nat -> Nat - Zero + m = m - (Succ n) + m = Succ (n + m) - in (Succ Zero) + x - foo11 :: Nat -> Nat - foo11 x - = let - (+) :: Nat -> Nat -> Nat - Zero + m = m - (Succ n) + m = Succ (n + m) - z :: Nat - z = x - in (Succ Zero) + z - foo12 :: Nat -> Nat - foo12 x - = let - (+) :: Nat -> Nat -> Nat - Zero + m = m - (Succ n) + m = Succ (n + x) - in x + (Succ (Succ Zero)) - foo13 :: forall a. a -> a - foo13 x - = let - bar :: a - bar = x - in foo13_ bar - foo13_ :: a -> a - foo13_ y = y - foo14 :: Nat -> (Nat, Nat) - foo14 x = let (y, z) = (Succ x, x) in (z, y) |] - ======> - foo1 :: Nat -> Nat - foo1 x - = let - y :: Nat - y = Succ Zero - in y - foo2 :: Nat - foo2 - = let - y = Succ Zero - z = Succ y - in z - foo3 :: Nat -> Nat - foo3 x - = let - y :: Nat - y = Succ x - in y - foo4 :: Nat -> Nat - foo4 x - = let - f :: Nat -> Nat - f y = Succ y - in f x - foo5 :: Nat -> Nat - foo5 x - = let - f :: Nat -> Nat - f y - = let - z :: Nat - z = Succ y - in Succ z - in f x - foo6 :: Nat -> Nat - foo6 x - = let - f :: Nat -> Nat - f y = Succ y in - let - z :: Nat - z = f x - in z - foo7 :: Nat -> Nat - foo7 x - = let - x :: Nat - x = Zero - in x - foo8 :: Nat -> Nat - foo8 x - = let - z :: Nat - z = \ x -> x Zero - in z - foo9 :: Nat -> Nat - foo9 x - = let - z :: Nat -> Nat - z = \ x -> x - in z x - foo10 :: Nat -> Nat - foo10 x - = let - (+) :: Nat -> Nat -> Nat - (+) Zero m = m - (+) (Succ n) m = Succ (n + m) - in ((Succ Zero) + x) - foo11 :: Nat -> Nat - foo11 x - = let - (+) :: Nat -> Nat -> Nat - z :: Nat - (+) Zero m = m - (+) (Succ n) m = Succ (n + m) - z = x - in ((Succ Zero) + z) - foo12 :: Nat -> Nat - foo12 x - = let - (+) :: Nat -> Nat -> Nat - (+) Zero m = m - (+) (Succ n) m = Succ (n + x) - in (x + (Succ (Succ Zero))) - foo13 :: forall a. a -> a - foo13 x - = let - bar :: a - bar = x - in foo13_ bar - foo13_ :: forall a. a -> a - foo13_ y = y - foo14 :: Nat -> (Nat, Nat) - foo14 x = let (y, z) = (Succ x, x) in (z, y) - type family Case_0123456789 x t where - Case_0123456789 x '(y_0123456789, _z_0123456789) = y_0123456789 - type family Case_0123456789 x t where - Case_0123456789 x '(_z_0123456789, y_0123456789) = y_0123456789 - type Let0123456789YSym1 t = Let0123456789Y t - instance SuppressUnusedWarnings Let0123456789YSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789YSym0KindInference GHC.Tuple.()) - data Let0123456789YSym0 l - = forall arg. KindOf (Apply Let0123456789YSym0 arg) ~ KindOf (Let0123456789YSym1 arg) => - Let0123456789YSym0KindInference - type instance Apply Let0123456789YSym0 l = Let0123456789YSym1 l - type Let0123456789ZSym1 t = Let0123456789Z t - instance SuppressUnusedWarnings Let0123456789ZSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.()) - data Let0123456789ZSym0 l - = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) => - Let0123456789ZSym0KindInference - type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l - type Let0123456789X_0123456789Sym1 t = Let0123456789X_0123456789 t - instance SuppressUnusedWarnings Let0123456789X_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) - Let0123456789X_0123456789Sym0KindInference GHC.Tuple.()) - data Let0123456789X_0123456789Sym0 l - = forall arg. KindOf (Apply Let0123456789X_0123456789Sym0 arg) ~ KindOf (Let0123456789X_0123456789Sym1 arg) => - Let0123456789X_0123456789Sym0KindInference - type instance Apply Let0123456789X_0123456789Sym0 l = Let0123456789X_0123456789Sym1 l - type family Let0123456789Y x where - Let0123456789Y x = Case_0123456789 x (Let0123456789X_0123456789Sym1 x) - type family Let0123456789Z x where - Let0123456789Z x = Case_0123456789 x (Let0123456789X_0123456789Sym1 x) - type family Let0123456789X_0123456789 x where - Let0123456789X_0123456789 x = Apply (Apply Tuple2Sym0 (Apply SuccSym0 x)) x - type Let0123456789BarSym1 t = Let0123456789Bar t - instance SuppressUnusedWarnings Let0123456789BarSym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Let0123456789BarSym0KindInference GHC.Tuple.()) - data Let0123456789BarSym0 l - = forall arg. KindOf (Apply Let0123456789BarSym0 arg) ~ KindOf (Let0123456789BarSym1 arg) => - Let0123456789BarSym0KindInference - type instance Apply Let0123456789BarSym0 l = Let0123456789BarSym1 l - type family Let0123456789Bar x :: a where - Let0123456789Bar x = x - type (:<<<%%%%%%%%%%:+$$$$) t (t :: Nat) (t :: Nat) = - (:<<<%%%%%%%%%%:+) t t t - instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$$###) GHC.Tuple.()) - data (:<<<%%%%%%%%%%:+$$$) l (l :: Nat) (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$$) l l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$$) l l arg) => - :<<<%%%%%%%%%%:+$$$### - type instance Apply ((:<<<%%%%%%%%%%:+$$$) l l) l = (:<<<%%%%%%%%%%:+$$$$) l l l - instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$###) GHC.Tuple.()) - data (:<<<%%%%%%%%%%:+$$) l (l :: TyFun Nat (TyFun Nat Nat -> *)) - = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$) l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$) l arg) => - :<<<%%%%%%%%%%:+$$### - type instance Apply ((:<<<%%%%%%%%%%:+$$) l) l = (:<<<%%%%%%%%%%:+$$$) l l - instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$###) GHC.Tuple.()) - data (:<<<%%%%%%%%%%:+$) l - = forall arg. KindOf (Apply (:<<<%%%%%%%%%%:+$) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$) arg) => - :<<<%%%%%%%%%%:+$### - type instance Apply (:<<<%%%%%%%%%%:+$) l = (:<<<%%%%%%%%%%:+$$) l - type family (:<<<%%%%%%%%%%:+) x (a :: Nat) (a :: Nat) :: Nat where - (:<<<%%%%%%%%%%:+) x Zero m = m - (:<<<%%%%%%%%%%:+) x (Succ n) m = Apply SuccSym0 (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) n) x) - type Let0123456789ZSym1 t = Let0123456789Z t - instance SuppressUnusedWarnings Let0123456789ZSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.()) - data Let0123456789ZSym0 l - = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) => - Let0123456789ZSym0KindInference - type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l - type (:<<<%%%%%%%%%%:+$$$$) t (t :: Nat) (t :: Nat) = - (:<<<%%%%%%%%%%:+) t t t - instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$$###) GHC.Tuple.()) - data (:<<<%%%%%%%%%%:+$$$) l (l :: Nat) (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$$) l l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$$) l l arg) => - :<<<%%%%%%%%%%:+$$$### - type instance Apply ((:<<<%%%%%%%%%%:+$$$) l l) l = (:<<<%%%%%%%%%%:+$$$$) l l l - instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$###) GHC.Tuple.()) - data (:<<<%%%%%%%%%%:+$$) l (l :: TyFun Nat (TyFun Nat Nat -> *)) - = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$) l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$) l arg) => - :<<<%%%%%%%%%%:+$$### - type instance Apply ((:<<<%%%%%%%%%%:+$$) l) l = (:<<<%%%%%%%%%%:+$$$) l l - instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$###) GHC.Tuple.()) - data (:<<<%%%%%%%%%%:+$) l - = forall arg. KindOf (Apply (:<<<%%%%%%%%%%:+$) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$) arg) => - :<<<%%%%%%%%%%:+$### - type instance Apply (:<<<%%%%%%%%%%:+$) l = (:<<<%%%%%%%%%%:+$$) l - type family Let0123456789Z x :: Nat where - Let0123456789Z x = x - type family (:<<<%%%%%%%%%%:+) x (a :: Nat) (a :: Nat) :: Nat where - (:<<<%%%%%%%%%%:+) x Zero m = m - (:<<<%%%%%%%%%%:+) x (Succ n) m = Apply SuccSym0 (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) n) m) - type (:<<<%%%%%%%%%%:+$$$$) t (t :: Nat) (t :: Nat) = - (:<<<%%%%%%%%%%:+) t t t - instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$$###) GHC.Tuple.()) - data (:<<<%%%%%%%%%%:+$$$) l (l :: Nat) (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$$) l l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$$) l l arg) => - :<<<%%%%%%%%%%:+$$$### - type instance Apply ((:<<<%%%%%%%%%%:+$$$) l l) l = (:<<<%%%%%%%%%%:+$$$$) l l l - instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$###) GHC.Tuple.()) - data (:<<<%%%%%%%%%%:+$$) l (l :: TyFun Nat (TyFun Nat Nat -> *)) - = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$) l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$) l arg) => - :<<<%%%%%%%%%%:+$$### - type instance Apply ((:<<<%%%%%%%%%%:+$$) l) l = (:<<<%%%%%%%%%%:+$$$) l l - instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$###) GHC.Tuple.()) - data (:<<<%%%%%%%%%%:+$) l - = forall arg. KindOf (Apply (:<<<%%%%%%%%%%:+$) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$) arg) => - :<<<%%%%%%%%%%:+$### - type instance Apply (:<<<%%%%%%%%%%:+$) l = (:<<<%%%%%%%%%%:+$$) l - type family (:<<<%%%%%%%%%%:+) x (a :: Nat) (a :: Nat) :: Nat where - (:<<<%%%%%%%%%%:+) x Zero m = m - (:<<<%%%%%%%%%%:+) x (Succ n) m = Apply SuccSym0 (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) n) m) - type family Lambda_0123456789 x a_0123456789 t where - Lambda_0123456789 x a_0123456789 x = x - type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type Let0123456789ZSym2 t (t :: Nat) = Let0123456789Z t t - instance SuppressUnusedWarnings Let0123456789ZSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789ZSym1KindInference GHC.Tuple.()) - data Let0123456789ZSym1 l (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply (Let0123456789ZSym1 l) arg) ~ KindOf (Let0123456789ZSym2 l arg) => - Let0123456789ZSym1KindInference - type instance Apply (Let0123456789ZSym1 l) l = Let0123456789ZSym2 l l - instance SuppressUnusedWarnings Let0123456789ZSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.()) - data Let0123456789ZSym0 l - = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) => - Let0123456789ZSym0KindInference - type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l - type family Let0123456789Z x (a :: Nat) :: Nat where - Let0123456789Z x a_0123456789 = Apply (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789) a_0123456789 - type family Lambda_0123456789 x t where - Lambda_0123456789 x x = x - type Lambda_0123456789Sym2 t t = Lambda_0123456789 t t - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type Let0123456789ZSym1 t = Let0123456789Z t - instance SuppressUnusedWarnings Let0123456789ZSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.()) - data Let0123456789ZSym0 l - = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) => - Let0123456789ZSym0KindInference - type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l - type family Let0123456789Z x :: Nat where - Let0123456789Z x = Apply (Apply Lambda_0123456789Sym0 x) ZeroSym0 - type Let0123456789XSym1 t = Let0123456789X t - instance SuppressUnusedWarnings Let0123456789XSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789XSym0KindInference GHC.Tuple.()) - data Let0123456789XSym0 l - = forall arg. KindOf (Apply Let0123456789XSym0 arg) ~ KindOf (Let0123456789XSym1 arg) => - Let0123456789XSym0KindInference - type instance Apply Let0123456789XSym0 l = Let0123456789XSym1 l - type family Let0123456789X x :: Nat where - Let0123456789X x = ZeroSym0 - type Let0123456789FSym2 t (t :: Nat) = Let0123456789F t t - instance SuppressUnusedWarnings Let0123456789FSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789FSym1KindInference GHC.Tuple.()) - data Let0123456789FSym1 l (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply (Let0123456789FSym1 l) arg) ~ KindOf (Let0123456789FSym2 l arg) => - Let0123456789FSym1KindInference - type instance Apply (Let0123456789FSym1 l) l = Let0123456789FSym2 l l - instance SuppressUnusedWarnings Let0123456789FSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789FSym0KindInference GHC.Tuple.()) - data Let0123456789FSym0 l - = forall arg. KindOf (Apply Let0123456789FSym0 arg) ~ KindOf (Let0123456789FSym1 arg) => - Let0123456789FSym0KindInference - type instance Apply Let0123456789FSym0 l = Let0123456789FSym1 l - type family Let0123456789F x (a :: Nat) :: Nat where - Let0123456789F x y = Apply SuccSym0 y - type Let0123456789ZSym1 t = Let0123456789Z t - instance SuppressUnusedWarnings Let0123456789ZSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.()) - data Let0123456789ZSym0 l - = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) => - Let0123456789ZSym0KindInference - type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l - type family Let0123456789Z x :: Nat where - Let0123456789Z x = Apply (Let0123456789FSym1 x) x - type Let0123456789ZSym2 t t = Let0123456789Z t t - instance SuppressUnusedWarnings Let0123456789ZSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789ZSym1KindInference GHC.Tuple.()) - data Let0123456789ZSym1 l l - = forall arg. KindOf (Apply (Let0123456789ZSym1 l) arg) ~ KindOf (Let0123456789ZSym2 l arg) => - Let0123456789ZSym1KindInference - type instance Apply (Let0123456789ZSym1 l) l = Let0123456789ZSym2 l l - instance SuppressUnusedWarnings Let0123456789ZSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.()) - data Let0123456789ZSym0 l - = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) => - Let0123456789ZSym0KindInference - type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l - type family Let0123456789Z x y :: Nat where - Let0123456789Z x y = Apply SuccSym0 y - type Let0123456789FSym2 t (t :: Nat) = Let0123456789F t t - instance SuppressUnusedWarnings Let0123456789FSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789FSym1KindInference GHC.Tuple.()) - data Let0123456789FSym1 l (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply (Let0123456789FSym1 l) arg) ~ KindOf (Let0123456789FSym2 l arg) => - Let0123456789FSym1KindInference - type instance Apply (Let0123456789FSym1 l) l = Let0123456789FSym2 l l - instance SuppressUnusedWarnings Let0123456789FSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789FSym0KindInference GHC.Tuple.()) - data Let0123456789FSym0 l - = forall arg. KindOf (Apply Let0123456789FSym0 arg) ~ KindOf (Let0123456789FSym1 arg) => - Let0123456789FSym0KindInference - type instance Apply Let0123456789FSym0 l = Let0123456789FSym1 l - type family Let0123456789F x (a :: Nat) :: Nat where - Let0123456789F x y = Apply SuccSym0 (Let0123456789ZSym2 x y) - type Let0123456789FSym2 t (t :: Nat) = Let0123456789F t t - instance SuppressUnusedWarnings Let0123456789FSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789FSym1KindInference GHC.Tuple.()) - data Let0123456789FSym1 l (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply (Let0123456789FSym1 l) arg) ~ KindOf (Let0123456789FSym2 l arg) => - Let0123456789FSym1KindInference - type instance Apply (Let0123456789FSym1 l) l = Let0123456789FSym2 l l - instance SuppressUnusedWarnings Let0123456789FSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789FSym0KindInference GHC.Tuple.()) - data Let0123456789FSym0 l - = forall arg. KindOf (Apply Let0123456789FSym0 arg) ~ KindOf (Let0123456789FSym1 arg) => - Let0123456789FSym0KindInference - type instance Apply Let0123456789FSym0 l = Let0123456789FSym1 l - type family Let0123456789F x (a :: Nat) :: Nat where - Let0123456789F x y = Apply SuccSym0 y - type Let0123456789YSym1 t = Let0123456789Y t - instance SuppressUnusedWarnings Let0123456789YSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789YSym0KindInference GHC.Tuple.()) - data Let0123456789YSym0 l - = forall arg. KindOf (Apply Let0123456789YSym0 arg) ~ KindOf (Let0123456789YSym1 arg) => - Let0123456789YSym0KindInference - type instance Apply Let0123456789YSym0 l = Let0123456789YSym1 l - type family Let0123456789Y x :: Nat where - Let0123456789Y x = Apply SuccSym0 x - type Let0123456789YSym0 = Let0123456789Y - type Let0123456789ZSym0 = Let0123456789Z - type family Let0123456789Y where - Let0123456789Y = Apply SuccSym0 ZeroSym0 - type family Let0123456789Z where - Let0123456789Z = Apply SuccSym0 Let0123456789YSym0 - type Let0123456789YSym1 t = Let0123456789Y t - instance SuppressUnusedWarnings Let0123456789YSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789YSym0KindInference GHC.Tuple.()) - data Let0123456789YSym0 l - = forall arg. KindOf (Apply Let0123456789YSym0 arg) ~ KindOf (Let0123456789YSym1 arg) => - Let0123456789YSym0KindInference - type instance Apply Let0123456789YSym0 l = Let0123456789YSym1 l - type family Let0123456789Y x :: Nat where - Let0123456789Y x = Apply SuccSym0 ZeroSym0 - type Foo14Sym1 (t :: Nat) = Foo14 t - instance SuppressUnusedWarnings Foo14Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo14Sym0KindInference GHC.Tuple.()) - data Foo14Sym0 (l :: TyFun Nat (Nat, Nat)) - = forall arg. KindOf (Apply Foo14Sym0 arg) ~ KindOf (Foo14Sym1 arg) => - Foo14Sym0KindInference - type instance Apply Foo14Sym0 l = Foo14Sym1 l - type Foo13_Sym1 (t :: a0123456789) = Foo13_ t - instance SuppressUnusedWarnings Foo13_Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo13_Sym0KindInference GHC.Tuple.()) - data Foo13_Sym0 (l :: TyFun a0123456789 a0123456789) - = forall arg. KindOf (Apply Foo13_Sym0 arg) ~ KindOf (Foo13_Sym1 arg) => - Foo13_Sym0KindInference - type instance Apply Foo13_Sym0 l = Foo13_Sym1 l - type Foo13Sym1 (t :: a0123456789) = Foo13 t - instance SuppressUnusedWarnings Foo13Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo13Sym0KindInference GHC.Tuple.()) - data Foo13Sym0 (l :: TyFun a0123456789 a0123456789) - = forall arg. KindOf (Apply Foo13Sym0 arg) ~ KindOf (Foo13Sym1 arg) => - Foo13Sym0KindInference - type instance Apply Foo13Sym0 l = Foo13Sym1 l - type Foo12Sym1 (t :: Nat) = Foo12 t - instance SuppressUnusedWarnings Foo12Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo12Sym0KindInference GHC.Tuple.()) - data Foo12Sym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply Foo12Sym0 arg) ~ KindOf (Foo12Sym1 arg) => - Foo12Sym0KindInference - type instance Apply Foo12Sym0 l = Foo12Sym1 l - type Foo11Sym1 (t :: Nat) = Foo11 t - instance SuppressUnusedWarnings Foo11Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo11Sym0KindInference GHC.Tuple.()) - data Foo11Sym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply Foo11Sym0 arg) ~ KindOf (Foo11Sym1 arg) => - Foo11Sym0KindInference - type instance Apply Foo11Sym0 l = Foo11Sym1 l - type Foo10Sym1 (t :: Nat) = Foo10 t - instance SuppressUnusedWarnings Foo10Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo10Sym0KindInference GHC.Tuple.()) - data Foo10Sym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply Foo10Sym0 arg) ~ KindOf (Foo10Sym1 arg) => - Foo10Sym0KindInference - type instance Apply Foo10Sym0 l = Foo10Sym1 l - type Foo9Sym1 (t :: Nat) = Foo9 t - instance SuppressUnusedWarnings Foo9Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo9Sym0KindInference GHC.Tuple.()) - data Foo9Sym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply Foo9Sym0 arg) ~ KindOf (Foo9Sym1 arg) => - Foo9Sym0KindInference - type instance Apply Foo9Sym0 l = Foo9Sym1 l - type Foo8Sym1 (t :: Nat) = Foo8 t - instance SuppressUnusedWarnings Foo8Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo8Sym0KindInference GHC.Tuple.()) - data Foo8Sym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply Foo8Sym0 arg) ~ KindOf (Foo8Sym1 arg) => - Foo8Sym0KindInference - type instance Apply Foo8Sym0 l = Foo8Sym1 l - type Foo7Sym1 (t :: Nat) = Foo7 t - instance SuppressUnusedWarnings Foo7Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo7Sym0KindInference GHC.Tuple.()) - data Foo7Sym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply Foo7Sym0 arg) ~ KindOf (Foo7Sym1 arg) => - Foo7Sym0KindInference - type instance Apply Foo7Sym0 l = Foo7Sym1 l - type Foo6Sym1 (t :: Nat) = Foo6 t - instance SuppressUnusedWarnings Foo6Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo6Sym0KindInference GHC.Tuple.()) - data Foo6Sym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply Foo6Sym0 arg) ~ KindOf (Foo6Sym1 arg) => - Foo6Sym0KindInference - type instance Apply Foo6Sym0 l = Foo6Sym1 l - type Foo5Sym1 (t :: Nat) = Foo5 t - instance SuppressUnusedWarnings Foo5Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo5Sym0KindInference GHC.Tuple.()) - data Foo5Sym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply Foo5Sym0 arg) ~ KindOf (Foo5Sym1 arg) => - Foo5Sym0KindInference - type instance Apply Foo5Sym0 l = Foo5Sym1 l - type Foo4Sym1 (t :: Nat) = Foo4 t - instance SuppressUnusedWarnings Foo4Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo4Sym0KindInference GHC.Tuple.()) - data Foo4Sym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply Foo4Sym0 arg) ~ KindOf (Foo4Sym1 arg) => - Foo4Sym0KindInference - type instance Apply Foo4Sym0 l = Foo4Sym1 l - type Foo3Sym1 (t :: Nat) = Foo3 t - instance SuppressUnusedWarnings Foo3Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo3Sym0KindInference GHC.Tuple.()) - data Foo3Sym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply Foo3Sym0 arg) ~ KindOf (Foo3Sym1 arg) => - Foo3Sym0KindInference - type instance Apply Foo3Sym0 l = Foo3Sym1 l - type Foo2Sym0 = Foo2 - type Foo1Sym1 (t :: Nat) = Foo1 t - instance SuppressUnusedWarnings Foo1Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.()) - data Foo1Sym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) => - Foo1Sym0KindInference - type instance Apply Foo1Sym0 l = Foo1Sym1 l - type family Foo14 (a :: Nat) :: (Nat, Nat) where - Foo14 x = Apply (Apply Tuple2Sym0 (Let0123456789ZSym1 x)) (Let0123456789YSym1 x) - type family Foo13_ (a :: a) :: a where - Foo13_ y = y - type family Foo13 (a :: a) :: a where - Foo13 x = Apply Foo13_Sym0 (Let0123456789BarSym1 x) - type family Foo12 (a :: Nat) :: Nat where - Foo12 x = Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) x) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0)) - type family Foo11 (a :: Nat) :: Nat where - Foo11 x = Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 ZeroSym0)) (Let0123456789ZSym1 x) - type family Foo10 (a :: Nat) :: Nat where - Foo10 x = Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 ZeroSym0)) x - type family Foo9 (a :: Nat) :: Nat where - Foo9 x = Apply (Let0123456789ZSym1 x) x - type family Foo8 (a :: Nat) :: Nat where - Foo8 x = Let0123456789ZSym1 x - type family Foo7 (a :: Nat) :: Nat where - Foo7 x = Let0123456789XSym1 x - type family Foo6 (a :: Nat) :: Nat where - Foo6 x = Let0123456789ZSym1 x - type family Foo5 (a :: Nat) :: Nat where - Foo5 x = Apply (Let0123456789FSym1 x) x - type family Foo4 (a :: Nat) :: Nat where - Foo4 x = Apply (Let0123456789FSym1 x) x - type family Foo3 (a :: Nat) :: Nat where - Foo3 x = Let0123456789YSym1 x - type family Foo2 :: Nat where - Foo2 = Let0123456789ZSym0 - type family Foo1 (a :: Nat) :: Nat where - Foo1 x = Let0123456789YSym1 x - sFoo14 :: - forall (t :: Nat). Sing t -> Sing (Apply Foo14Sym0 t :: (Nat, Nat)) - sFoo13_ :: - forall (t :: a). Sing t -> Sing (Apply Foo13_Sym0 t :: a) - sFoo13 :: forall (t :: a). Sing t -> Sing (Apply Foo13Sym0 t :: a) - sFoo12 :: - forall (t :: Nat). Sing t -> Sing (Apply Foo12Sym0 t :: Nat) - sFoo11 :: - forall (t :: Nat). Sing t -> Sing (Apply Foo11Sym0 t :: Nat) - sFoo10 :: - forall (t :: Nat). Sing t -> Sing (Apply Foo10Sym0 t :: Nat) - sFoo9 :: - forall (t :: Nat). Sing t -> Sing (Apply Foo9Sym0 t :: Nat) - sFoo8 :: - forall (t :: Nat). Sing t -> Sing (Apply Foo8Sym0 t :: Nat) - sFoo7 :: - forall (t :: Nat). Sing t -> Sing (Apply Foo7Sym0 t :: Nat) - sFoo6 :: - forall (t :: Nat). Sing t -> Sing (Apply Foo6Sym0 t :: Nat) - sFoo5 :: - forall (t :: Nat). Sing t -> Sing (Apply Foo5Sym0 t :: Nat) - sFoo4 :: - forall (t :: Nat). Sing t -> Sing (Apply Foo4Sym0 t :: Nat) - sFoo3 :: - forall (t :: Nat). Sing t -> Sing (Apply Foo3Sym0 t :: Nat) - sFoo2 :: Sing (Foo2Sym0 :: Nat) - sFoo1 :: - forall (t :: Nat). Sing t -> Sing (Apply Foo1Sym0 t :: Nat) - sFoo14 sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply Foo14Sym0 t :: (Nat, Nat)) - lambda x - = let - sY :: Sing (Let0123456789YSym1 x) - sZ :: Sing (Let0123456789ZSym1 x) - sX_0123456789 :: Sing (Let0123456789X_0123456789Sym1 x) - sY - = case sX_0123456789 of { - STuple2 sY_0123456789 _s_z_0123456789 - -> let - lambda :: - forall y_0123456789 - _z_0123456789. Apply (Apply Tuple2Sym0 y_0123456789) _z_0123456789 ~ Let0123456789X_0123456789Sym1 x => - Sing y_0123456789 - -> Sing _z_0123456789 - -> Sing (Case_0123456789 x (Apply (Apply Tuple2Sym0 y_0123456789) _z_0123456789)) - lambda y_0123456789 _z_0123456789 = y_0123456789 - in lambda sY_0123456789 _s_z_0123456789 } :: - Sing (Case_0123456789 x (Let0123456789X_0123456789Sym1 x)) - sZ - = case sX_0123456789 of { - STuple2 _s_z_0123456789 sY_0123456789 - -> let - lambda :: - forall _z_0123456789 - y_0123456789. Apply (Apply Tuple2Sym0 _z_0123456789) y_0123456789 ~ Let0123456789X_0123456789Sym1 x => - Sing _z_0123456789 - -> Sing y_0123456789 - -> Sing (Case_0123456789 x (Apply (Apply Tuple2Sym0 _z_0123456789) y_0123456789)) - lambda _z_0123456789 y_0123456789 = y_0123456789 - in lambda _s_z_0123456789 sY_0123456789 } :: - Sing (Case_0123456789 x (Let0123456789X_0123456789Sym1 x)) - sX_0123456789 - = applySing - (applySing - (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) x)) - x - in - applySing - (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) sZ) sY - in lambda sX - sFoo13_ sY - = let - lambda :: - forall y. t ~ y => Sing y -> Sing (Apply Foo13_Sym0 t :: a) - lambda y = y - in lambda sY - sFoo13 sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply Foo13Sym0 t :: a) - lambda x - = let - sBar :: Sing (Let0123456789BarSym1 x :: a) - sBar = x - in applySing (singFun1 (Proxy :: Proxy Foo13_Sym0) sFoo13_) sBar - in lambda sX - sFoo12 sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply Foo12Sym0 t :: Nat) - lambda x - = let - (%:+) :: - forall (t :: Nat) (t :: Nat). - Sing t - -> Sing t - -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t :: Nat) - (%:+) SZero sM - = let - lambda :: - forall m. (t ~ ZeroSym0, t ~ m) => - Sing m -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t :: Nat) - lambda m = m - in lambda sM - (%:+) (SSucc sN) sM - = let - lambda :: - forall n m. (t ~ Apply SuccSym0 n, t ~ m) => - Sing n - -> Sing m - -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t :: Nat) - lambda n m - = applySing - (singFun1 (Proxy :: Proxy SuccSym0) SSucc) - (applySing - (applySing - (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) n) - x) - in lambda sN sM - in - applySing - (applySing - (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) x) - (applySing - (singFun1 (Proxy :: Proxy SuccSym0) SSucc) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)) - in lambda sX - sFoo11 sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply Foo11Sym0 t :: Nat) - lambda x - = let - sZ :: Sing (Let0123456789ZSym1 x :: Nat) - (%:+) :: - forall (t :: Nat) (t :: Nat). - Sing t - -> Sing t - -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t :: Nat) - sZ = x - (%:+) SZero sM - = let - lambda :: - forall m. (t ~ ZeroSym0, t ~ m) => - Sing m -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t :: Nat) - lambda m = m - in lambda sM - (%:+) (SSucc sN) sM - = let - lambda :: - forall n m. (t ~ Apply SuccSym0 n, t ~ m) => - Sing n - -> Sing m - -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t :: Nat) - lambda n m - = applySing - (singFun1 (Proxy :: Proxy SuccSym0) SSucc) - (applySing - (applySing - (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) n) - m) - in lambda sN sM - in - applySing - (applySing - (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)) - sZ - in lambda sX - sFoo10 sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply Foo10Sym0 t :: Nat) - lambda x - = let - (%:+) :: - forall (t :: Nat) (t :: Nat). - Sing t - -> Sing t - -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t :: Nat) - (%:+) SZero sM - = let - lambda :: - forall m. (t ~ ZeroSym0, t ~ m) => - Sing m -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t :: Nat) - lambda m = m - in lambda sM - (%:+) (SSucc sN) sM - = let - lambda :: - forall n m. (t ~ Apply SuccSym0 n, t ~ m) => - Sing n - -> Sing m - -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t :: Nat) - lambda n m - = applySing - (singFun1 (Proxy :: Proxy SuccSym0) SSucc) - (applySing - (applySing - (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) n) - m) - in lambda sN sM - in - applySing - (applySing - (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)) - x - in lambda sX - sFoo9 sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply Foo9Sym0 t :: Nat) - lambda x - = let - sZ :: - forall (t :: Nat). - Sing t -> Sing (Apply (Let0123456789ZSym1 x) t :: Nat) - sZ sA_0123456789 - = let - lambda :: - forall a_0123456789. t ~ a_0123456789 => - Sing a_0123456789 -> Sing (Apply (Let0123456789ZSym1 x) t :: Nat) - lambda a_0123456789 - = applySing - (singFun1 - (Proxy :: - Proxy (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789)) - (\ sX - -> let - lambda :: - forall x. - Sing x - -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789) x) - lambda x = x - in lambda sX)) - a_0123456789 - in lambda sA_0123456789 - in - applySing (singFun1 (Proxy :: Proxy (Let0123456789ZSym1 x)) sZ) x - in lambda sX - sFoo8 sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply Foo8Sym0 t :: Nat) - lambda x - = let - sZ :: Sing (Let0123456789ZSym1 x :: Nat) - sZ - = applySing - (singFun1 - (Proxy :: Proxy (Apply Lambda_0123456789Sym0 x)) - (\ sX - -> let - lambda :: - forall x. - Sing x -> Sing (Apply (Apply Lambda_0123456789Sym0 x) x) - lambda x = x - in lambda sX)) - SZero - in sZ - in lambda sX - sFoo7 sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply Foo7Sym0 t :: Nat) - lambda x - = let - sX :: Sing (Let0123456789XSym1 x :: Nat) - sX = SZero - in sX - in lambda sX - sFoo6 sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply Foo6Sym0 t :: Nat) - lambda x - = let - sF :: - forall (t :: Nat). - Sing t -> Sing (Apply (Let0123456789FSym1 x) t :: Nat) - sF sY - = let - lambda :: - forall y. t ~ y => - Sing y -> Sing (Apply (Let0123456789FSym1 x) t :: Nat) - lambda y = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) y - in lambda sY in - let - sZ :: Sing (Let0123456789ZSym1 x :: Nat) - sZ - = applySing (singFun1 (Proxy :: Proxy (Let0123456789FSym1 x)) sF) x - in sZ - in lambda sX - sFoo5 sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply Foo5Sym0 t :: Nat) - lambda x - = let - sF :: - forall (t :: Nat). - Sing t -> Sing (Apply (Let0123456789FSym1 x) t :: Nat) - sF sY - = let - lambda :: - forall y. t ~ y => - Sing y -> Sing (Apply (Let0123456789FSym1 x) t :: Nat) - lambda y - = let - sZ :: Sing (Let0123456789ZSym2 x y :: Nat) - sZ = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) y - in applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) sZ - in lambda sY - in - applySing (singFun1 (Proxy :: Proxy (Let0123456789FSym1 x)) sF) x - in lambda sX - sFoo4 sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply Foo4Sym0 t :: Nat) - lambda x - = let - sF :: - forall (t :: Nat). - Sing t -> Sing (Apply (Let0123456789FSym1 x) t :: Nat) - sF sY - = let - lambda :: - forall y. t ~ y => - Sing y -> Sing (Apply (Let0123456789FSym1 x) t :: Nat) - lambda y = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) y - in lambda sY - in - applySing (singFun1 (Proxy :: Proxy (Let0123456789FSym1 x)) sF) x - in lambda sX - sFoo3 sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply Foo3Sym0 t :: Nat) - lambda x - = let - sY :: Sing (Let0123456789YSym1 x :: Nat) - sY = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) x - in sY - in lambda sX - sFoo2 - = let - sY :: Sing Let0123456789YSym0 - sZ :: Sing Let0123456789ZSym0 - sY = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero - sZ = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) sY - in sZ - sFoo1 sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply Foo1Sym0 t :: Nat) - lambda x - = let - sY :: Sing (Let0123456789YSym1 x :: Nat) - sY = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero - in sY - in lambda sX diff --git a/tests/compile-and-dump/Singletons/Maybe.ghc710.template b/tests/compile-and-dump/Singletons/Maybe.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/Maybe.ghc710.template +++ /dev/null @@ -1,66 +0,0 @@ -Singletons/Maybe.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| data Maybe a - = Nothing | Just a - deriving (Eq, Show) |] - ======> - data Maybe a - = Nothing | Just a - deriving (Eq, Show) - type family Equals_0123456789 (a :: Maybe k) - (b :: Maybe k) :: Bool where - Equals_0123456789 Nothing Nothing = TrueSym0 - Equals_0123456789 (Just a) (Just b) = (:==) a b - Equals_0123456789 (a :: Maybe k) (b :: Maybe k) = FalseSym0 - instance PEq (KProxy :: KProxy (Maybe k)) where - type (:==) (a :: Maybe k) (b :: Maybe k) = Equals_0123456789 a b - type NothingSym0 = Nothing - type JustSym1 (t :: a0123456789) = Just t - instance SuppressUnusedWarnings JustSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) JustSym0KindInference GHC.Tuple.()) - data JustSym0 (l :: TyFun a0123456789 (Maybe a0123456789)) - = forall arg. KindOf (Apply JustSym0 arg) ~ KindOf (JustSym1 arg) => - JustSym0KindInference - type instance Apply JustSym0 l = JustSym1 l - data instance Sing (z :: Maybe a) - = z ~ Nothing => SNothing | - forall (n :: a). z ~ Just n => SJust (Sing (n :: a)) - type SMaybe = (Sing :: Maybe a -> *) - instance SingKind (KProxy :: KProxy a) => - SingKind (KProxy :: KProxy (Maybe a)) where - type DemoteRep (KProxy :: KProxy (Maybe a)) = Maybe (DemoteRep (KProxy :: KProxy a)) - fromSing SNothing = Nothing - fromSing (SJust b) = Just (fromSing b) - toSing Nothing = SomeSing SNothing - toSing (Just b) - = case toSing b :: SomeSing (KProxy :: KProxy a) of { - SomeSing c -> SomeSing (SJust c) } - instance SEq (KProxy :: KProxy a) => - SEq (KProxy :: KProxy (Maybe a)) where - (%:==) SNothing SNothing = STrue - (%:==) SNothing (SJust _) = SFalse - (%:==) (SJust _) SNothing = SFalse - (%:==) (SJust a) (SJust b) = (%:==) a b - instance SDecide (KProxy :: KProxy a) => - SDecide (KProxy :: KProxy (Maybe a)) where - (%~) SNothing SNothing = Proved Refl - (%~) SNothing (SJust _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SJust _) SNothing - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SJust a) (SJust b) - = case (%~) a b of { - Proved Refl -> Proved Refl - Disproved contra - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) } - instance SingI Nothing where - sing = SNothing - instance SingI n => SingI (Just (n :: a)) where - sing = SJust sing diff --git a/tests/compile-and-dump/Singletons/Maybe.ghc80.template b/tests/compile-and-dump/Singletons/Maybe.ghc80.template --- a/tests/compile-and-dump/Singletons/Maybe.ghc80.template +++ b/tests/compile-and-dump/Singletons/Maybe.ghc80.template @@ -12,7 +12,7 @@ Equals_0123456789 Nothing Nothing = TrueSym0 Equals_0123456789 (Just a) (Just b) = (:==) a b Equals_0123456789 (a :: Maybe k) (b :: Maybe k) = FalseSym0 - instance PEq (KProxy :: KProxy (Maybe k)) where + instance PEq (Proxy :: Proxy (Maybe k)) where type (:==) (a :: Maybe k) (b :: Maybe k) = Equals_0123456789 a b type NothingSym0 = Nothing type JustSym1 (t :: a0123456789) = Just t @@ -27,23 +27,20 @@ = z ~ Nothing => SNothing | forall (n :: a). z ~ Just n => SJust (Sing (n :: a)) type SMaybe = (Sing :: Maybe a -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy a) => - SingKind (KProxy :: KProxy (Maybe a)) where - type DemoteRep (KProxy :: KProxy (Maybe a)) = Maybe (DemoteRep (KProxy :: KProxy a)) + instance SingKind a => SingKind (Maybe a) where + type DemoteRep (Maybe a) = Maybe (DemoteRep a) fromSing SNothing = Nothing fromSing (SJust b) = Just (fromSing b) toSing Nothing = SomeSing SNothing toSing (Just b) - = case toSing b :: SomeSing (KProxy :: KProxy a) of { + = case toSing b :: SomeSing a of { SomeSing c -> SomeSing (SJust c) } - instance SEq (KProxy :: KProxy a) => - SEq (KProxy :: KProxy (Maybe a)) where + instance SEq a => SEq (Maybe a) where (%:==) SNothing SNothing = STrue (%:==) SNothing (SJust _) = SFalse (%:==) (SJust _) SNothing = SFalse (%:==) (SJust a) (SJust b) = (%:==) a b - instance SDecide (KProxy :: KProxy a) => - SDecide (KProxy :: KProxy (Maybe a)) where + instance SDecide a => SDecide (Maybe a) where (%~) SNothing SNothing = Proved Refl (%~) SNothing (SJust _) = Disproved diff --git a/tests/compile-and-dump/Singletons/Nat.ghc710.template b/tests/compile-and-dump/Singletons/Nat.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/Nat.ghc710.template +++ /dev/null @@ -1,141 +0,0 @@ -Singletons/Nat.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| plus :: Nat -> Nat -> Nat - plus Zero m = m - plus (Succ n) m = Succ (plus n m) - pred :: Nat -> Nat - pred Zero = Zero - pred (Succ n) = n - - data Nat - where - Zero :: Nat - Succ :: Nat -> Nat - deriving (Eq, Show, Read) |] - ======> - data Nat - = Zero | Succ Nat - deriving (Eq, Show, Read) - plus :: Nat -> Nat -> Nat - plus Zero m = m - plus (Succ n) m = Succ (plus n m) - pred :: Nat -> Nat - pred Zero = Zero - pred (Succ n) = n - type family Equals_0123456789 (a :: Nat) (b :: Nat) :: Bool where - Equals_0123456789 Zero Zero = TrueSym0 - Equals_0123456789 (Succ a) (Succ b) = (:==) a b - Equals_0123456789 (a :: Nat) (b :: Nat) = FalseSym0 - instance PEq (KProxy :: KProxy Nat) where - type (:==) (a :: Nat) (b :: Nat) = Equals_0123456789 a b - type ZeroSym0 = Zero - type SuccSym1 (t :: Nat) = Succ t - instance SuppressUnusedWarnings SuccSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.()) - data SuccSym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply SuccSym0 arg) ~ KindOf (SuccSym1 arg) => - SuccSym0KindInference - type instance Apply SuccSym0 l = SuccSym1 l - type PredSym1 (t :: Nat) = Pred t - instance SuppressUnusedWarnings PredSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) PredSym0KindInference GHC.Tuple.()) - data PredSym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply PredSym0 arg) ~ KindOf (PredSym1 arg) => - PredSym0KindInference - type instance Apply PredSym0 l = PredSym1 l - type PlusSym2 (t :: Nat) (t :: Nat) = Plus t t - instance SuppressUnusedWarnings PlusSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) PlusSym1KindInference GHC.Tuple.()) - data PlusSym1 (l :: Nat) (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply (PlusSym1 l) arg) ~ KindOf (PlusSym2 l arg) => - PlusSym1KindInference - type instance Apply (PlusSym1 l) l = PlusSym2 l l - instance SuppressUnusedWarnings PlusSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) PlusSym0KindInference GHC.Tuple.()) - data PlusSym0 (l :: TyFun Nat (TyFun Nat Nat -> *)) - = forall arg. KindOf (Apply PlusSym0 arg) ~ KindOf (PlusSym1 arg) => - PlusSym0KindInference - type instance Apply PlusSym0 l = PlusSym1 l - type family Pred (a :: Nat) :: Nat where - Pred Zero = ZeroSym0 - Pred (Succ n) = n - type family Plus (a :: Nat) (a :: Nat) :: Nat where - Plus Zero m = m - Plus (Succ n) m = Apply SuccSym0 (Apply (Apply PlusSym0 n) m) - 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) - sPred SZero - = let - lambda :: t ~ ZeroSym0 => Sing (Apply PredSym0 t :: Nat) - lambda = SZero - in lambda - sPred (SSucc sN) - = let - lambda :: - forall n. t ~ Apply SuccSym0 n => - Sing n -> Sing (Apply PredSym0 t :: Nat) - lambda n = n - in lambda sN - sPlus SZero sM - = let - lambda :: - forall m. (t ~ ZeroSym0, t ~ m) => - Sing m -> Sing (Apply (Apply PlusSym0 t) t :: Nat) - lambda m = m - in lambda sM - sPlus (SSucc sN) sM - = let - lambda :: - forall n m. (t ~ Apply SuccSym0 n, t ~ m) => - Sing n -> Sing m -> Sing (Apply (Apply PlusSym0 t) t :: Nat) - lambda n m - = applySing - (singFun1 (Proxy :: Proxy SuccSym0) SSucc) - (applySing - (applySing (singFun2 (Proxy :: Proxy PlusSym0) sPlus) n) m) - in lambda sN sM - data instance Sing (z :: Nat) - = z ~ Zero => SZero | - forall (n :: Nat). z ~ Succ n => SSucc (Sing (n :: Nat)) - type SNat = (Sing :: Nat -> *) - instance SingKind (KProxy :: KProxy Nat) where - type DemoteRep (KProxy :: KProxy Nat) = Nat - fromSing SZero = Zero - fromSing (SSucc b) = Succ (fromSing b) - toSing Zero = SomeSing SZero - toSing (Succ b) - = case toSing b :: SomeSing (KProxy :: KProxy Nat) of { - SomeSing c -> SomeSing (SSucc c) } - instance SEq (KProxy :: KProxy Nat) where - (%:==) SZero SZero = STrue - (%:==) SZero (SSucc _) = SFalse - (%:==) (SSucc _) SZero = SFalse - (%:==) (SSucc a) (SSucc b) = (%:==) a b - instance SDecide (KProxy :: KProxy Nat) where - (%~) SZero SZero = Proved Refl - (%~) SZero (SSucc _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SSucc _) SZero - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SSucc a) (SSucc b) - = case (%~) a b of { - Proved Refl -> Proved Refl - Disproved contra - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) } - instance SingI Zero where - sing = SZero - instance SingI n => SingI (Succ (n :: Nat)) where - sing = SSucc sing diff --git a/tests/compile-and-dump/Singletons/Nat.ghc80.template b/tests/compile-and-dump/Singletons/Nat.ghc80.template --- a/tests/compile-and-dump/Singletons/Nat.ghc80.template +++ b/tests/compile-and-dump/Singletons/Nat.ghc80.template @@ -28,7 +28,7 @@ Equals_0123456789 Zero Zero = TrueSym0 Equals_0123456789 (Succ a) (Succ b) = (:==) a b Equals_0123456789 (a :: Nat) (b :: Nat) = FalseSym0 - instance PEq (KProxy :: KProxy Nat) where + instance PEq (Proxy :: Proxy Nat) where type (:==) (a :: Nat) (b :: Nat) = Equals_0123456789 a b type ZeroSym0 = Zero type SuccSym1 (t :: Nat) = Succ t @@ -109,20 +109,20 @@ = z ~ Zero => SZero | forall (n :: Nat). z ~ Succ n => SSucc (Sing (n :: Nat)) type SNat = (Sing :: Nat -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy Nat) where - type DemoteRep (KProxy :: KProxy Nat) = Nat + instance SingKind Nat where + type DemoteRep Nat = Nat fromSing SZero = Zero fromSing (SSucc b) = Succ (fromSing b) toSing Zero = SomeSing SZero toSing (Succ b) - = case toSing b :: SomeSing (KProxy :: KProxy Nat) of { + = case toSing b :: SomeSing Nat of { SomeSing c -> SomeSing (SSucc c) } - instance SEq (KProxy :: KProxy Nat) where + instance SEq Nat where (%:==) SZero SZero = STrue (%:==) SZero (SSucc _) = SFalse (%:==) (SSucc _) SZero = SFalse (%:==) (SSucc a) (SSucc b) = (%:==) a b - instance SDecide (KProxy :: KProxy Nat) where + instance SDecide Nat where (%~) SZero SZero = Proved Refl (%~) SZero (SSucc _) = Disproved diff --git a/tests/compile-and-dump/Singletons/Operators.ghc710.template b/tests/compile-and-dump/Singletons/Operators.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/Operators.ghc710.template +++ /dev/null @@ -1,122 +0,0 @@ -Singletons/Operators.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| child :: Foo -> Foo - child FLeaf = FLeaf - child (a :+: _) = a - (+) :: Nat -> Nat -> Nat - Zero + m = m - (Succ n) + m = Succ (n + m) - - data Foo - where - FLeaf :: Foo - :+: :: Foo -> Foo -> Foo |] - ======> - data Foo = FLeaf | :+: Foo Foo - child :: Foo -> Foo - child FLeaf = FLeaf - child (a :+: _) = a - (+) :: Nat -> Nat -> Nat - (+) Zero m = m - (+) (Succ n) m = Succ (n + m) - type FLeafSym0 = FLeaf - type (:+:$$$) (t :: Foo) (t :: Foo) = (:+:) t t - instance SuppressUnusedWarnings (:+:$$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:+:$$###) GHC.Tuple.()) - data (:+:$$) (l :: Foo) (l :: TyFun Foo Foo) - = forall arg. KindOf (Apply ((:+:$$) l) arg) ~ KindOf ((:+:$$$) l arg) => - :+:$$### - type instance Apply ((:+:$$) l) l = (:+:$$$) l l - instance SuppressUnusedWarnings (:+:$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:+:$###) GHC.Tuple.()) - data (:+:$) (l :: TyFun Foo (TyFun Foo Foo -> *)) - = forall arg. KindOf (Apply (:+:$) arg) ~ KindOf ((:+:$$) arg) => - :+:$### - type instance Apply (:+:$) l = (:+:$$) l - type (:+$$$) (t :: Nat) (t :: Nat) = (:+) t t - instance SuppressUnusedWarnings (:+$$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.()) - data (:+$$) (l :: Nat) (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply ((:+$$) l) arg) ~ KindOf ((:+$$$) l arg) => - :+$$### - type instance Apply ((:+$$) l) l = (:+$$$) l l - instance SuppressUnusedWarnings (:+$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:+$###) GHC.Tuple.()) - data (:+$) (l :: TyFun Nat (TyFun Nat Nat -> *)) - = forall arg. KindOf (Apply (:+$) arg) ~ KindOf ((:+$$) arg) => - :+$### - type instance Apply (:+$) l = (:+$$) l - type ChildSym1 (t :: Foo) = Child t - instance SuppressUnusedWarnings ChildSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ChildSym0KindInference GHC.Tuple.()) - data ChildSym0 (l :: TyFun Foo Foo) - = forall arg. KindOf (Apply ChildSym0 arg) ~ KindOf (ChildSym1 arg) => - ChildSym0KindInference - type instance Apply ChildSym0 l = ChildSym1 l - type family (:+) (a :: Nat) (a :: Nat) :: Nat where - (:+) Zero m = m - (:+) (Succ n) m = Apply SuccSym0 (Apply (Apply (:+$) n) m) - type family Child (a :: Foo) :: Foo where - Child FLeaf = FLeafSym0 - Child ((:+:) a _z_0123456789) = a - (%:+) :: - 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 - = let - lambda :: - forall m. (t ~ ZeroSym0, t ~ m) => - Sing m -> Sing (Apply (Apply (:+$) t) t :: Nat) - lambda m = m - in lambda sM - (%:+) (SSucc sN) sM - = let - lambda :: - forall n m. (t ~ Apply SuccSym0 n, t ~ m) => - Sing n -> Sing m -> Sing (Apply (Apply (:+$) t) t :: Nat) - lambda n m - = applySing - (singFun1 (Proxy :: Proxy SuccSym0) SSucc) - (applySing (applySing (singFun2 (Proxy :: Proxy (:+$)) (%:+)) n) m) - in lambda sN sM - sChild SFLeaf - = let - lambda :: t ~ FLeafSym0 => Sing (Apply ChildSym0 t :: Foo) - lambda = SFLeaf - in lambda - sChild ((:%+:) sA _s_z_0123456789) - = let - lambda :: - forall a _z_0123456789. t ~ Apply (Apply (:+:$) a) _z_0123456789 => - Sing a -> Sing _z_0123456789 -> Sing (Apply ChildSym0 t :: Foo) - lambda a _z_0123456789 = a - in lambda sA _s_z_0123456789 - data instance Sing (z :: Foo) - = z ~ FLeaf => SFLeaf | - forall (n :: Foo) (n :: Foo). z ~ (:+:) n n => - :%+: (Sing (n :: Foo)) (Sing (n :: Foo)) - type SFoo = (Sing :: Foo -> *) - instance SingKind (KProxy :: KProxy Foo) where - type DemoteRep (KProxy :: KProxy Foo) = Foo - fromSing SFLeaf = FLeaf - fromSing ((:%+:) b b) = (:+:) (fromSing b) (fromSing b) - toSing FLeaf = SomeSing SFLeaf - toSing ((:+:) b b) - = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy Foo)) - (toSing b :: SomeSing (KProxy :: KProxy Foo)) - of { - GHC.Tuple.(,) (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 diff --git a/tests/compile-and-dump/Singletons/Operators.ghc80.template b/tests/compile-and-dump/Singletons/Operators.ghc80.template --- a/tests/compile-and-dump/Singletons/Operators.ghc80.template +++ b/tests/compile-and-dump/Singletons/Operators.ghc80.template @@ -109,16 +109,14 @@ forall (n :: Foo) (n :: Foo). z ~ (:+:) n n => (:%+:) (Sing (n :: Foo)) (Sing (n :: Foo)) type SFoo = (Sing :: Foo -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy Foo) where - type DemoteRep (KProxy :: KProxy Foo) = Foo + instance SingKind Foo where + type DemoteRep Foo = Foo fromSing SFLeaf = FLeaf fromSing ((:%+:) b b) = (:+:) (fromSing b) (fromSing b) toSing FLeaf = SomeSing SFLeaf toSing ((:+:) b b) = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy Foo)) - (toSing b :: SomeSing (KProxy :: KProxy Foo)) + GHC.Tuple.(,) (toSing b :: SomeSing Foo) (toSing b :: SomeSing Foo) of { GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing ((:%+:) c c) } instance SingI FLeaf where diff --git a/tests/compile-and-dump/Singletons/OrdDeriving.ghc710.template b/tests/compile-and-dump/Singletons/OrdDeriving.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/OrdDeriving.ghc710.template +++ /dev/null @@ -1,2891 +0,0 @@ -Singletons/OrdDeriving.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| data Nat - = Zero | Succ Nat - deriving (Eq, Ord) - data Foo a b c d - = A a b c d | - B a b c d | - C a b c d | - D a b c d | - E a b c d | - F a b c d - deriving (Eq, Ord) |] - ======> - data Nat - = Zero | Succ Nat - deriving (Eq, Ord) - data Foo a b c d - = A a b c d | - B a b c d | - C a b c d | - D a b c d | - E a b c d | - F a b c d - deriving (Eq, Ord) - type family Equals_0123456789 (a :: Nat) (b :: Nat) :: Bool where - Equals_0123456789 Zero Zero = TrueSym0 - Equals_0123456789 (Succ a) (Succ b) = (:==) a b - Equals_0123456789 (a :: Nat) (b :: Nat) = FalseSym0 - instance PEq (KProxy :: KProxy Nat) where - type (:==) (a :: Nat) (b :: Nat) = Equals_0123456789 a b - type ZeroSym0 = Zero - type SuccSym1 (t :: Nat) = Succ t - instance SuppressUnusedWarnings SuccSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) SuccSym0KindInference GHC.Tuple.()) - data SuccSym0 (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply SuccSym0 arg) ~ KindOf (SuccSym1 arg) => - SuccSym0KindInference - type instance Apply SuccSym0 l = SuccSym1 l - type family Equals_0123456789 (a :: Foo k k k k) - (b :: Foo k k k k) :: Bool where - Equals_0123456789 (A a a a a) (A b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b))) - Equals_0123456789 (B a a a a) (B b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b))) - Equals_0123456789 (C a a a a) (C b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b))) - Equals_0123456789 (D a a a a) (D b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b))) - Equals_0123456789 (E a a a a) (E b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b))) - Equals_0123456789 (F a a a a) (F b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b))) - Equals_0123456789 (a :: Foo k k k k) (b :: Foo k k k k) = FalseSym0 - instance PEq (KProxy :: KProxy (Foo k k k k)) where - type (:==) (a :: Foo k k k k) (b :: Foo k k k k) = Equals_0123456789 a b - type ASym4 (t :: a0123456789) - (t :: b0123456789) - (t :: c0123456789) - (t :: d0123456789) = - A t t t t - instance SuppressUnusedWarnings ASym3 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ASym3KindInference GHC.Tuple.()) - data ASym3 (l :: a0123456789) - (l :: b0123456789) - (l :: c0123456789) - (l :: TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789)) - = forall arg. KindOf (Apply (ASym3 l l l) arg) ~ KindOf (ASym4 l l l arg) => - ASym3KindInference - type instance Apply (ASym3 l l l) l = ASym4 l l l l - instance SuppressUnusedWarnings ASym2 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ASym2KindInference GHC.Tuple.()) - data ASym2 (l :: a0123456789) - (l :: b0123456789) - (l :: TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *)) - = forall arg. KindOf (Apply (ASym2 l l) arg) ~ KindOf (ASym3 l l arg) => - ASym2KindInference - type instance Apply (ASym2 l l) l = ASym3 l l l - instance SuppressUnusedWarnings ASym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ASym1KindInference GHC.Tuple.()) - data ASym1 (l :: a0123456789) - (l :: TyFun b0123456789 (TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *) - -> *)) - = forall arg. KindOf (Apply (ASym1 l) arg) ~ KindOf (ASym2 l arg) => - ASym1KindInference - type instance Apply (ASym1 l) l = ASym2 l l - instance SuppressUnusedWarnings ASym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ASym0KindInference GHC.Tuple.()) - data ASym0 (l :: TyFun a0123456789 (TyFun b0123456789 (TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *) - -> *) - -> *)) - = forall arg. KindOf (Apply ASym0 arg) ~ KindOf (ASym1 arg) => - ASym0KindInference - type instance Apply ASym0 l = ASym1 l - type BSym4 (t :: a0123456789) - (t :: b0123456789) - (t :: c0123456789) - (t :: d0123456789) = - B t t t t - instance SuppressUnusedWarnings BSym3 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BSym3KindInference GHC.Tuple.()) - data BSym3 (l :: a0123456789) - (l :: b0123456789) - (l :: c0123456789) - (l :: TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789)) - = forall arg. KindOf (Apply (BSym3 l l l) arg) ~ KindOf (BSym4 l l l arg) => - BSym3KindInference - type instance Apply (BSym3 l l l) l = BSym4 l l l l - instance SuppressUnusedWarnings BSym2 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BSym2KindInference GHC.Tuple.()) - data BSym2 (l :: a0123456789) - (l :: b0123456789) - (l :: TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *)) - = forall arg. KindOf (Apply (BSym2 l l) arg) ~ KindOf (BSym3 l l arg) => - BSym2KindInference - type instance Apply (BSym2 l l) l = BSym3 l l l - instance SuppressUnusedWarnings BSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BSym1KindInference GHC.Tuple.()) - data BSym1 (l :: a0123456789) - (l :: TyFun b0123456789 (TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *) - -> *)) - = forall arg. KindOf (Apply (BSym1 l) arg) ~ KindOf (BSym2 l arg) => - BSym1KindInference - type instance Apply (BSym1 l) l = BSym2 l l - instance SuppressUnusedWarnings BSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BSym0KindInference GHC.Tuple.()) - data BSym0 (l :: TyFun a0123456789 (TyFun b0123456789 (TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *) - -> *) - -> *)) - = forall arg. KindOf (Apply BSym0 arg) ~ KindOf (BSym1 arg) => - BSym0KindInference - type instance Apply BSym0 l = BSym1 l - type CSym4 (t :: a0123456789) - (t :: b0123456789) - (t :: c0123456789) - (t :: d0123456789) = - C t t t t - instance SuppressUnusedWarnings CSym3 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) CSym3KindInference GHC.Tuple.()) - data CSym3 (l :: a0123456789) - (l :: b0123456789) - (l :: c0123456789) - (l :: TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789)) - = forall arg. KindOf (Apply (CSym3 l l l) arg) ~ KindOf (CSym4 l l l arg) => - CSym3KindInference - type instance Apply (CSym3 l l l) l = CSym4 l l l l - instance SuppressUnusedWarnings CSym2 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) CSym2KindInference GHC.Tuple.()) - data CSym2 (l :: a0123456789) - (l :: b0123456789) - (l :: TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *)) - = forall arg. KindOf (Apply (CSym2 l l) arg) ~ KindOf (CSym3 l l arg) => - CSym2KindInference - type instance Apply (CSym2 l l) l = CSym3 l l l - instance SuppressUnusedWarnings CSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) CSym1KindInference GHC.Tuple.()) - data CSym1 (l :: a0123456789) - (l :: TyFun b0123456789 (TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *) - -> *)) - = forall arg. KindOf (Apply (CSym1 l) arg) ~ KindOf (CSym2 l arg) => - CSym1KindInference - type instance Apply (CSym1 l) l = CSym2 l l - instance SuppressUnusedWarnings CSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) CSym0KindInference GHC.Tuple.()) - data CSym0 (l :: TyFun a0123456789 (TyFun b0123456789 (TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *) - -> *) - -> *)) - = forall arg. KindOf (Apply CSym0 arg) ~ KindOf (CSym1 arg) => - CSym0KindInference - type instance Apply CSym0 l = CSym1 l - type DSym4 (t :: a0123456789) - (t :: b0123456789) - (t :: c0123456789) - (t :: d0123456789) = - D t t t t - instance SuppressUnusedWarnings DSym3 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) DSym3KindInference GHC.Tuple.()) - data DSym3 (l :: a0123456789) - (l :: b0123456789) - (l :: c0123456789) - (l :: TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789)) - = forall arg. KindOf (Apply (DSym3 l l l) arg) ~ KindOf (DSym4 l l l arg) => - DSym3KindInference - type instance Apply (DSym3 l l l) l = DSym4 l l l l - instance SuppressUnusedWarnings DSym2 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) DSym2KindInference GHC.Tuple.()) - data DSym2 (l :: a0123456789) - (l :: b0123456789) - (l :: TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *)) - = forall arg. KindOf (Apply (DSym2 l l) arg) ~ KindOf (DSym3 l l arg) => - DSym2KindInference - type instance Apply (DSym2 l l) l = DSym3 l l l - instance SuppressUnusedWarnings DSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) DSym1KindInference GHC.Tuple.()) - data DSym1 (l :: a0123456789) - (l :: TyFun b0123456789 (TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *) - -> *)) - = forall arg. KindOf (Apply (DSym1 l) arg) ~ KindOf (DSym2 l arg) => - DSym1KindInference - type instance Apply (DSym1 l) l = DSym2 l l - instance SuppressUnusedWarnings DSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) DSym0KindInference GHC.Tuple.()) - data DSym0 (l :: TyFun a0123456789 (TyFun b0123456789 (TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *) - -> *) - -> *)) - = forall arg. KindOf (Apply DSym0 arg) ~ KindOf (DSym1 arg) => - DSym0KindInference - type instance Apply DSym0 l = DSym1 l - type ESym4 (t :: a0123456789) - (t :: b0123456789) - (t :: c0123456789) - (t :: d0123456789) = - E t t t t - instance SuppressUnusedWarnings ESym3 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ESym3KindInference GHC.Tuple.()) - data ESym3 (l :: a0123456789) - (l :: b0123456789) - (l :: c0123456789) - (l :: TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789)) - = forall arg. KindOf (Apply (ESym3 l l l) arg) ~ KindOf (ESym4 l l l arg) => - ESym3KindInference - type instance Apply (ESym3 l l l) l = ESym4 l l l l - instance SuppressUnusedWarnings ESym2 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ESym2KindInference GHC.Tuple.()) - data ESym2 (l :: a0123456789) - (l :: b0123456789) - (l :: TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *)) - = forall arg. KindOf (Apply (ESym2 l l) arg) ~ KindOf (ESym3 l l arg) => - ESym2KindInference - type instance Apply (ESym2 l l) l = ESym3 l l l - instance SuppressUnusedWarnings ESym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ESym1KindInference GHC.Tuple.()) - data ESym1 (l :: a0123456789) - (l :: TyFun b0123456789 (TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *) - -> *)) - = forall arg. KindOf (Apply (ESym1 l) arg) ~ KindOf (ESym2 l arg) => - ESym1KindInference - type instance Apply (ESym1 l) l = ESym2 l l - instance SuppressUnusedWarnings ESym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ESym0KindInference GHC.Tuple.()) - data ESym0 (l :: TyFun a0123456789 (TyFun b0123456789 (TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *) - -> *) - -> *)) - = forall arg. KindOf (Apply ESym0 arg) ~ KindOf (ESym1 arg) => - ESym0KindInference - type instance Apply ESym0 l = ESym1 l - type FSym4 (t :: a0123456789) - (t :: b0123456789) - (t :: c0123456789) - (t :: d0123456789) = - F t t t t - instance SuppressUnusedWarnings FSym3 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FSym3KindInference GHC.Tuple.()) - data FSym3 (l :: a0123456789) - (l :: b0123456789) - (l :: c0123456789) - (l :: TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789)) - = forall arg. KindOf (Apply (FSym3 l l l) arg) ~ KindOf (FSym4 l l l arg) => - FSym3KindInference - type instance Apply (FSym3 l l l) l = FSym4 l l l l - instance SuppressUnusedWarnings FSym2 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FSym2KindInference GHC.Tuple.()) - data FSym2 (l :: a0123456789) - (l :: b0123456789) - (l :: TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *)) - = forall arg. KindOf (Apply (FSym2 l l) arg) ~ KindOf (FSym3 l l arg) => - FSym2KindInference - type instance Apply (FSym2 l l) l = FSym3 l l l - instance SuppressUnusedWarnings FSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FSym1KindInference GHC.Tuple.()) - data FSym1 (l :: a0123456789) - (l :: TyFun b0123456789 (TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *) - -> *)) - = forall arg. KindOf (Apply (FSym1 l) arg) ~ KindOf (FSym2 l arg) => - FSym1KindInference - type instance Apply (FSym1 l) l = FSym2 l l - instance SuppressUnusedWarnings FSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FSym0KindInference GHC.Tuple.()) - data FSym0 (l :: TyFun a0123456789 (TyFun b0123456789 (TyFun c0123456789 (TyFun d0123456789 (Foo a0123456789 b0123456789 c0123456789 d0123456789) - -> *) - -> *) - -> *)) - = forall arg. KindOf (Apply FSym0 arg) ~ KindOf (FSym1 arg) => - FSym0KindInference - type instance Apply FSym0 l = FSym1 l - type family Compare_0123456789 (a :: Nat) - (a :: Nat) :: Ordering where - Compare_0123456789 Zero Zero = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[] - Compare_0123456789 (Succ a_0123456789) (Succ b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[]) - Compare_0123456789 Zero (Succ _z_0123456789) = LTSym0 - Compare_0123456789 (Succ _z_0123456789) Zero = GTSym0 - type Compare_0123456789Sym2 (t :: Nat) (t :: Nat) = - Compare_0123456789 t t - instance SuppressUnusedWarnings Compare_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Compare_0123456789Sym1KindInference GHC.Tuple.()) - data Compare_0123456789Sym1 (l :: Nat) (l :: TyFun Nat Ordering) - = forall arg. KindOf (Apply (Compare_0123456789Sym1 l) arg) ~ KindOf (Compare_0123456789Sym2 l arg) => - Compare_0123456789Sym1KindInference - type instance Apply (Compare_0123456789Sym1 l) l = Compare_0123456789Sym2 l l - instance SuppressUnusedWarnings Compare_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Compare_0123456789Sym0KindInference GHC.Tuple.()) - data Compare_0123456789Sym0 (l :: TyFun Nat (TyFun Nat Ordering - -> *)) - = forall arg. KindOf (Apply Compare_0123456789Sym0 arg) ~ KindOf (Compare_0123456789Sym1 arg) => - Compare_0123456789Sym0KindInference - type instance Apply Compare_0123456789Sym0 l = Compare_0123456789Sym1 l - instance POrd (KProxy :: KProxy Nat) where - type Compare (a :: Nat) (a :: Nat) = Apply (Apply Compare_0123456789Sym0 a) a - type family Compare_0123456789 (a :: Foo a b c d) - (a :: Foo a b c d) :: Ordering where - Compare_0123456789 (A a_0123456789 a_0123456789 a_0123456789 a_0123456789) (A b_0123456789 b_0123456789 b_0123456789 b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[])))) - Compare_0123456789 (B a_0123456789 a_0123456789 a_0123456789 a_0123456789) (B b_0123456789 b_0123456789 b_0123456789 b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[])))) - Compare_0123456789 (C a_0123456789 a_0123456789 a_0123456789 a_0123456789) (C b_0123456789 b_0123456789 b_0123456789 b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[])))) - Compare_0123456789 (D a_0123456789 a_0123456789 a_0123456789 a_0123456789) (D b_0123456789 b_0123456789 b_0123456789 b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[])))) - Compare_0123456789 (E a_0123456789 a_0123456789 a_0123456789 a_0123456789) (E b_0123456789 b_0123456789 b_0123456789 b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[])))) - Compare_0123456789 (F a_0123456789 a_0123456789 a_0123456789 a_0123456789) (F b_0123456789 b_0123456789 b_0123456789 b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[])))) - Compare_0123456789 (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0 - Compare_0123456789 (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0 - Compare_0123456789 (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0 - Compare_0123456789 (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0 - Compare_0123456789 (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0 - Compare_0123456789 (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0 - Compare_0123456789 (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0 - Compare_0123456789 (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0 - Compare_0123456789 (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0 - Compare_0123456789 (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0 - Compare_0123456789 (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (A _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0 - Compare_0123456789 (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (B _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0 - Compare_0123456789 (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (C _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0 - Compare_0123456789 (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (D _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0 - Compare_0123456789 (F _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) (E _z_0123456789 _z_0123456789 _z_0123456789 _z_0123456789) = GTSym0 - type Compare_0123456789Sym2 (t :: Foo a0123456789 b0123456789 c0123456789 d0123456789) - (t :: Foo a0123456789 b0123456789 c0123456789 d0123456789) = - Compare_0123456789 t t - instance SuppressUnusedWarnings Compare_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Compare_0123456789Sym1KindInference GHC.Tuple.()) - data Compare_0123456789Sym1 (l :: Foo a0123456789 b0123456789 c0123456789 d0123456789) - (l :: TyFun (Foo a0123456789 b0123456789 c0123456789 d0123456789) Ordering) - = forall arg. KindOf (Apply (Compare_0123456789Sym1 l) arg) ~ KindOf (Compare_0123456789Sym2 l arg) => - Compare_0123456789Sym1KindInference - type instance Apply (Compare_0123456789Sym1 l) l = Compare_0123456789Sym2 l l - instance SuppressUnusedWarnings Compare_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Compare_0123456789Sym0KindInference GHC.Tuple.()) - data Compare_0123456789Sym0 (l :: TyFun (Foo a0123456789 b0123456789 c0123456789 d0123456789) (TyFun (Foo a0123456789 b0123456789 c0123456789 d0123456789) Ordering - -> *)) - = forall arg. KindOf (Apply Compare_0123456789Sym0 arg) ~ KindOf (Compare_0123456789Sym1 arg) => - Compare_0123456789Sym0KindInference - type instance Apply Compare_0123456789Sym0 l = Compare_0123456789Sym1 l - instance POrd (KProxy :: KProxy (Foo a b c d)) where - type Compare (a :: Foo a b c d) (a :: Foo a b c d) = Apply (Apply Compare_0123456789Sym0 a) a - data instance Sing (z :: Nat) - = z ~ Zero => SZero | - forall (n :: Nat). z ~ Succ n => SSucc (Sing (n :: Nat)) - type SNat = (Sing :: Nat -> *) - instance SingKind (KProxy :: KProxy Nat) where - type DemoteRep (KProxy :: KProxy Nat) = Nat - fromSing SZero = Zero - fromSing (SSucc b) = Succ (fromSing b) - toSing Zero = SomeSing SZero - toSing (Succ b) - = case toSing b :: SomeSing (KProxy :: KProxy Nat) of { - SomeSing c -> SomeSing (SSucc c) } - instance SEq (KProxy :: KProxy Nat) where - (%:==) SZero SZero = STrue - (%:==) SZero (SSucc _) = SFalse - (%:==) (SSucc _) SZero = SFalse - (%:==) (SSucc a) (SSucc b) = (%:==) a b - instance SDecide (KProxy :: KProxy Nat) where - (%~) SZero SZero = Proved Refl - (%~) SZero (SSucc _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SSucc _) SZero - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SSucc a) (SSucc b) - = case (%~) a b of { - Proved Refl -> Proved Refl - Disproved contra - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) } - data instance Sing (z :: Foo a b c d) - = forall (n :: a) (n :: b) (n :: c) (n :: d). z ~ A n n n n => - SA (Sing (n :: a)) (Sing (n :: b)) (Sing (n :: c)) (Sing (n :: d)) | - forall (n :: a) (n :: b) (n :: c) (n :: d). z ~ B n n n n => - SB (Sing (n :: a)) (Sing (n :: b)) (Sing (n :: c)) (Sing (n :: d)) | - forall (n :: a) (n :: b) (n :: c) (n :: d). z ~ C n n n n => - SC (Sing (n :: a)) (Sing (n :: b)) (Sing (n :: c)) (Sing (n :: d)) | - forall (n :: a) (n :: b) (n :: c) (n :: d). z ~ D n n n n => - SD (Sing (n :: a)) (Sing (n :: b)) (Sing (n :: c)) (Sing (n :: d)) | - forall (n :: a) (n :: b) (n :: c) (n :: d). z ~ E n n n n => - SE (Sing (n :: a)) (Sing (n :: b)) (Sing (n :: c)) (Sing (n :: d)) | - forall (n :: a) (n :: b) (n :: c) (n :: d). z ~ F n n n n => - SF (Sing (n :: a)) (Sing (n :: b)) (Sing (n :: c)) (Sing (n :: d)) - type SFoo = (Sing :: Foo a b c d -> *) - instance (SingKind (KProxy :: KProxy a), - SingKind (KProxy :: KProxy b), - SingKind (KProxy :: KProxy c), - SingKind (KProxy :: KProxy d)) => - SingKind (KProxy :: KProxy (Foo a b c d)) where - type DemoteRep (KProxy :: KProxy (Foo a b c d)) = Foo (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b)) (DemoteRep (KProxy :: KProxy c)) (DemoteRep (KProxy :: KProxy d)) - fromSing (SA b b b b) - = A (fromSing b) (fromSing b) (fromSing b) (fromSing b) - fromSing (SB b b b b) - = B (fromSing b) (fromSing b) (fromSing b) (fromSing b) - fromSing (SC b b b b) - = C (fromSing b) (fromSing b) (fromSing b) (fromSing b) - fromSing (SD b b b b) - = D (fromSing b) (fromSing b) (fromSing b) (fromSing b) - fromSing (SE b b b b) - = E (fromSing b) (fromSing b) (fromSing b) (fromSing b) - fromSing (SF b b b b) - = F (fromSing b) (fromSing b) (fromSing b) (fromSing b) - toSing (A b b b b) - = case - GHC.Tuple.(,,,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) - (toSing b :: SomeSing (KProxy :: KProxy c)) - (toSing b :: SomeSing (KProxy :: KProxy d)) - of { - GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) - -> SomeSing (SA c c c c) } - toSing (B b b b b) - = case - GHC.Tuple.(,,,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) - (toSing b :: SomeSing (KProxy :: KProxy c)) - (toSing b :: SomeSing (KProxy :: KProxy d)) - of { - GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) - -> SomeSing (SB c c c c) } - toSing (C b b b b) - = case - GHC.Tuple.(,,,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) - (toSing b :: SomeSing (KProxy :: KProxy c)) - (toSing b :: SomeSing (KProxy :: KProxy d)) - of { - GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) - -> SomeSing (SC c c c c) } - toSing (D b b b b) - = case - GHC.Tuple.(,,,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) - (toSing b :: SomeSing (KProxy :: KProxy c)) - (toSing b :: SomeSing (KProxy :: KProxy d)) - of { - GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) - -> SomeSing (SD c c c c) } - toSing (E b b b b) - = case - GHC.Tuple.(,,,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) - (toSing b :: SomeSing (KProxy :: KProxy c)) - (toSing b :: SomeSing (KProxy :: KProxy d)) - of { - GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) - -> SomeSing (SE c c c c) } - toSing (F b b b b) - = case - GHC.Tuple.(,,,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) - (toSing b :: SomeSing (KProxy :: KProxy c)) - (toSing b :: SomeSing (KProxy :: KProxy d)) - of { - GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) - -> SomeSing (SF c c c c) } - instance (SEq (KProxy :: KProxy a), - SEq (KProxy :: KProxy b), - SEq (KProxy :: KProxy c), - SEq (KProxy :: KProxy d)) => - SEq (KProxy :: KProxy (Foo a b c d)) where - (%:==) (SA a a a a) (SA b b b b) - = (%:&&) - ((%:==) a b) - ((%:&&) ((%:==) a b) ((%:&&) ((%:==) a b) ((%:==) a b))) - (%:==) (SA _ _ _ _) (SB _ _ _ _) = SFalse - (%:==) (SA _ _ _ _) (SC _ _ _ _) = SFalse - (%:==) (SA _ _ _ _) (SD _ _ _ _) = SFalse - (%:==) (SA _ _ _ _) (SE _ _ _ _) = SFalse - (%:==) (SA _ _ _ _) (SF _ _ _ _) = SFalse - (%:==) (SB _ _ _ _) (SA _ _ _ _) = SFalse - (%:==) (SB a a a a) (SB b b b b) - = (%:&&) - ((%:==) a b) - ((%:&&) ((%:==) a b) ((%:&&) ((%:==) a b) ((%:==) a b))) - (%:==) (SB _ _ _ _) (SC _ _ _ _) = SFalse - (%:==) (SB _ _ _ _) (SD _ _ _ _) = SFalse - (%:==) (SB _ _ _ _) (SE _ _ _ _) = SFalse - (%:==) (SB _ _ _ _) (SF _ _ _ _) = SFalse - (%:==) (SC _ _ _ _) (SA _ _ _ _) = SFalse - (%:==) (SC _ _ _ _) (SB _ _ _ _) = SFalse - (%:==) (SC a a a a) (SC b b b b) - = (%:&&) - ((%:==) a b) - ((%:&&) ((%:==) a b) ((%:&&) ((%:==) a b) ((%:==) a b))) - (%:==) (SC _ _ _ _) (SD _ _ _ _) = SFalse - (%:==) (SC _ _ _ _) (SE _ _ _ _) = SFalse - (%:==) (SC _ _ _ _) (SF _ _ _ _) = SFalse - (%:==) (SD _ _ _ _) (SA _ _ _ _) = SFalse - (%:==) (SD _ _ _ _) (SB _ _ _ _) = SFalse - (%:==) (SD _ _ _ _) (SC _ _ _ _) = SFalse - (%:==) (SD a a a a) (SD b b b b) - = (%:&&) - ((%:==) a b) - ((%:&&) ((%:==) a b) ((%:&&) ((%:==) a b) ((%:==) a b))) - (%:==) (SD _ _ _ _) (SE _ _ _ _) = SFalse - (%:==) (SD _ _ _ _) (SF _ _ _ _) = SFalse - (%:==) (SE _ _ _ _) (SA _ _ _ _) = SFalse - (%:==) (SE _ _ _ _) (SB _ _ _ _) = SFalse - (%:==) (SE _ _ _ _) (SC _ _ _ _) = SFalse - (%:==) (SE _ _ _ _) (SD _ _ _ _) = SFalse - (%:==) (SE a a a a) (SE b b b b) - = (%:&&) - ((%:==) a b) - ((%:&&) ((%:==) a b) ((%:&&) ((%:==) a b) ((%:==) a b))) - (%:==) (SE _ _ _ _) (SF _ _ _ _) = SFalse - (%:==) (SF _ _ _ _) (SA _ _ _ _) = SFalse - (%:==) (SF _ _ _ _) (SB _ _ _ _) = SFalse - (%:==) (SF _ _ _ _) (SC _ _ _ _) = SFalse - (%:==) (SF _ _ _ _) (SD _ _ _ _) = SFalse - (%:==) (SF _ _ _ _) (SE _ _ _ _) = SFalse - (%:==) (SF a a a a) (SF b b b b) - = (%:&&) - ((%:==) a b) - ((%:&&) ((%:==) a b) ((%:&&) ((%:==) a b) ((%:==) a b))) - instance (SDecide (KProxy :: KProxy a), - SDecide (KProxy :: KProxy b), - SDecide (KProxy :: KProxy c), - SDecide (KProxy :: KProxy d)) => - SDecide (KProxy :: KProxy (Foo a b c d)) where - (%~) (SA a a a a) (SA b b b b) - = case - GHC.Tuple.(,,,) ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b) - of { - GHC.Tuple.(,,,) (Proved Refl) - (Proved Refl) - (Proved Refl) - (Proved Refl) - -> Proved Refl - GHC.Tuple.(,,,) (Disproved contra) _ _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ (Disproved contra) _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ _ (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ _ _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) } - (%~) (SA _ _ _ _) (SB _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SA _ _ _ _) (SC _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SA _ _ _ _) (SD _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SA _ _ _ _) (SE _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SA _ _ _ _) (SF _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SB _ _ _ _) (SA _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SB a a a a) (SB b b b b) - = case - GHC.Tuple.(,,,) ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b) - of { - GHC.Tuple.(,,,) (Proved Refl) - (Proved Refl) - (Proved Refl) - (Proved Refl) - -> Proved Refl - GHC.Tuple.(,,,) (Disproved contra) _ _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ (Disproved contra) _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ _ (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ _ _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) } - (%~) (SB _ _ _ _) (SC _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SB _ _ _ _) (SD _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SB _ _ _ _) (SE _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SB _ _ _ _) (SF _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SC _ _ _ _) (SA _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SC _ _ _ _) (SB _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SC a a a a) (SC b b b b) - = case - GHC.Tuple.(,,,) ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b) - of { - GHC.Tuple.(,,,) (Proved Refl) - (Proved Refl) - (Proved Refl) - (Proved Refl) - -> Proved Refl - GHC.Tuple.(,,,) (Disproved contra) _ _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ (Disproved contra) _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ _ (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ _ _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) } - (%~) (SC _ _ _ _) (SD _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SC _ _ _ _) (SE _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SC _ _ _ _) (SF _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SD _ _ _ _) (SA _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SD _ _ _ _) (SB _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SD _ _ _ _) (SC _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SD a a a a) (SD b b b b) - = case - GHC.Tuple.(,,,) ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b) - of { - GHC.Tuple.(,,,) (Proved Refl) - (Proved Refl) - (Proved Refl) - (Proved Refl) - -> Proved Refl - GHC.Tuple.(,,,) (Disproved contra) _ _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ (Disproved contra) _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ _ (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ _ _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) } - (%~) (SD _ _ _ _) (SE _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SD _ _ _ _) (SF _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SE _ _ _ _) (SA _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SE _ _ _ _) (SB _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SE _ _ _ _) (SC _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SE _ _ _ _) (SD _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SE a a a a) (SE b b b b) - = case - GHC.Tuple.(,,,) ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b) - of { - GHC.Tuple.(,,,) (Proved Refl) - (Proved Refl) - (Proved Refl) - (Proved Refl) - -> Proved Refl - GHC.Tuple.(,,,) (Disproved contra) _ _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ (Disproved contra) _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ _ (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ _ _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) } - (%~) (SE _ _ _ _) (SF _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SF _ _ _ _) (SA _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SF _ _ _ _) (SB _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SF _ _ _ _) (SC _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SF _ _ _ _) (SD _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SF _ _ _ _) (SE _ _ _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SF a a a a) (SF b b b b) - = case - GHC.Tuple.(,,,) ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b) - of { - GHC.Tuple.(,,,) (Proved Refl) - (Proved Refl) - (Proved Refl) - (Proved Refl) - -> Proved Refl - GHC.Tuple.(,,,) (Disproved contra) _ _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ (Disproved contra) _ _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ _ (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,,,) _ _ _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) } - instance SOrd (KProxy :: KProxy Nat) => - SOrd (KProxy :: KProxy Nat) where - sCompare :: - forall (t0 :: Nat) (t1 :: Nat). - Sing t0 - -> Sing t1 - -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat (TyFun Nat Ordering - -> *) - -> *) t0 :: TyFun Nat Ordering - -> *) t1 :: Ordering) - sCompare SZero SZero - = let - lambda :: - (t0 ~ ZeroSym0, t1 ~ ZeroSym0) => - Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - = applySing - (applySing - (applySing - (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl) - (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp)) - SEQ) - SNil - in lambda - sCompare (SSucc sA_0123456789) (SSucc sB_0123456789) - = let - lambda :: - forall a_0123456789 - b_0123456789. (t0 ~ Apply SuccSym0 a_0123456789, - t1 ~ Apply SuccSym0 b_0123456789) => - Sing a_0123456789 - -> Sing b_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda a_0123456789 b_0123456789 - = applySing - (applySing - (applySing - (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl) - (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp)) - SEQ) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - SNil) - in lambda sA_0123456789 sB_0123456789 - sCompare SZero (SSucc _s_z_0123456789) - = let - lambda :: - forall _z_0123456789. (t0 ~ ZeroSym0, - t1 ~ Apply SuccSym0 _z_0123456789) => - Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 = SLT - in lambda _s_z_0123456789 - sCompare (SSucc _s_z_0123456789) SZero - = let - lambda :: - forall _z_0123456789. (t0 ~ Apply SuccSym0 _z_0123456789, - t1 ~ ZeroSym0) => - Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 = SGT - in lambda _s_z_0123456789 - instance (SOrd (KProxy :: KProxy a), - SOrd (KProxy :: KProxy b), - SOrd (KProxy :: KProxy c), - SOrd (KProxy :: KProxy d)) => - SOrd (KProxy :: KProxy (Foo a b c d)) where - sCompare :: - forall (t0 :: Foo a b c d) (t1 :: Foo a b c d). - Sing t0 - -> Sing t1 - -> Sing (Apply (Apply (CompareSym0 :: TyFun (Foo a b c d) (TyFun (Foo a b c d) Ordering - -> *) - -> *) t0 :: TyFun (Foo a b c d) Ordering - -> *) t1 :: Ordering) - sCompare - (SA sA_0123456789 sA_0123456789 sA_0123456789 sA_0123456789) - (SA sB_0123456789 sB_0123456789 sB_0123456789 sB_0123456789) - = let - lambda :: - forall a_0123456789 - a_0123456789 - a_0123456789 - a_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - b_0123456789. (t0 ~ Apply (Apply (Apply (Apply ASym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789, - t1 ~ Apply (Apply (Apply (Apply ASym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) => - Sing a_0123456789 - -> Sing a_0123456789 - -> Sing a_0123456789 - -> Sing a_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - a_0123456789 - a_0123456789 - a_0123456789 - a_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - = applySing - (applySing - (applySing - (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl) - (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp)) - SEQ) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) - a_0123456789) - b_0123456789)) - SNil)))) - in - lambda - sA_0123456789 - sA_0123456789 - sA_0123456789 - sA_0123456789 - sB_0123456789 - sB_0123456789 - sB_0123456789 - sB_0123456789 - sCompare - (SB sA_0123456789 sA_0123456789 sA_0123456789 sA_0123456789) - (SB sB_0123456789 sB_0123456789 sB_0123456789 sB_0123456789) - = let - lambda :: - forall a_0123456789 - a_0123456789 - a_0123456789 - a_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - b_0123456789. (t0 ~ Apply (Apply (Apply (Apply BSym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789, - t1 ~ Apply (Apply (Apply (Apply BSym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) => - Sing a_0123456789 - -> Sing a_0123456789 - -> Sing a_0123456789 - -> Sing a_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - a_0123456789 - a_0123456789 - a_0123456789 - a_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - = applySing - (applySing - (applySing - (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl) - (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp)) - SEQ) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) - a_0123456789) - b_0123456789)) - SNil)))) - in - lambda - sA_0123456789 - sA_0123456789 - sA_0123456789 - sA_0123456789 - sB_0123456789 - sB_0123456789 - sB_0123456789 - sB_0123456789 - sCompare - (SC sA_0123456789 sA_0123456789 sA_0123456789 sA_0123456789) - (SC sB_0123456789 sB_0123456789 sB_0123456789 sB_0123456789) - = let - lambda :: - forall a_0123456789 - a_0123456789 - a_0123456789 - a_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - b_0123456789. (t0 ~ Apply (Apply (Apply (Apply CSym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789, - t1 ~ Apply (Apply (Apply (Apply CSym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) => - Sing a_0123456789 - -> Sing a_0123456789 - -> Sing a_0123456789 - -> Sing a_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - a_0123456789 - a_0123456789 - a_0123456789 - a_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - = applySing - (applySing - (applySing - (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl) - (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp)) - SEQ) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) - a_0123456789) - b_0123456789)) - SNil)))) - in - lambda - sA_0123456789 - sA_0123456789 - sA_0123456789 - sA_0123456789 - sB_0123456789 - sB_0123456789 - sB_0123456789 - sB_0123456789 - sCompare - (SD sA_0123456789 sA_0123456789 sA_0123456789 sA_0123456789) - (SD sB_0123456789 sB_0123456789 sB_0123456789 sB_0123456789) - = let - lambda :: - forall a_0123456789 - a_0123456789 - a_0123456789 - a_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - b_0123456789. (t0 ~ Apply (Apply (Apply (Apply DSym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789, - t1 ~ Apply (Apply (Apply (Apply DSym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) => - Sing a_0123456789 - -> Sing a_0123456789 - -> Sing a_0123456789 - -> Sing a_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - a_0123456789 - a_0123456789 - a_0123456789 - a_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - = applySing - (applySing - (applySing - (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl) - (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp)) - SEQ) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) - a_0123456789) - b_0123456789)) - SNil)))) - in - lambda - sA_0123456789 - sA_0123456789 - sA_0123456789 - sA_0123456789 - sB_0123456789 - sB_0123456789 - sB_0123456789 - sB_0123456789 - sCompare - (SE sA_0123456789 sA_0123456789 sA_0123456789 sA_0123456789) - (SE sB_0123456789 sB_0123456789 sB_0123456789 sB_0123456789) - = let - lambda :: - forall a_0123456789 - a_0123456789 - a_0123456789 - a_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - b_0123456789. (t0 ~ Apply (Apply (Apply (Apply ESym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789, - t1 ~ Apply (Apply (Apply (Apply ESym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) => - Sing a_0123456789 - -> Sing a_0123456789 - -> Sing a_0123456789 - -> Sing a_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - a_0123456789 - a_0123456789 - a_0123456789 - a_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - = applySing - (applySing - (applySing - (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl) - (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp)) - SEQ) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) - a_0123456789) - b_0123456789)) - SNil)))) - in - lambda - sA_0123456789 - sA_0123456789 - sA_0123456789 - sA_0123456789 - sB_0123456789 - sB_0123456789 - sB_0123456789 - sB_0123456789 - sCompare - (SF sA_0123456789 sA_0123456789 sA_0123456789 sA_0123456789) - (SF sB_0123456789 sB_0123456789 sB_0123456789 sB_0123456789) - = let - lambda :: - forall a_0123456789 - a_0123456789 - a_0123456789 - a_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - b_0123456789. (t0 ~ Apply (Apply (Apply (Apply FSym0 a_0123456789) a_0123456789) a_0123456789) a_0123456789, - t1 ~ Apply (Apply (Apply (Apply FSym0 b_0123456789) b_0123456789) b_0123456789) b_0123456789) => - Sing a_0123456789 - -> Sing a_0123456789 - -> Sing a_0123456789 - -> Sing a_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - a_0123456789 - a_0123456789 - a_0123456789 - a_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - b_0123456789 - = applySing - (applySing - (applySing - (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl) - (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp)) - SEQ) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 (Proxy :: Proxy CompareSym0) sCompare) - a_0123456789) - b_0123456789)) - SNil)))) - in - lambda - sA_0123456789 - sA_0123456789 - sA_0123456789 - sA_0123456789 - sB_0123456789 - sB_0123456789 - sB_0123456789 - sB_0123456789 - sCompare - (SA _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SB _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SLT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SA _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SC _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SLT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SA _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SD _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SLT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SA _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SE _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SLT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SA _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SF _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SLT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SB _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SA _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SGT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SB _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SC _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SLT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SB _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SD _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SLT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SB _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SE _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SLT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SB _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SF _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SLT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SC _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SA _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SGT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SC _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SB _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SGT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SC _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SD _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SLT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SC _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SE _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SLT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SC _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SF _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SLT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SD _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SA _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SGT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SD _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SB _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SGT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SD _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SC _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SGT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SD _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SE _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SLT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SD _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SF _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SLT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SE _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SA _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SGT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SE _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SB _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SGT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SE _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SC _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SGT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SE _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SD _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SGT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SE _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SF _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SLT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SF _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SA _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply ASym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SGT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SF _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SB _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply BSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SGT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SF _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SC _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply CSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SGT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SF _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SD _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply DSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SGT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - sCompare - (SF _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - (SE _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply (Apply (Apply FSym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789, - t1 ~ Apply (Apply (Apply (Apply ESym0 _z_0123456789) _z_0123456789) _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - _z_0123456789 - = SGT - in - lambda - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - _s_z_0123456789 - instance SingI Zero where - sing = SZero - instance SingI n => SingI (Succ (n :: Nat)) where - sing = SSucc sing - 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, 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, 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, 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, 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, SingI n) => - SingI (F (n :: a) (n :: b) (n :: c) (n :: d)) where - sing = SF sing sing sing sing diff --git a/tests/compile-and-dump/Singletons/OrdDeriving.ghc80.template b/tests/compile-and-dump/Singletons/OrdDeriving.ghc80.template --- a/tests/compile-and-dump/Singletons/OrdDeriving.ghc80.template +++ b/tests/compile-and-dump/Singletons/OrdDeriving.ghc80.template @@ -27,7 +27,7 @@ Equals_0123456789 Zero Zero = TrueSym0 Equals_0123456789 (Succ a) (Succ b) = (:==) a b Equals_0123456789 (a :: Nat) (b :: Nat) = FalseSym0 - instance PEq (KProxy :: KProxy Nat) where + instance PEq (Proxy :: Proxy Nat) where type (:==) (a :: Nat) (b :: Nat) = Equals_0123456789 a b type ZeroSym0 = Zero type SuccSym1 (t :: Nat) = Succ t @@ -47,7 +47,7 @@ Equals_0123456789 (E a a a a) (E b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b))) Equals_0123456789 (F a a a a) (F b b b b) = (:&&) ((:==) a b) ((:&&) ((:==) a b) ((:&&) ((:==) a b) ((:==) a b))) Equals_0123456789 (a :: Foo k k k k) (b :: Foo k k k k) = FalseSym0 - instance PEq (KProxy :: KProxy (Foo k k k k)) where + instance PEq (Proxy :: Proxy (Foo k k k k)) where type (:==) (a :: Foo k k k k) (b :: Foo k k k k) = Equals_0123456789 a b type ASym4 (t :: a0123456789) (t :: b0123456789) @@ -344,7 +344,7 @@ = forall arg. KindOf (Apply Compare_0123456789Sym0 arg) ~ KindOf (Compare_0123456789Sym1 arg) => Compare_0123456789Sym0KindInference type instance Apply Compare_0123456789Sym0 l = Compare_0123456789Sym1 l - instance POrd (KProxy :: KProxy Nat) where + instance POrd (Proxy :: Proxy Nat) where type Compare (a :: Nat) (a :: Nat) = Apply (Apply Compare_0123456789Sym0 a) a type family Compare_0123456789 (a :: Foo a b c d) (a :: Foo a b c d) :: Ordering where @@ -405,26 +405,26 @@ = forall arg. KindOf (Apply Compare_0123456789Sym0 arg) ~ KindOf (Compare_0123456789Sym1 arg) => Compare_0123456789Sym0KindInference type instance Apply Compare_0123456789Sym0 l = Compare_0123456789Sym1 l - instance POrd (KProxy :: KProxy (Foo a b c d)) where + instance POrd (Proxy :: Proxy (Foo a b c d)) where type Compare (a :: Foo a b c d) (a :: Foo a b c d) = Apply (Apply Compare_0123456789Sym0 a) a data instance Sing (z :: Nat) = z ~ Zero => SZero | forall (n :: Nat). z ~ Succ n => SSucc (Sing (n :: Nat)) type SNat = (Sing :: Nat -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy Nat) where - type DemoteRep (KProxy :: KProxy Nat) = Nat + instance SingKind Nat where + type DemoteRep Nat = Nat fromSing SZero = Zero fromSing (SSucc b) = Succ (fromSing b) toSing Zero = SomeSing SZero toSing (Succ b) - = case toSing b :: SomeSing (KProxy :: KProxy Nat) of { + = case toSing b :: SomeSing Nat of { SomeSing c -> SomeSing (SSucc c) } - instance SEq (KProxy :: KProxy Nat) where + instance SEq Nat where (%:==) SZero SZero = STrue (%:==) SZero (SSucc _) = SFalse (%:==) (SSucc _) SZero = SFalse (%:==) (SSucc a) (SSucc b) = (%:==) a b - instance SDecide (KProxy :: KProxy Nat) where + instance SDecide Nat where (%~) SZero SZero = Proved Refl (%~) SZero (SSucc _) = Disproved @@ -455,12 +455,9 @@ forall (n :: a) (n :: b) (n :: c) (n :: d). z ~ F n n n n => SF (Sing (n :: a)) (Sing (n :: b)) (Sing (n :: c)) (Sing (n :: d)) type SFoo = (Sing :: Foo a b c d -> GHC.Types.Type) - instance (SingKind (KProxy :: KProxy a), - SingKind (KProxy :: KProxy b), - SingKind (KProxy :: KProxy c), - SingKind (KProxy :: KProxy d)) => - SingKind (KProxy :: KProxy (Foo a b c d)) where - type DemoteRep (KProxy :: KProxy (Foo a b c d)) = Foo (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b)) (DemoteRep (KProxy :: KProxy c)) (DemoteRep (KProxy :: KProxy d)) + instance (SingKind a, SingKind b, SingKind c, SingKind d) => + SingKind (Foo a b c d) where + type DemoteRep (Foo a b c d) = Foo (DemoteRep a) (DemoteRep b) (DemoteRep c) (DemoteRep d) fromSing (SA b b b b) = A (fromSing b) (fromSing b) (fromSing b) (fromSing b) fromSing (SB b b b b) @@ -476,68 +473,64 @@ toSing (A b b b b) = case GHC.Tuple.(,,,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) - (toSing b :: SomeSing (KProxy :: KProxy c)) - (toSing b :: SomeSing (KProxy :: KProxy d)) + (toSing b :: SomeSing a) + (toSing b :: SomeSing b) + (toSing b :: SomeSing c) + (toSing b :: SomeSing d) of { GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) -> SomeSing (SA c c c c) } toSing (B b b b b) = case GHC.Tuple.(,,,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) - (toSing b :: SomeSing (KProxy :: KProxy c)) - (toSing b :: SomeSing (KProxy :: KProxy d)) + (toSing b :: SomeSing a) + (toSing b :: SomeSing b) + (toSing b :: SomeSing c) + (toSing b :: SomeSing d) of { GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) -> SomeSing (SB c c c c) } toSing (C b b b b) = case GHC.Tuple.(,,,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) - (toSing b :: SomeSing (KProxy :: KProxy c)) - (toSing b :: SomeSing (KProxy :: KProxy d)) + (toSing b :: SomeSing a) + (toSing b :: SomeSing b) + (toSing b :: SomeSing c) + (toSing b :: SomeSing d) of { GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) -> SomeSing (SC c c c c) } toSing (D b b b b) = case GHC.Tuple.(,,,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) - (toSing b :: SomeSing (KProxy :: KProxy c)) - (toSing b :: SomeSing (KProxy :: KProxy d)) + (toSing b :: SomeSing a) + (toSing b :: SomeSing b) + (toSing b :: SomeSing c) + (toSing b :: SomeSing d) of { GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) -> SomeSing (SD c c c c) } toSing (E b b b b) = case GHC.Tuple.(,,,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) - (toSing b :: SomeSing (KProxy :: KProxy c)) - (toSing b :: SomeSing (KProxy :: KProxy d)) + (toSing b :: SomeSing a) + (toSing b :: SomeSing b) + (toSing b :: SomeSing c) + (toSing b :: SomeSing d) of { GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) -> SomeSing (SE c c c c) } toSing (F b b b b) = case GHC.Tuple.(,,,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) - (toSing b :: SomeSing (KProxy :: KProxy c)) - (toSing b :: SomeSing (KProxy :: KProxy d)) + (toSing b :: SomeSing a) + (toSing b :: SomeSing b) + (toSing b :: SomeSing c) + (toSing b :: SomeSing d) of { GHC.Tuple.(,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c) -> SomeSing (SF c c c c) } - instance (SEq (KProxy :: KProxy a), - SEq (KProxy :: KProxy b), - SEq (KProxy :: KProxy c), - SEq (KProxy :: KProxy d)) => - SEq (KProxy :: KProxy (Foo a b c d)) where + instance (SEq a, SEq b, SEq c, SEq d) => SEq (Foo a b c d) where (%:==) (SA a a a a) (SA b b b b) = (%:&&) ((%:==) a b) @@ -592,11 +585,8 @@ = (%:&&) ((%:==) a b) ((%:&&) ((%:==) a b) ((%:&&) ((%:==) a b) ((%:==) a b))) - instance (SDecide (KProxy :: KProxy a), - SDecide (KProxy :: KProxy b), - SDecide (KProxy :: KProxy c), - SDecide (KProxy :: KProxy d)) => - SDecide (KProxy :: KProxy (Foo a b c d)) where + instance (SDecide a, SDecide b, SDecide c, SDecide d) => + SDecide (Foo a b c d) where (%~) (SA a a a a) (SA b b b b) = case GHC.Tuple.(,,,) ((%~) a b) ((%~) a b) ((%~) a b) ((%~) a b) @@ -849,8 +839,7 @@ -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) GHC.Tuple.(,,,) _ _ _ (Disproved contra) -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) } - instance SOrd (KProxy :: KProxy Nat) => - SOrd (KProxy :: KProxy Nat) where + instance SOrd Nat => SOrd Nat where sCompare :: forall (t0 :: Nat) (t1 :: Nat). Sing t0 @@ -916,11 +905,8 @@ -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) lambda _z_0123456789 = SGT in lambda _s_z_0123456789 - instance (SOrd (KProxy :: KProxy a), - SOrd (KProxy :: KProxy b), - SOrd (KProxy :: KProxy c), - SOrd (KProxy :: KProxy d)) => - SOrd (KProxy :: KProxy (Foo a b c d)) where + instance (SOrd a, SOrd b, SOrd c, SOrd d) => + SOrd (Foo a b c d) where sCompare :: forall (t0 :: Foo a b c d) (t1 :: Foo a b c d). Sing t0 diff --git a/tests/compile-and-dump/Singletons/PatternMatching.ghc710.template b/tests/compile-and-dump/Singletons/PatternMatching.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/PatternMatching.ghc710.template +++ /dev/null @@ -1,593 +0,0 @@ -Singletons/PatternMatching.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| pr = Pair (Succ Zero) ([Zero]) - complex = Pair (Pair (Just Zero) Zero) False - tuple = (False, Just Zero, True) - aList = [Zero, Succ Zero, Succ (Succ Zero)] - - data Pair a b - = Pair a b - deriving (Show) |] - ======> - data Pair a b - = Pair a b - deriving (Show) - pr = Pair (Succ Zero) [Zero] - complex = Pair (Pair (Just Zero) Zero) False - tuple = (False, Just Zero, True) - aList = [Zero, Succ Zero, Succ (Succ Zero)] - type PairSym2 (t :: a0123456789) (t :: b0123456789) = Pair t t - instance SuppressUnusedWarnings PairSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) PairSym1KindInference GHC.Tuple.()) - data PairSym1 (l :: a0123456789) - (l :: TyFun b0123456789 (Pair a0123456789 b0123456789)) - = forall arg. KindOf (Apply (PairSym1 l) arg) ~ KindOf (PairSym2 l arg) => - PairSym1KindInference - type instance Apply (PairSym1 l) l = PairSym2 l l - instance SuppressUnusedWarnings PairSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) PairSym0KindInference GHC.Tuple.()) - data PairSym0 (l :: TyFun a0123456789 (TyFun b0123456789 (Pair a0123456789 b0123456789) - -> *)) - = forall arg. KindOf (Apply PairSym0 arg) ~ KindOf (PairSym1 arg) => - PairSym0KindInference - type instance Apply PairSym0 l = PairSym1 l - type AListSym0 = AList - type TupleSym0 = Tuple - type ComplexSym0 = Complex - type PrSym0 = Pr - type family AList where - AList = Apply (Apply (:$) ZeroSym0) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:$) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))) '[])) - type family Tuple where - Tuple = Apply (Apply (Apply Tuple3Sym0 FalseSym0) (Apply JustSym0 ZeroSym0)) TrueSym0 - type family Complex where - 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) '[]) - sAList :: Sing AListSym0 - sTuple :: Sing TupleSym0 - sComplex :: Sing ComplexSym0 - sPr :: Sing PrSym0 - sAList - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing - (singFun1 (Proxy :: Proxy SuccSym0) SSucc) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))) - SNil)) - sTuple - = applySing - (applySing - (applySing (singFun3 (Proxy :: Proxy Tuple3Sym0) STuple3) SFalse) - (applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) SZero)) - STrue - sComplex - = applySing - (applySing - (singFun2 (Proxy :: Proxy PairSym0) SPair) - (applySing - (applySing - (singFun2 (Proxy :: Proxy PairSym0) SPair) - (applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) SZero)) - SZero)) - SFalse - sPr - = applySing - (applySing - (singFun2 (Proxy :: Proxy PairSym0) SPair) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero) SNil) - data instance Sing (z :: Pair a b) - = forall (n :: a) (n :: b). z ~ Pair n n => - SPair (Sing (n :: a)) (Sing (n :: b)) - type SPair = (Sing :: Pair a b -> *) - instance (SingKind (KProxy :: KProxy a), - SingKind (KProxy :: KProxy b)) => - SingKind (KProxy :: KProxy (Pair a b)) where - type DemoteRep (KProxy :: KProxy (Pair a b)) = Pair (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b)) - fromSing (SPair b b) = Pair (fromSing b) (fromSing b) - toSing (Pair b b) - = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) - of { - GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SPair c c) } - instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where - sing = SPair sing sing -Singletons/PatternMatching.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| Pair sz lz = pr - Pair (Pair jz zz) fls = complex - (tf, tjz, tt) = tuple - [_, lsz, (Succ blimy)] = aList - lsz :: Nat - fls :: Bool - foo1 :: (a, b) -> a - foo1 (x, y) = (\ _ -> x) y - foo2 :: (# a, b #) -> a - foo2 t@(# x, y #) = case t of { (# a, b #) -> (\ _ -> a) b } - silly :: a -> () - silly x = case x of { _ -> () } |] - ======> - Pair sz lz = pr - Pair (Pair jz zz) fls = complex - (tf, tjz, tt) = tuple - [_, lsz, Succ blimy] = aList - lsz :: Nat - fls :: Bool - foo1 :: forall a b. (a, b) -> a - foo1 (x, y) = \ _ -> x y - foo2 :: forall a b. (# a, b #) -> a - foo2 t@(# x, y #) = case t of { (# a, b #) -> \ _ -> a b } - silly :: forall a. a -> () - silly x = case x of { _ -> GHC.Tuple.() } - type family Case_0123456789 x t where - Case_0123456789 x _z_0123456789 = Tuple0Sym0 - type Let0123456789TSym2 t t = Let0123456789T t t - instance SuppressUnusedWarnings Let0123456789TSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789TSym1KindInference GHC.Tuple.()) - data Let0123456789TSym1 l l - = forall arg. KindOf (Apply (Let0123456789TSym1 l) arg) ~ KindOf (Let0123456789TSym2 l arg) => - Let0123456789TSym1KindInference - type instance Apply (Let0123456789TSym1 l) l = Let0123456789TSym2 l l - instance SuppressUnusedWarnings Let0123456789TSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Let0123456789TSym0KindInference GHC.Tuple.()) - data Let0123456789TSym0 l - = forall arg. KindOf (Apply Let0123456789TSym0 arg) ~ KindOf (Let0123456789TSym1 arg) => - Let0123456789TSym0KindInference - type instance Apply Let0123456789TSym0 l = Let0123456789TSym1 l - type family Let0123456789T x y where - Let0123456789T x y = Apply (Apply Tuple2Sym0 x) y - type family Case_0123456789 x y a b arg_0123456789 t where - Case_0123456789 x y a b arg_0123456789 _z_0123456789 = a - type family Lambda_0123456789 x y a b t where - Lambda_0123456789 x y a b arg_0123456789 = Case_0123456789 x y a b arg_0123456789 arg_0123456789 - type Lambda_0123456789Sym5 t t t t t = Lambda_0123456789 t t t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym4 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym4KindInference GHC.Tuple.()) - data Lambda_0123456789Sym4 l l l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym4 l l l l) arg) ~ KindOf (Lambda_0123456789Sym5 l l l l arg) => - Lambda_0123456789Sym4KindInference - type instance Apply (Lambda_0123456789Sym4 l l l l) l = Lambda_0123456789Sym5 l l l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym3 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym3KindInference GHC.Tuple.()) - data Lambda_0123456789Sym3 l l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym3 l l l) arg) ~ KindOf (Lambda_0123456789Sym4 l l l arg) => - Lambda_0123456789Sym3KindInference - type instance Apply (Lambda_0123456789Sym3 l l l) l = Lambda_0123456789Sym4 l l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type family Case_0123456789 x y t where - Case_0123456789 x y '(a, - b) = Apply (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) a) b) b - type family Case_0123456789 x y arg_0123456789 t where - Case_0123456789 x y arg_0123456789 _z_0123456789 = x - type family Lambda_0123456789 x y t where - Lambda_0123456789 x y arg_0123456789 = Case_0123456789 x y arg_0123456789 arg_0123456789 - type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t - instance SuppressUnusedWarnings Lambda_0123456789Sym2 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym2KindInference GHC.Tuple.()) - data Lambda_0123456789Sym2 l l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym2 l l) arg) ~ KindOf (Lambda_0123456789Sym3 l l arg) => - Lambda_0123456789Sym2KindInference - type instance Apply (Lambda_0123456789Sym2 l l) l = Lambda_0123456789Sym3 l l l - instance SuppressUnusedWarnings Lambda_0123456789Sym1 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym1KindInference GHC.Tuple.()) - data Lambda_0123456789Sym1 l l - = forall arg. KindOf (Apply (Lambda_0123456789Sym1 l) arg) ~ KindOf (Lambda_0123456789Sym2 l arg) => - Lambda_0123456789Sym1KindInference - type instance Apply (Lambda_0123456789Sym1 l) l = Lambda_0123456789Sym2 l l - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type family Case_0123456789 t where - Case_0123456789 '[_z_0123456789, - y_0123456789, - Succ _z_0123456789] = y_0123456789 - type family Case_0123456789 t where - Case_0123456789 '[_z_0123456789, - _z_0123456789, - Succ y_0123456789] = y_0123456789 - type family Case_0123456789 t where - Case_0123456789 '(y_0123456789, - _z_0123456789, - _z_0123456789) = y_0123456789 - type family Case_0123456789 t where - Case_0123456789 '(_z_0123456789, - y_0123456789, - _z_0123456789) = y_0123456789 - type family Case_0123456789 t where - Case_0123456789 '(_z_0123456789, - _z_0123456789, - y_0123456789) = y_0123456789 - type family Case_0123456789 t where - Case_0123456789 (Pair (Pair y_0123456789 _z_0123456789) _z_0123456789) = y_0123456789 - type family Case_0123456789 t where - Case_0123456789 (Pair (Pair _z_0123456789 y_0123456789) _z_0123456789) = y_0123456789 - type family Case_0123456789 t where - Case_0123456789 (Pair (Pair _z_0123456789 _z_0123456789) y_0123456789) = y_0123456789 - type family Case_0123456789 t where - Case_0123456789 (Pair y_0123456789 _z_0123456789) = y_0123456789 - type family Case_0123456789 t where - Case_0123456789 (Pair _z_0123456789 y_0123456789) = y_0123456789 - type SillySym1 (t :: a0123456789) = Silly t - instance SuppressUnusedWarnings SillySym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) SillySym0KindInference GHC.Tuple.()) - data SillySym0 (l :: TyFun a0123456789 ()) - = forall arg. KindOf (Apply SillySym0 arg) ~ KindOf (SillySym1 arg) => - SillySym0KindInference - type instance Apply SillySym0 l = SillySym1 l - type Foo2Sym1 (t :: (a0123456789, b0123456789)) = Foo2 t - instance SuppressUnusedWarnings Foo2Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo2Sym0KindInference GHC.Tuple.()) - data Foo2Sym0 (l :: TyFun (a0123456789, b0123456789) a0123456789) - = forall arg. KindOf (Apply Foo2Sym0 arg) ~ KindOf (Foo2Sym1 arg) => - Foo2Sym0KindInference - type instance Apply Foo2Sym0 l = Foo2Sym1 l - type Foo1Sym1 (t :: (a0123456789, b0123456789)) = Foo1 t - instance SuppressUnusedWarnings Foo1Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Foo1Sym0KindInference GHC.Tuple.()) - data Foo1Sym0 (l :: TyFun (a0123456789, b0123456789) a0123456789) - = forall arg. KindOf (Apply Foo1Sym0 arg) ~ KindOf (Foo1Sym1 arg) => - Foo1Sym0KindInference - type instance Apply Foo1Sym0 l = Foo1Sym1 l - type LszSym0 = Lsz - type BlimySym0 = Blimy - type TfSym0 = Tf - type TjzSym0 = Tjz - type TtSym0 = Tt - type JzSym0 = Jz - type ZzSym0 = Zz - type FlsSym0 = Fls - type SzSym0 = Sz - type LzSym0 = Lz - type X_0123456789Sym0 = X_0123456789 - type X_0123456789Sym0 = X_0123456789 - type X_0123456789Sym0 = X_0123456789 - type X_0123456789Sym0 = X_0123456789 - type family Silly (a :: a) :: () where - Silly x = Case_0123456789 x x - type family Foo2 (a :: (a, b)) :: a where - Foo2 '(x, y) = Case_0123456789 x y (Let0123456789TSym2 x y) - type family Foo1 (a :: (a, b)) :: a where - Foo1 '(x, y) = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) y - type family Lsz :: Nat where - Lsz = Case_0123456789 X_0123456789Sym0 - type family Blimy where - Blimy = Case_0123456789 X_0123456789Sym0 - type family Tf where - Tf = Case_0123456789 X_0123456789Sym0 - type family Tjz where - Tjz = Case_0123456789 X_0123456789Sym0 - type family Tt where - Tt = Case_0123456789 X_0123456789Sym0 - type family Jz where - Jz = Case_0123456789 X_0123456789Sym0 - type family Zz where - Zz = Case_0123456789 X_0123456789Sym0 - type family Fls :: Bool where - Fls = Case_0123456789 X_0123456789Sym0 - type family Sz where - Sz = Case_0123456789 X_0123456789Sym0 - type family Lz where - Lz = Case_0123456789 X_0123456789Sym0 - type family X_0123456789 where - X_0123456789 = PrSym0 - type family X_0123456789 where - X_0123456789 = ComplexSym0 - type family X_0123456789 where - X_0123456789 = TupleSym0 - type family X_0123456789 where - X_0123456789 = AListSym0 - sSilly :: forall (t :: a). Sing t -> Sing (Apply SillySym0 t :: ()) - sFoo2 :: - forall (t :: (a, b)). Sing t -> Sing (Apply Foo2Sym0 t :: a) - sFoo1 :: - forall (t :: (a, b)). Sing t -> Sing (Apply Foo1Sym0 t :: a) - sLsz :: Sing (LszSym0 :: Nat) - sBlimy :: Sing BlimySym0 - sTf :: Sing TfSym0 - sTjz :: Sing TjzSym0 - sTt :: Sing TtSym0 - sJz :: Sing JzSym0 - sZz :: Sing ZzSym0 - sFls :: Sing (FlsSym0 :: Bool) - sSz :: Sing SzSym0 - sLz :: Sing LzSym0 - sX_0123456789 :: Sing X_0123456789Sym0 - sX_0123456789 :: Sing X_0123456789Sym0 - sX_0123456789 :: Sing X_0123456789Sym0 - sX_0123456789 :: Sing X_0123456789Sym0 - sSilly sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply SillySym0 t :: ()) - lambda x - = case x of { - _s_z_0123456789 - -> let - lambda :: - forall _z_0123456789. _z_0123456789 ~ x => - Sing _z_0123456789 -> Sing (Case_0123456789 x _z_0123456789 :: ()) - lambda _z_0123456789 = STuple0 - in lambda _s_z_0123456789 } :: - Sing (Case_0123456789 x x :: ()) - in lambda sX - sFoo2 (STuple2 sX sY) - = let - lambda :: - forall x y. t ~ Apply (Apply Tuple2Sym0 x) y => - Sing x -> Sing y -> Sing (Apply Foo2Sym0 t :: a) - lambda x y - = let - sT :: Sing (Let0123456789TSym2 x y) - sT - = applySing - (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) x) y - in case sT of { - STuple2 sA sB - -> let - lambda :: - forall a - b. Apply (Apply Tuple2Sym0 a) b ~ Let0123456789TSym2 x y => - Sing a - -> Sing b - -> Sing (Case_0123456789 x y (Apply (Apply Tuple2Sym0 a) b) :: a) - lambda a b - = applySing - (singFun1 - (Proxy :: - Proxy (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) a) b)) - (\ sArg_0123456789 - -> let - lambda :: - forall arg_0123456789. - Sing arg_0123456789 - -> Sing (Apply (Apply (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) a) b) arg_0123456789) - lambda arg_0123456789 - = case arg_0123456789 of { - _s_z_0123456789 - -> let - lambda :: - forall _z_0123456789. _z_0123456789 ~ arg_0123456789 => - Sing _z_0123456789 - -> Sing (Case_0123456789 x y a b arg_0123456789 _z_0123456789) - lambda _z_0123456789 = a - in lambda _s_z_0123456789 } :: - Sing (Case_0123456789 x y a b arg_0123456789 arg_0123456789) - in lambda sArg_0123456789)) - b - in lambda sA sB } :: - Sing (Case_0123456789 x y (Let0123456789TSym2 x y) :: a) - in lambda sX sY - sFoo1 (STuple2 sX sY) - = let - lambda :: - forall x y. t ~ Apply (Apply Tuple2Sym0 x) y => - Sing x -> Sing y -> Sing (Apply Foo1Sym0 t :: a) - lambda x y - = applySing - (singFun1 - (Proxy :: Proxy (Apply (Apply Lambda_0123456789Sym0 x) y)) - (\ sArg_0123456789 - -> let - lambda :: - forall arg_0123456789. - Sing arg_0123456789 - -> Sing (Apply (Apply (Apply Lambda_0123456789Sym0 x) y) arg_0123456789) - lambda arg_0123456789 - = case arg_0123456789 of { - _s_z_0123456789 - -> let - lambda :: - forall _z_0123456789. _z_0123456789 ~ arg_0123456789 => - Sing _z_0123456789 - -> Sing (Case_0123456789 x y arg_0123456789 _z_0123456789) - lambda _z_0123456789 = x - in lambda _s_z_0123456789 } :: - Sing (Case_0123456789 x y arg_0123456789 arg_0123456789) - in lambda sArg_0123456789)) - y - in lambda sX sY - sLsz - = case sX_0123456789 of { - SCons _s_z_0123456789 - (SCons sY_0123456789 (SCons (SSucc _s_z_0123456789) SNil)) - -> let - lambda :: - forall _z_0123456789 - y_0123456789 - _z_0123456789. Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) y_0123456789) (Apply (Apply (:$) (Apply SuccSym0 _z_0123456789)) '[])) ~ X_0123456789Sym0 => - Sing _z_0123456789 - -> Sing y_0123456789 - -> Sing _z_0123456789 - -> Sing (Case_0123456789 (Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) y_0123456789) (Apply (Apply (:$) (Apply SuccSym0 _z_0123456789)) '[]))) :: Nat) - lambda _z_0123456789 y_0123456789 _z_0123456789 = y_0123456789 - in lambda _s_z_0123456789 sY_0123456789 _s_z_0123456789 } :: - Sing (Case_0123456789 X_0123456789Sym0 :: Nat) - sBlimy - = case sX_0123456789 of { - SCons _s_z_0123456789 - (SCons _s_z_0123456789 (SCons (SSucc sY_0123456789) SNil)) - -> let - lambda :: - forall _z_0123456789 - _z_0123456789 - y_0123456789. Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) (Apply SuccSym0 y_0123456789)) '[])) ~ X_0123456789Sym0 => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing y_0123456789 - -> Sing (Case_0123456789 (Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) (Apply SuccSym0 y_0123456789)) '[])))) - lambda _z_0123456789 _z_0123456789 y_0123456789 = y_0123456789 - in lambda _s_z_0123456789 _s_z_0123456789 sY_0123456789 } :: - Sing (Case_0123456789 X_0123456789Sym0) - sTf - = case sX_0123456789 of { - STuple3 sY_0123456789 _s_z_0123456789 _s_z_0123456789 - -> let - lambda :: - forall y_0123456789 - _z_0123456789 - _z_0123456789. Apply (Apply (Apply Tuple3Sym0 y_0123456789) _z_0123456789) _z_0123456789 ~ X_0123456789Sym0 => - Sing y_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Case_0123456789 (Apply (Apply (Apply Tuple3Sym0 y_0123456789) _z_0123456789) _z_0123456789)) - lambda y_0123456789 _z_0123456789 _z_0123456789 = y_0123456789 - in lambda sY_0123456789 _s_z_0123456789 _s_z_0123456789 } :: - Sing (Case_0123456789 X_0123456789Sym0) - sTjz - = case sX_0123456789 of { - STuple3 _s_z_0123456789 sY_0123456789 _s_z_0123456789 - -> let - lambda :: - forall _z_0123456789 - y_0123456789 - _z_0123456789. Apply (Apply (Apply Tuple3Sym0 _z_0123456789) y_0123456789) _z_0123456789 ~ X_0123456789Sym0 => - Sing _z_0123456789 - -> Sing y_0123456789 - -> Sing _z_0123456789 - -> Sing (Case_0123456789 (Apply (Apply (Apply Tuple3Sym0 _z_0123456789) y_0123456789) _z_0123456789)) - lambda _z_0123456789 y_0123456789 _z_0123456789 = y_0123456789 - in lambda _s_z_0123456789 sY_0123456789 _s_z_0123456789 } :: - Sing (Case_0123456789 X_0123456789Sym0) - sTt - = case sX_0123456789 of { - STuple3 _s_z_0123456789 _s_z_0123456789 sY_0123456789 - -> let - lambda :: - forall _z_0123456789 - _z_0123456789 - y_0123456789. Apply (Apply (Apply Tuple3Sym0 _z_0123456789) _z_0123456789) y_0123456789 ~ X_0123456789Sym0 => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing y_0123456789 - -> Sing (Case_0123456789 (Apply (Apply (Apply Tuple3Sym0 _z_0123456789) _z_0123456789) y_0123456789)) - lambda _z_0123456789 _z_0123456789 y_0123456789 = y_0123456789 - in lambda _s_z_0123456789 _s_z_0123456789 sY_0123456789 } :: - Sing (Case_0123456789 X_0123456789Sym0) - sJz - = case sX_0123456789 of { - SPair (SPair sY_0123456789 _s_z_0123456789) _s_z_0123456789 - -> let - lambda :: - forall y_0123456789 - _z_0123456789 - _z_0123456789. Apply (Apply PairSym0 (Apply (Apply PairSym0 y_0123456789) _z_0123456789)) _z_0123456789 ~ X_0123456789Sym0 => - Sing y_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Case_0123456789 (Apply (Apply PairSym0 (Apply (Apply PairSym0 y_0123456789) _z_0123456789)) _z_0123456789)) - lambda y_0123456789 _z_0123456789 _z_0123456789 = y_0123456789 - in lambda sY_0123456789 _s_z_0123456789 _s_z_0123456789 } :: - Sing (Case_0123456789 X_0123456789Sym0) - sZz - = case sX_0123456789 of { - SPair (SPair _s_z_0123456789 sY_0123456789) _s_z_0123456789 - -> let - lambda :: - forall _z_0123456789 - y_0123456789 - _z_0123456789. Apply (Apply PairSym0 (Apply (Apply PairSym0 _z_0123456789) y_0123456789)) _z_0123456789 ~ X_0123456789Sym0 => - Sing _z_0123456789 - -> Sing y_0123456789 - -> Sing _z_0123456789 - -> Sing (Case_0123456789 (Apply (Apply PairSym0 (Apply (Apply PairSym0 _z_0123456789) y_0123456789)) _z_0123456789)) - lambda _z_0123456789 y_0123456789 _z_0123456789 = y_0123456789 - in lambda _s_z_0123456789 sY_0123456789 _s_z_0123456789 } :: - Sing (Case_0123456789 X_0123456789Sym0) - sFls - = case sX_0123456789 of { - SPair (SPair _s_z_0123456789 _s_z_0123456789) sY_0123456789 - -> let - lambda :: - forall _z_0123456789 - _z_0123456789 - y_0123456789. Apply (Apply PairSym0 (Apply (Apply PairSym0 _z_0123456789) _z_0123456789)) y_0123456789 ~ X_0123456789Sym0 => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing y_0123456789 - -> Sing (Case_0123456789 (Apply (Apply PairSym0 (Apply (Apply PairSym0 _z_0123456789) _z_0123456789)) y_0123456789) :: Bool) - lambda _z_0123456789 _z_0123456789 y_0123456789 = y_0123456789 - in lambda _s_z_0123456789 _s_z_0123456789 sY_0123456789 } :: - Sing (Case_0123456789 X_0123456789Sym0 :: Bool) - sSz - = case sX_0123456789 of { - SPair sY_0123456789 _s_z_0123456789 - -> let - lambda :: - forall y_0123456789 - _z_0123456789. Apply (Apply PairSym0 y_0123456789) _z_0123456789 ~ X_0123456789Sym0 => - Sing y_0123456789 - -> Sing _z_0123456789 - -> Sing (Case_0123456789 (Apply (Apply PairSym0 y_0123456789) _z_0123456789)) - lambda y_0123456789 _z_0123456789 = y_0123456789 - in lambda sY_0123456789 _s_z_0123456789 } :: - Sing (Case_0123456789 X_0123456789Sym0) - sLz - = case sX_0123456789 of { - SPair _s_z_0123456789 sY_0123456789 - -> let - lambda :: - forall _z_0123456789 - y_0123456789. Apply (Apply PairSym0 _z_0123456789) y_0123456789 ~ X_0123456789Sym0 => - Sing _z_0123456789 - -> Sing y_0123456789 - -> Sing (Case_0123456789 (Apply (Apply PairSym0 _z_0123456789) y_0123456789)) - lambda _z_0123456789 y_0123456789 = y_0123456789 - in lambda _s_z_0123456789 sY_0123456789 } :: - Sing (Case_0123456789 X_0123456789Sym0) - sX_0123456789 = sPr - sX_0123456789 = sComplex - sX_0123456789 = sTuple - sX_0123456789 = sAList diff --git a/tests/compile-and-dump/Singletons/PatternMatching.ghc80.template b/tests/compile-and-dump/Singletons/PatternMatching.ghc80.template --- a/tests/compile-and-dump/Singletons/PatternMatching.ghc80.template +++ b/tests/compile-and-dump/Singletons/PatternMatching.ghc80.template @@ -90,16 +90,12 @@ = forall (n :: a) (n :: b). z ~ Pair n n => SPair (Sing (n :: a)) (Sing (n :: b)) type SPair = (Sing :: Pair a b -> GHC.Types.Type) - instance (SingKind (KProxy :: KProxy a), - SingKind (KProxy :: KProxy b)) => - SingKind (KProxy :: KProxy (Pair a b)) where - type DemoteRep (KProxy :: KProxy (Pair a b)) = Pair (DemoteRep (KProxy :: KProxy a)) (DemoteRep (KProxy :: KProxy b)) + instance (SingKind a, SingKind b) => SingKind (Pair a b) where + type DemoteRep (Pair a b) = Pair (DemoteRep a) (DemoteRep b) fromSing (SPair b b) = Pair (fromSing b) (fromSing b) toSing (Pair b b) = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy b)) + GHC.Tuple.(,) (toSing b :: SomeSing a) (toSing b :: SomeSing b) of { GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SPair c c) } instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where diff --git a/tests/compile-and-dump/Singletons/Records.ghc710.template b/tests/compile-and-dump/Singletons/Records.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/Records.ghc710.template +++ /dev/null @@ -1,61 +0,0 @@ -Singletons/Records.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| data Record a = MkRecord {field1 :: a, field2 :: Bool} |] - ======> - data Record a = MkRecord {field1 :: a, field2 :: Bool} - type Field1Sym1 (t :: Record a0123456789) = Field1 t - instance SuppressUnusedWarnings Field1Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Field1Sym0KindInference GHC.Tuple.()) - data Field1Sym0 (l :: TyFun (Record a0123456789) a0123456789) - = forall arg. KindOf (Apply Field1Sym0 arg) ~ KindOf (Field1Sym1 arg) => - Field1Sym0KindInference - type instance Apply Field1Sym0 l = Field1Sym1 l - type Field2Sym1 (t :: Record a0123456789) = Field2 t - instance SuppressUnusedWarnings Field2Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Field2Sym0KindInference GHC.Tuple.()) - data Field2Sym0 (l :: TyFun (Record a0123456789) Bool) - = forall arg. KindOf (Apply Field2Sym0 arg) ~ KindOf (Field2Sym1 arg) => - Field2Sym0KindInference - type instance Apply Field2Sym0 l = Field2Sym1 l - type family Field1 (a :: Record a) :: a where - Field1 (MkRecord field _z_0123456789) = field - type family Field2 (a :: Record a) :: Bool where - Field2 (MkRecord _z_0123456789 field) = field - type MkRecordSym2 (t :: a0123456789) (t :: Bool) = MkRecord t t - instance SuppressUnusedWarnings MkRecordSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) MkRecordSym1KindInference GHC.Tuple.()) - data MkRecordSym1 (l :: a0123456789) - (l :: TyFun Bool (Record a0123456789)) - = forall arg. KindOf (Apply (MkRecordSym1 l) arg) ~ KindOf (MkRecordSym2 l arg) => - MkRecordSym1KindInference - type instance Apply (MkRecordSym1 l) l = MkRecordSym2 l l - instance SuppressUnusedWarnings MkRecordSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) MkRecordSym0KindInference GHC.Tuple.()) - data MkRecordSym0 (l :: TyFun a0123456789 (TyFun Bool (Record a0123456789) - -> *)) - = forall arg. KindOf (Apply MkRecordSym0 arg) ~ KindOf (MkRecordSym1 arg) => - MkRecordSym0KindInference - type instance Apply MkRecordSym0 l = MkRecordSym1 l - data instance Sing (z :: Record a) - = forall (n :: a) (n :: Bool). z ~ MkRecord n n => - SMkRecord {sField1 :: Sing (n :: a), sField2 :: Sing (n :: Bool)} - type SRecord = (Sing :: Record a -> *) - instance SingKind (KProxy :: KProxy a) => - SingKind (KProxy :: KProxy (Record a)) where - type DemoteRep (KProxy :: KProxy (Record a)) = Record (DemoteRep (KProxy :: KProxy a)) - fromSing (SMkRecord b b) = MkRecord (fromSing b) (fromSing b) - toSing (MkRecord b b) - = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy Bool)) - of { - GHC.Tuple.(,) (SomeSing c) (SomeSing c) - -> SomeSing (SMkRecord c c) } - instance (SingI n, SingI n) => - SingI (MkRecord (n :: a) (n :: Bool)) where - sing = SMkRecord sing sing diff --git a/tests/compile-and-dump/Singletons/Records.ghc80.template b/tests/compile-and-dump/Singletons/Records.ghc80.template --- a/tests/compile-and-dump/Singletons/Records.ghc80.template +++ b/tests/compile-and-dump/Singletons/Records.ghc80.template @@ -45,15 +45,12 @@ SMkRecord {sField1 :: (Sing (n :: a)), sField2 :: (Sing (n :: Bool))} type SRecord = (Sing :: Record a -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy a) => - SingKind (KProxy :: KProxy (Record a)) where - type DemoteRep (KProxy :: KProxy (Record a)) = Record (DemoteRep (KProxy :: KProxy a)) + instance SingKind a => SingKind (Record a) where + type DemoteRep (Record a) = Record (DemoteRep a) fromSing (SMkRecord b b) = MkRecord (fromSing b) (fromSing b) toSing (MkRecord b b) = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy a)) - (toSing b :: SomeSing (KProxy :: KProxy Bool)) + GHC.Tuple.(,) (toSing b :: SomeSing a) (toSing b :: SomeSing Bool) of { GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SMkRecord c c) } diff --git a/tests/compile-and-dump/Singletons/ReturnFunc.ghc710.template b/tests/compile-and-dump/Singletons/ReturnFunc.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/ReturnFunc.ghc710.template +++ /dev/null @@ -1,94 +0,0 @@ -Singletons/ReturnFunc.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| returnFunc :: Nat -> Nat -> Nat - returnFunc _ = Succ - id :: a -> a - id x = x - idFoo :: c -> a -> a - idFoo _ = id |] - ======> - returnFunc :: Nat -> Nat -> Nat - returnFunc _ = Succ - id :: forall a. a -> a - id x = x - idFoo :: forall c a. c -> a -> a - idFoo _ = id - type IdSym1 (t :: a0123456789) = Id t - instance SuppressUnusedWarnings IdSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) IdSym0KindInference GHC.Tuple.()) - data IdSym0 (l :: TyFun a0123456789 a0123456789) - = forall arg. KindOf (Apply IdSym0 arg) ~ KindOf (IdSym1 arg) => - IdSym0KindInference - type instance Apply IdSym0 l = IdSym1 l - type IdFooSym2 (t :: c0123456789) (t :: a0123456789) = IdFoo t t - instance SuppressUnusedWarnings IdFooSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) IdFooSym1KindInference GHC.Tuple.()) - data IdFooSym1 (l :: c0123456789) - (l :: TyFun a0123456789 a0123456789) - = forall arg. KindOf (Apply (IdFooSym1 l) arg) ~ KindOf (IdFooSym2 l arg) => - IdFooSym1KindInference - type instance Apply (IdFooSym1 l) l = IdFooSym2 l l - instance SuppressUnusedWarnings IdFooSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) IdFooSym0KindInference GHC.Tuple.()) - data IdFooSym0 (l :: TyFun c0123456789 (TyFun a0123456789 a0123456789 - -> *)) - = forall arg. KindOf (Apply IdFooSym0 arg) ~ KindOf (IdFooSym1 arg) => - IdFooSym0KindInference - type instance Apply IdFooSym0 l = IdFooSym1 l - type ReturnFuncSym2 (t :: Nat) (t :: Nat) = ReturnFunc t t - instance SuppressUnusedWarnings ReturnFuncSym1 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ReturnFuncSym1KindInference GHC.Tuple.()) - data ReturnFuncSym1 (l :: Nat) (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply (ReturnFuncSym1 l) arg) ~ KindOf (ReturnFuncSym2 l arg) => - ReturnFuncSym1KindInference - type instance Apply (ReturnFuncSym1 l) l = ReturnFuncSym2 l l - instance SuppressUnusedWarnings ReturnFuncSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) ReturnFuncSym0KindInference GHC.Tuple.()) - data ReturnFuncSym0 (l :: TyFun Nat (TyFun Nat Nat -> *)) - = forall arg. KindOf (Apply ReturnFuncSym0 arg) ~ KindOf (ReturnFuncSym1 arg) => - ReturnFuncSym0KindInference - type instance Apply ReturnFuncSym0 l = ReturnFuncSym1 l - type family Id (a :: a) :: a where - Id x = x - type family IdFoo (a :: c) (a :: a) :: a where - IdFoo _z_0123456789 a_0123456789 = Apply IdSym0 a_0123456789 - type family ReturnFunc (a :: Nat) (a :: Nat) :: Nat where - ReturnFunc _z_0123456789 a_0123456789 = Apply SuccSym0 a_0123456789 - sId :: forall (t :: a). Sing t -> Sing (Apply IdSym0 t :: a) - sIdFoo :: - forall (t :: c) (t :: a). - Sing t -> Sing t -> Sing (Apply (Apply IdFooSym0 t) t :: a) - sReturnFunc :: - forall (t :: Nat) (t :: Nat). - Sing t -> Sing t -> Sing (Apply (Apply ReturnFuncSym0 t) t :: Nat) - sId sX - = let - lambda :: forall x. t ~ x => Sing x -> Sing (Apply IdSym0 t :: a) - lambda x = x - in lambda sX - sIdFoo _s_z_0123456789 sA_0123456789 - = let - lambda :: - forall _z_0123456789 a_0123456789. (t ~ _z_0123456789, - t ~ a_0123456789) => - Sing _z_0123456789 - -> Sing a_0123456789 -> Sing (Apply (Apply IdFooSym0 t) t :: a) - lambda _z_0123456789 a_0123456789 - = applySing (singFun1 (Proxy :: Proxy IdSym0) sId) a_0123456789 - in lambda _s_z_0123456789 sA_0123456789 - sReturnFunc _s_z_0123456789 sA_0123456789 - = let - lambda :: - forall _z_0123456789 a_0123456789. (t ~ _z_0123456789, - t ~ a_0123456789) => - Sing _z_0123456789 - -> Sing a_0123456789 - -> Sing (Apply (Apply ReturnFuncSym0 t) t :: Nat) - lambda _z_0123456789 a_0123456789 - = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) a_0123456789 - in lambda _s_z_0123456789 sA_0123456789 diff --git a/tests/compile-and-dump/Singletons/Sections.ghc710.template b/tests/compile-and-dump/Singletons/Sections.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/Sections.ghc710.template +++ /dev/null @@ -1,142 +0,0 @@ -Singletons/Sections.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| (+) :: Nat -> Nat -> Nat - Zero + m = m - (Succ n) + m = Succ (n + m) - foo1 :: [Nat] - foo1 = map ((Succ Zero) +) [Zero, Succ Zero] - foo2 :: [Nat] - foo2 = map (+ (Succ Zero)) [Zero, Succ Zero] - foo3 :: [Nat] - foo3 = zipWith (+) [Succ Zero, Succ Zero] [Zero, Succ Zero] |] - ======> - (+) :: Nat -> Nat -> Nat - (+) Zero m = m - (+) (Succ n) m = Succ (n + m) - foo1 :: [Nat] - foo1 = map (Succ Zero +) [Zero, Succ Zero] - foo2 :: [Nat] - foo2 = map (+ Succ Zero) [Zero, Succ Zero] - foo3 :: [Nat] - foo3 = zipWith (+) [Succ Zero, Succ Zero] [Zero, Succ Zero] - type family Lambda_0123456789 t where - Lambda_0123456789 lhs_0123456789 = Apply (Apply (:+$) lhs_0123456789) (Apply SuccSym0 ZeroSym0) - type Lambda_0123456789Sym1 t = Lambda_0123456789 t - instance SuppressUnusedWarnings Lambda_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Lambda_0123456789Sym0KindInference GHC.Tuple.()) - data Lambda_0123456789Sym0 l - = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) => - Lambda_0123456789Sym0KindInference - type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l - type (:+$$$) (t :: Nat) (t :: Nat) = (:+) t t - instance SuppressUnusedWarnings (:+$$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:+$$###) GHC.Tuple.()) - data (:+$$) (l :: Nat) (l :: TyFun Nat Nat) - = forall arg. KindOf (Apply ((:+$$) l) arg) ~ KindOf ((:+$$$) l arg) => - :+$$### - type instance Apply ((:+$$) l) l = (:+$$$) l l - instance SuppressUnusedWarnings (:+$) where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) (:+$###) GHC.Tuple.()) - data (:+$) (l :: TyFun Nat (TyFun Nat Nat -> *)) - = forall arg. KindOf (Apply (:+$) arg) ~ KindOf ((:+$$) arg) => - :+$### - type instance Apply (:+$) l = (:+$$) l - type Foo1Sym0 = Foo1 - type Foo2Sym0 = Foo2 - type Foo3Sym0 = Foo3 - type family (:+) (a :: Nat) (a :: Nat) :: Nat where - (:+) Zero m = m - (:+) (Succ n) m = Apply SuccSym0 (Apply (Apply (:+$) n) m) - type family Foo1 :: [Nat] where - Foo1 = Apply (Apply MapSym0 (Apply (:+$) (Apply SuccSym0 ZeroSym0))) (Apply (Apply (:$) ZeroSym0) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) '[])) - type family Foo2 :: [Nat] where - Foo2 = Apply (Apply MapSym0 Lambda_0123456789Sym0) (Apply (Apply (:$) ZeroSym0) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) '[])) - type family Foo3 :: [Nat] where - Foo3 = Apply (Apply (Apply ZipWithSym0 (:+$)) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) '[]))) (Apply (Apply (:$) ZeroSym0) (Apply (Apply (:$) (Apply SuccSym0 ZeroSym0)) '[])) - (%:+) :: - forall (t :: Nat) (t :: Nat). - Sing t -> Sing t -> Sing (Apply (Apply (:+$) t) t :: Nat) - sFoo1 :: Sing (Foo1Sym0 :: [Nat]) - sFoo2 :: Sing (Foo2Sym0 :: [Nat]) - sFoo3 :: Sing (Foo3Sym0 :: [Nat]) - (%:+) SZero sM - = let - lambda :: - forall m. (t ~ ZeroSym0, t ~ m) => - Sing m -> Sing (Apply (Apply (:+$) t) t :: Nat) - lambda m = m - in lambda sM - (%:+) (SSucc sN) sM - = let - lambda :: - forall n m. (t ~ Apply SuccSym0 n, t ~ m) => - Sing n -> Sing m -> Sing (Apply (Apply (:+$) t) t :: Nat) - lambda n m - = applySing - (singFun1 (Proxy :: Proxy SuccSym0) SSucc) - (applySing (applySing (singFun2 (Proxy :: Proxy (:+$)) (%:+)) n) m) - in lambda sN sM - sFoo1 - = applySing - (applySing - (singFun2 (Proxy :: Proxy MapSym0) sMap) - (applySing - (singFun2 (Proxy :: Proxy (:+$)) (%:+)) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)) - SNil)) - sFoo2 - = applySing - (applySing - (singFun2 (Proxy :: Proxy MapSym0) sMap) - (singFun1 - (Proxy :: Proxy Lambda_0123456789Sym0) - (\ sLhs_0123456789 - -> let - lambda :: - forall lhs_0123456789. - Sing lhs_0123456789 - -> Sing (Apply Lambda_0123456789Sym0 lhs_0123456789) - lambda lhs_0123456789 - = applySing - (applySing (singFun2 (Proxy :: Proxy (:+$)) (%:+)) lhs_0123456789) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero) - in lambda sLhs_0123456789))) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)) - SNil)) - sFoo3 - = applySing - (applySing - (applySing - (singFun3 (Proxy :: Proxy ZipWithSym0) sZipWith) - (singFun2 (Proxy :: Proxy (:+$)) (%:+))) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)) - SNil))) - (applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SZero) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero)) - SNil)) diff --git a/tests/compile-and-dump/Singletons/Star.ghc710.template b/tests/compile-and-dump/Singletons/Star.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/Star.ghc710.template +++ /dev/null @@ -1,587 +0,0 @@ -Singletons/Star.hs:0:0:: Splicing declarations - singletonStar [''Nat, ''Int, ''String, ''Maybe, ''Vec] - ======> - data Rep - = Singletons.Star.Nat | - Singletons.Star.Int | - Singletons.Star.String | - Singletons.Star.Maybe Rep | - Singletons.Star.Vec Rep Nat - deriving (Eq, Show, Read) - type family Equals_0123456789 (a :: *) (b :: *) :: Bool where - Equals_0123456789 Nat Nat = TrueSym0 - Equals_0123456789 Int Int = TrueSym0 - Equals_0123456789 String String = TrueSym0 - Equals_0123456789 (Maybe a) (Maybe b) = (:==) a b - Equals_0123456789 (Vec a a) (Vec b b) = (:&&) ((:==) a b) ((:==) a b) - Equals_0123456789 (a :: *) (b :: *) = FalseSym0 - instance PEq (KProxy :: KProxy *) where - type (:==) (a :: *) (b :: *) = Equals_0123456789 a b - type NatSym0 = Nat - type IntSym0 = Int - type StringSym0 = String - type MaybeSym1 (t :: *) = Maybe t - instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings MaybeSym0 where - Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) MaybeSym0KindInference GHC.Tuple.()) - data MaybeSym0 (l :: TyFun * *) - = forall arg. KindOf (Apply MaybeSym0 arg) ~ KindOf (MaybeSym1 arg) => - MaybeSym0KindInference - type instance Apply MaybeSym0 l = MaybeSym1 l - type VecSym2 (t :: *) (t :: Nat) = Vec t t - instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings VecSym1 where - Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) VecSym1KindInference GHC.Tuple.()) - data VecSym1 (l :: *) (l :: TyFun Nat *) - = forall arg. KindOf (Apply (VecSym1 l) arg) ~ KindOf (VecSym2 l arg) => - VecSym1KindInference - type instance Apply (VecSym1 l) l = VecSym2 l l - instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings VecSym0 where - Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) VecSym0KindInference GHC.Tuple.()) - data VecSym0 (l :: TyFun * (TyFun Nat * -> *)) - = forall arg. KindOf (Apply VecSym0 arg) ~ KindOf (VecSym1 arg) => - VecSym0KindInference - type instance Apply VecSym0 l = VecSym1 l - type family Compare_0123456789 (a :: *) (a :: *) :: Ordering where - Compare_0123456789 Nat Nat = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[] - Compare_0123456789 Int Int = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[] - Compare_0123456789 String String = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[] - Compare_0123456789 (Maybe a_0123456789) (Maybe b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[]) - Compare_0123456789 (Vec a_0123456789 a_0123456789) (Vec b_0123456789 b_0123456789) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) (Apply (Apply (:$) (Apply (Apply CompareSym0 a_0123456789) b_0123456789)) '[])) - Compare_0123456789 Nat Int = LTSym0 - Compare_0123456789 Nat String = LTSym0 - Compare_0123456789 Nat (Maybe _z_0123456789) = LTSym0 - Compare_0123456789 Nat (Vec _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 Int Nat = GTSym0 - Compare_0123456789 Int String = LTSym0 - Compare_0123456789 Int (Maybe _z_0123456789) = LTSym0 - Compare_0123456789 Int (Vec _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 String Nat = GTSym0 - Compare_0123456789 String Int = GTSym0 - Compare_0123456789 String (Maybe _z_0123456789) = LTSym0 - Compare_0123456789 String (Vec _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (Maybe _z_0123456789) Nat = GTSym0 - Compare_0123456789 (Maybe _z_0123456789) Int = GTSym0 - Compare_0123456789 (Maybe _z_0123456789) String = GTSym0 - Compare_0123456789 (Maybe _z_0123456789) (Vec _z_0123456789 _z_0123456789) = LTSym0 - Compare_0123456789 (Vec _z_0123456789 _z_0123456789) Nat = GTSym0 - Compare_0123456789 (Vec _z_0123456789 _z_0123456789) Int = GTSym0 - Compare_0123456789 (Vec _z_0123456789 _z_0123456789) String = GTSym0 - Compare_0123456789 (Vec _z_0123456789 _z_0123456789) (Maybe _z_0123456789) = GTSym0 - type Compare_0123456789Sym2 (t :: *) (t :: *) = - Compare_0123456789 t t - instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings Compare_0123456789Sym1 where - Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Compare_0123456789Sym1KindInference GHC.Tuple.()) - data Compare_0123456789Sym1 (l :: *) (l :: TyFun * Ordering) - = forall arg. KindOf (Apply (Compare_0123456789Sym1 l) arg) ~ KindOf (Compare_0123456789Sym2 l arg) => - Compare_0123456789Sym1KindInference - type instance Apply (Compare_0123456789Sym1 l) l = Compare_0123456789Sym2 l l - instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings Compare_0123456789Sym0 where - Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) Compare_0123456789Sym0KindInference GHC.Tuple.()) - data Compare_0123456789Sym0 (l :: TyFun * (TyFun * Ordering -> *)) - = forall arg. KindOf (Apply Compare_0123456789Sym0 arg) ~ KindOf (Compare_0123456789Sym1 arg) => - Compare_0123456789Sym0KindInference - type instance Apply Compare_0123456789Sym0 l = Compare_0123456789Sym1 l - instance POrd (KProxy :: KProxy *) where - type Compare (a :: *) (a :: *) = Apply (Apply Compare_0123456789Sym0 a) a - instance (SOrd (KProxy :: KProxy *), - SOrd (KProxy :: KProxy Nat)) => - SOrd (KProxy :: KProxy *) where - sCompare :: - forall (t0 :: *) (t1 :: *). - Sing t0 - -> Sing t1 - -> Sing (Apply (Apply (CompareSym0 :: TyFun * (TyFun * Ordering - -> *) - -> *) t0 :: TyFun * Ordering -> *) t1 :: Ordering) - sCompare SNat SNat - = let - lambda :: - (t0 ~ NatSym0, t1 ~ NatSym0) => - Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - = applySing - (applySing - (applySing - (singFun3 (Data.Proxy.Proxy :: Data.Proxy.Proxy FoldlSym0) sFoldl) - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy ThenCmpSym0) sThenCmp)) - SEQ) - SNil - in lambda - sCompare SInt SInt - = let - lambda :: - (t0 ~ IntSym0, t1 ~ IntSym0) => - Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - = applySing - (applySing - (applySing - (singFun3 (Data.Proxy.Proxy :: Data.Proxy.Proxy FoldlSym0) sFoldl) - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy ThenCmpSym0) sThenCmp)) - SEQ) - SNil - in lambda - sCompare SString SString - = let - lambda :: - (t0 ~ StringSym0, t1 ~ StringSym0) => - Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda - = applySing - (applySing - (applySing - (singFun3 (Data.Proxy.Proxy :: Data.Proxy.Proxy FoldlSym0) sFoldl) - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy ThenCmpSym0) sThenCmp)) - SEQ) - SNil - in lambda - sCompare (SMaybe sA_0123456789) (SMaybe sB_0123456789) - = let - lambda :: - forall a_0123456789 - b_0123456789. (t0 ~ Apply MaybeSym0 a_0123456789, - t1 ~ Apply MaybeSym0 b_0123456789) => - Sing a_0123456789 - -> Sing b_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda a_0123456789 b_0123456789 - = applySing - (applySing - (applySing - (singFun3 (Data.Proxy.Proxy :: Data.Proxy.Proxy FoldlSym0) sFoldl) - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy ThenCmpSym0) sThenCmp)) - SEQ) - (applySing - (applySing - (singFun2 (Data.Proxy.Proxy :: Data.Proxy.Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy CompareSym0) sCompare) - a_0123456789) - b_0123456789)) - SNil) - in lambda sA_0123456789 sB_0123456789 - sCompare - (SVec sA_0123456789 sA_0123456789) - (SVec sB_0123456789 sB_0123456789) - = let - lambda :: - forall a_0123456789 - a_0123456789 - b_0123456789 - b_0123456789. (t0 ~ Apply (Apply VecSym0 a_0123456789) a_0123456789, - t1 ~ Apply (Apply VecSym0 b_0123456789) b_0123456789) => - Sing a_0123456789 - -> Sing a_0123456789 - -> Sing b_0123456789 - -> Sing b_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda a_0123456789 a_0123456789 b_0123456789 b_0123456789 - = applySing - (applySing - (applySing - (singFun3 (Data.Proxy.Proxy :: Data.Proxy.Proxy FoldlSym0) sFoldl) - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy ThenCmpSym0) sThenCmp)) - SEQ) - (applySing - (applySing - (singFun2 (Data.Proxy.Proxy :: Data.Proxy.Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy CompareSym0) sCompare) - a_0123456789) - b_0123456789)) - (applySing - (applySing - (singFun2 (Data.Proxy.Proxy :: Data.Proxy.Proxy (:$)) SCons) - (applySing - (applySing - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy CompareSym0) sCompare) - a_0123456789) - b_0123456789)) - SNil)) - in lambda sA_0123456789 sA_0123456789 sB_0123456789 sB_0123456789 - sCompare SNat SInt - = let - lambda :: - (t0 ~ NatSym0, t1 ~ IntSym0) => - Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda = SLT - in lambda - sCompare SNat SString - = let - lambda :: - (t0 ~ NatSym0, t1 ~ StringSym0) => - Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda = SLT - in lambda - sCompare SNat (SMaybe _s_z_0123456789) - = let - lambda :: - forall _z_0123456789. (t0 ~ NatSym0, - t1 ~ Apply MaybeSym0 _z_0123456789) => - Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 = SLT - in lambda _s_z_0123456789 - sCompare SNat (SVec _s_z_0123456789 _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 _z_0123456789. (t0 ~ NatSym0, - t1 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 _z_0123456789 = SLT - in lambda _s_z_0123456789 _s_z_0123456789 - sCompare SInt SNat - = let - lambda :: - (t0 ~ IntSym0, t1 ~ NatSym0) => - Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda = SGT - in lambda - sCompare SInt SString - = let - lambda :: - (t0 ~ IntSym0, t1 ~ StringSym0) => - Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda = SLT - in lambda - sCompare SInt (SMaybe _s_z_0123456789) - = let - lambda :: - forall _z_0123456789. (t0 ~ IntSym0, - t1 ~ Apply MaybeSym0 _z_0123456789) => - Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 = SLT - in lambda _s_z_0123456789 - sCompare SInt (SVec _s_z_0123456789 _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 _z_0123456789. (t0 ~ IntSym0, - t1 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 _z_0123456789 = SLT - in lambda _s_z_0123456789 _s_z_0123456789 - sCompare SString SNat - = let - lambda :: - (t0 ~ StringSym0, t1 ~ NatSym0) => - Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda = SGT - in lambda - sCompare SString SInt - = let - lambda :: - (t0 ~ StringSym0, t1 ~ IntSym0) => - Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda = SGT - in lambda - sCompare SString (SMaybe _s_z_0123456789) - = let - lambda :: - forall _z_0123456789. (t0 ~ StringSym0, - t1 ~ Apply MaybeSym0 _z_0123456789) => - Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 = SLT - in lambda _s_z_0123456789 - sCompare SString (SVec _s_z_0123456789 _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 _z_0123456789. (t0 ~ StringSym0, - t1 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 _z_0123456789 = SLT - in lambda _s_z_0123456789 _s_z_0123456789 - sCompare (SMaybe _s_z_0123456789) SNat - = let - lambda :: - forall _z_0123456789. (t0 ~ Apply MaybeSym0 _z_0123456789, - t1 ~ NatSym0) => - Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 = SGT - in lambda _s_z_0123456789 - sCompare (SMaybe _s_z_0123456789) SInt - = let - lambda :: - forall _z_0123456789. (t0 ~ Apply MaybeSym0 _z_0123456789, - t1 ~ IntSym0) => - Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 = SGT - in lambda _s_z_0123456789 - sCompare (SMaybe _s_z_0123456789) SString - = let - lambda :: - forall _z_0123456789. (t0 ~ Apply MaybeSym0 _z_0123456789, - t1 ~ StringSym0) => - Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 = SGT - in lambda _s_z_0123456789 - sCompare - (SMaybe _s_z_0123456789) - (SVec _s_z_0123456789 _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply MaybeSym0 _z_0123456789, - t1 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 _z_0123456789 _z_0123456789 = SLT - in lambda _s_z_0123456789 _s_z_0123456789 _s_z_0123456789 - sCompare (SVec _s_z_0123456789 _s_z_0123456789) SNat - = let - lambda :: - forall _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789, - t1 ~ NatSym0) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 _z_0123456789 = SGT - in lambda _s_z_0123456789 _s_z_0123456789 - sCompare (SVec _s_z_0123456789 _s_z_0123456789) SInt - = let - lambda :: - forall _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789, - t1 ~ IntSym0) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 _z_0123456789 = SGT - in lambda _s_z_0123456789 _s_z_0123456789 - sCompare (SVec _s_z_0123456789 _s_z_0123456789) SString - = let - lambda :: - forall _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789, - t1 ~ StringSym0) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 _z_0123456789 = SGT - in lambda _s_z_0123456789 _s_z_0123456789 - sCompare - (SVec _s_z_0123456789 _s_z_0123456789) - (SMaybe _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789 - _z_0123456789. (t0 ~ Apply (Apply VecSym0 _z_0123456789) _z_0123456789, - t1 ~ Apply MaybeSym0 _z_0123456789) => - Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing _z_0123456789 - -> Sing (Apply (Apply CompareSym0 t0) t1 :: Ordering) - lambda _z_0123456789 _z_0123456789 _z_0123456789 = SGT - in lambda _s_z_0123456789 _s_z_0123456789 _s_z_0123456789 - data instance Sing (z :: *) - = z ~ Nat => SNat | - z ~ Int => SInt | - z ~ String => SString | - forall (n :: *). z ~ Maybe n => SMaybe (Sing (n :: *)) | - forall (n :: *) (n :: Nat). z ~ Vec n n => - SVec (Sing (n :: *)) (Sing (n :: Nat)) - type SRep = (Sing :: * -> *) - instance SingKind (KProxy :: KProxy *) where - type DemoteRep (KProxy :: KProxy *) = Rep - fromSing SNat = Singletons.Star.Nat - fromSing SInt = Singletons.Star.Int - fromSing SString = Singletons.Star.String - fromSing (SMaybe b) = Singletons.Star.Maybe (fromSing b) - fromSing (SVec b b) = Singletons.Star.Vec (fromSing b) (fromSing b) - toSing Singletons.Star.Nat = SomeSing SNat - toSing Singletons.Star.Int = SomeSing SInt - toSing Singletons.Star.String = SomeSing SString - toSing (Singletons.Star.Maybe b) - = case toSing b :: SomeSing (KProxy :: KProxy *) of { - SomeSing c -> SomeSing (SMaybe c) } - toSing (Singletons.Star.Vec b b) - = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy *)) - (toSing b :: SomeSing (KProxy :: KProxy Nat)) - of { - GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SVec c c) } - instance SEq (KProxy :: KProxy *) where - (%:==) SNat SNat = STrue - (%:==) SNat SInt = SFalse - (%:==) SNat SString = SFalse - (%:==) SNat (SMaybe _) = SFalse - (%:==) SNat (SVec _ _) = SFalse - (%:==) SInt SNat = SFalse - (%:==) SInt SInt = STrue - (%:==) SInt SString = SFalse - (%:==) SInt (SMaybe _) = SFalse - (%:==) SInt (SVec _ _) = SFalse - (%:==) SString SNat = SFalse - (%:==) SString SInt = SFalse - (%:==) SString SString = STrue - (%:==) SString (SMaybe _) = SFalse - (%:==) SString (SVec _ _) = SFalse - (%:==) (SMaybe _) SNat = SFalse - (%:==) (SMaybe _) SInt = SFalse - (%:==) (SMaybe _) SString = SFalse - (%:==) (SMaybe a) (SMaybe b) = (%:==) a b - (%:==) (SMaybe _) (SVec _ _) = SFalse - (%:==) (SVec _ _) SNat = SFalse - (%:==) (SVec _ _) SInt = SFalse - (%:==) (SVec _ _) SString = SFalse - (%:==) (SVec _ _) (SMaybe _) = SFalse - (%:==) (SVec a a) (SVec b b) = (%:&&) ((%:==) a b) ((%:==) a b) - instance SDecide (KProxy :: KProxy *) where - (%~) SNat SNat = Proved Refl - (%~) SNat SInt - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SNat SString - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SNat (SMaybe _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SNat (SVec _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SInt SNat - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SInt SInt = Proved Refl - (%~) SInt SString - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SInt (SMaybe _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SInt (SVec _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SString SNat - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SString SInt - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SString SString = Proved Refl - (%~) SString (SMaybe _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) SString (SVec _ _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SMaybe _) SNat - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SMaybe _) SInt - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SMaybe _) SString - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (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 { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SVec _ _) SNat - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SVec _ _) SInt - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SVec _ _) SString - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SVec _ _) (SMaybe _) - = Disproved - (\ x - -> case x of { - _ -> error "Empty case reached -- this should be impossible" }) - (%~) (SVec a a) (SVec b b) - = case GHC.Tuple.(,) ((%~) a b) ((%~) a b) of { - GHC.Tuple.(,) (Proved Refl) (Proved Refl) -> Proved Refl - GHC.Tuple.(,) (Disproved contra) _ - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) - GHC.Tuple.(,) _ (Disproved contra) - -> Disproved (\ refl -> case refl of { Refl -> contra Refl }) } - instance SingI Nat where - sing = SNat - instance SingI Int where - sing = SInt - instance SingI String where - sing = SString - instance SingI n => SingI (Maybe (n :: *)) where - sing = SMaybe sing - instance (SingI n, SingI n) => - SingI (Vec (n :: *) (n :: Nat)) where - sing = SVec sing sing diff --git a/tests/compile-and-dump/Singletons/Star.ghc80.template b/tests/compile-and-dump/Singletons/Star.ghc80.template --- a/tests/compile-and-dump/Singletons/Star.ghc80.template +++ b/tests/compile-and-dump/Singletons/Star.ghc80.template @@ -15,7 +15,7 @@ Equals_0123456789 (Maybe a) (Maybe b) = (:==) a b Equals_0123456789 (Vec a a) (Vec b b) = (:&&) ((:==) a b) ((:==) a b) Equals_0123456789 (a :: Type) (b :: Type) = FalseSym0 - instance PEq (KProxy :: KProxy Type) where + instance PEq (Proxy :: Proxy Type) where type (:==) (a :: Type) (b :: Type) = Equals_0123456789 a b type NatSym0 = Nat type IntSym0 = Int @@ -89,11 +89,9 @@ = forall arg. KindOf (Apply Compare_0123456789Sym0 arg) ~ KindOf (Compare_0123456789Sym1 arg) => Compare_0123456789Sym0KindInference type instance Apply Compare_0123456789Sym0 l = Compare_0123456789Sym1 l - instance POrd (KProxy :: KProxy Type) where + instance POrd (Proxy :: Proxy Type) where type Compare (a :: Type) (a :: Type) = Apply (Apply Compare_0123456789Sym0 a) a - instance (SOrd (KProxy :: KProxy Type), - SOrd (KProxy :: KProxy Nat)) => - SOrd (KProxy :: KProxy Type) where + instance (SOrd Type, SOrd Nat) => SOrd Type where sCompare :: forall (t0 :: Type) (t1 :: Type). Sing t0 @@ -111,9 +109,8 @@ = applySing (applySing (applySing - (singFun3 (Data.Proxy.Proxy :: Data.Proxy.Proxy FoldlSym0) sFoldl) - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy ThenCmpSym0) sThenCmp)) + (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl) + (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp)) SEQ) SNil in lambda @@ -126,9 +123,8 @@ = applySing (applySing (applySing - (singFun3 (Data.Proxy.Proxy :: Data.Proxy.Proxy FoldlSym0) sFoldl) - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy ThenCmpSym0) sThenCmp)) + (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl) + (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp)) SEQ) SNil in lambda @@ -141,9 +137,8 @@ = applySing (applySing (applySing - (singFun3 (Data.Proxy.Proxy :: Data.Proxy.Proxy FoldlSym0) sFoldl) - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy ThenCmpSym0) sThenCmp)) + (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl) + (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp)) SEQ) SNil in lambda @@ -160,18 +155,15 @@ = applySing (applySing (applySing - (singFun3 (Data.Proxy.Proxy :: Data.Proxy.Proxy FoldlSym0) sFoldl) - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy ThenCmpSym0) sThenCmp)) + (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl) + (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp)) SEQ) (applySing (applySing - (singFun2 (Data.Proxy.Proxy :: Data.Proxy.Proxy (:$)) SCons) + (singFun2 (Proxy :: Proxy (:$)) SCons) (applySing (applySing - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy CompareSym0) sCompare) - a_0123456789) + (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) b_0123456789)) SNil) in lambda sA_0123456789 sB_0123456789 @@ -192,27 +184,22 @@ = applySing (applySing (applySing - (singFun3 (Data.Proxy.Proxy :: Data.Proxy.Proxy FoldlSym0) sFoldl) - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy ThenCmpSym0) sThenCmp)) + (singFun3 (Proxy :: Proxy FoldlSym0) sFoldl) + (singFun2 (Proxy :: Proxy ThenCmpSym0) sThenCmp)) SEQ) (applySing (applySing - (singFun2 (Data.Proxy.Proxy :: Data.Proxy.Proxy (:$)) SCons) + (singFun2 (Proxy :: Proxy (:$)) SCons) (applySing (applySing - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy CompareSym0) sCompare) - a_0123456789) + (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) b_0123456789)) (applySing (applySing - (singFun2 (Data.Proxy.Proxy :: Data.Proxy.Proxy (:$)) SCons) + (singFun2 (Proxy :: Proxy (:$)) SCons) (applySing (applySing - (singFun2 - (Data.Proxy.Proxy :: Data.Proxy.Proxy CompareSym0) sCompare) - a_0123456789) + (singFun2 (Proxy :: Proxy CompareSym0) sCompare) a_0123456789) b_0123456789)) SNil)) in lambda sA_0123456789 sA_0123456789 sB_0123456789 sB_0123456789 @@ -414,8 +401,8 @@ forall (n :: Type) (n :: Nat). z ~ Vec n n => SVec (Sing (n :: Type)) (Sing (n :: Nat)) type SRep = (Sing :: Type -> Type) - instance SingKind (KProxy :: KProxy Type) where - type DemoteRep (KProxy :: KProxy Type) = Rep + instance SingKind Type where + type DemoteRep Type = Rep fromSing SNat = Singletons.Star.Nat fromSing SInt = Singletons.Star.Int fromSing SString = Singletons.Star.String @@ -425,16 +412,15 @@ toSing Singletons.Star.Int = SomeSing SInt toSing Singletons.Star.String = SomeSing SString toSing (Singletons.Star.Maybe b) - = case toSing b :: SomeSing (KProxy :: KProxy Type) of { + = case toSing b :: SomeSing Type of { SomeSing c -> SomeSing (SMaybe c) } toSing (Singletons.Star.Vec b b) = case GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy Type)) - (toSing b :: SomeSing (KProxy :: KProxy Nat)) + (toSing b :: SomeSing Type) (toSing b :: SomeSing Nat) of { GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SVec c c) } - instance SEq (KProxy :: KProxy Type) where + instance SEq Type where (%:==) SNat SNat = STrue (%:==) SNat SInt = SFalse (%:==) SNat SString = SFalse @@ -460,7 +446,7 @@ (%:==) (SVec _ _) SString = SFalse (%:==) (SVec _ _) (SMaybe _) = SFalse (%:==) (SVec a a) (SVec b b) = (%:&&) ((%:==) a b) ((%:==) a b) - instance SDecide (KProxy :: KProxy Type) where + instance SDecide Type where (%~) SNat SNat = Proved Refl (%~) SNat SInt = Disproved diff --git a/tests/compile-and-dump/Singletons/Star.hs b/tests/compile-and-dump/Singletons/Star.hs --- a/tests/compile-and-dump/Singletons/Star.hs +++ b/tests/compile-and-dump/Singletons/Star.hs @@ -6,10 +6,7 @@ import Data.Singletons.Decide import Data.Singletons.CustomStar import Singletons.Nat - -#if __GLASGOW_HASKELL__ >= 711 import Data.Kind -#endif data Vec :: * -> Nat -> * where VNil :: Vec a Zero diff --git a/tests/compile-and-dump/Singletons/T124.ghc710.template b/tests/compile-and-dump/Singletons/T124.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/T124.ghc710.template +++ /dev/null @@ -1,37 +0,0 @@ -Singletons/T124.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| foo :: Bool -> () - foo True = () - foo False = () |] - ======> - foo :: Bool -> () - foo True = GHC.Tuple.() - foo False = GHC.Tuple.() - type FooSym1 (t :: Bool) = Foo t - instance SuppressUnusedWarnings FooSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.()) - data FooSym0 (l :: TyFun Bool ()) - = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) => - FooSym0KindInference - type instance Apply FooSym0 l = FooSym1 l - type family Foo (a :: Bool) :: () where - Foo True = Tuple0Sym0 - Foo False = Tuple0Sym0 - sFoo :: forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: ()) - sFoo STrue - = let - lambda :: t ~ TrueSym0 => Sing (Apply FooSym0 t :: ()) - lambda = STuple0 - in lambda - sFoo SFalse - = let - lambda :: t ~ FalseSym0 => Sing (Apply FooSym0 t :: ()) - lambda = STuple0 - in lambda -Singletons/T124.hs:0:0:: Splicing expression - sCases ''Bool [| b |] [| STuple0 |] - ======> - case b of { - SFalse -> STuple0 - STrue -> STuple0 } diff --git a/tests/compile-and-dump/Singletons/T136.ghc710.template b/tests/compile-and-dump/Singletons/T136.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/T136.ghc710.template +++ /dev/null @@ -1,262 +0,0 @@ -Singletons/T136.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| instance Enum BiNat where - succ [] = [True] - succ (False : as) = True : as - succ (True : as) = False : succ as - pred [] = error "pred 0" - pred (False : as) = True : pred as - pred (True : as) = False : as - toEnum i - | i < 0 = error "negative toEnum" - | i == 0 = [] - | otherwise = succ (toEnum (pred i)) - fromEnum [] = 0 - fromEnum (False : as) = 2 * fromEnum as - fromEnum (True : as) = 1 + 2 * fromEnum as |] - ======> - instance Enum BiNat where - succ GHC.Types.[] = [True] - succ (False GHC.Types.: as) = (True GHC.Types.: as) - succ (True GHC.Types.: as) = (False GHC.Types.: (succ as)) - pred GHC.Types.[] = error "pred 0" - pred (False GHC.Types.: as) = (True GHC.Types.: (pred as)) - pred (True GHC.Types.: as) = (False GHC.Types.: as) - toEnum i - | (i < 0) = error "negative toEnum" - | (i == 0) = [] - | otherwise = succ (toEnum (pred i)) - fromEnum GHC.Types.[] = 0 - fromEnum (False GHC.Types.: as) = (2 * (fromEnum as)) - fromEnum (True GHC.Types.: as) = (1 + (2 * (fromEnum as))) - type family Succ_0123456789 (a :: [Bool]) :: [Bool] where - Succ_0123456789 '[] = Apply (Apply (:$) TrueSym0) '[] - Succ_0123456789 ((:) False as) = Apply (Apply (:$) TrueSym0) as - Succ_0123456789 ((:) True as) = Apply (Apply (:$) FalseSym0) (Apply SuccSym0 as) - type Succ_0123456789Sym1 (t :: [Bool]) = Succ_0123456789 t - instance SuppressUnusedWarnings Succ_0123456789Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Succ_0123456789Sym0KindInference GHC.Tuple.()) - data Succ_0123456789Sym0 (l :: TyFun [Bool] [Bool]) - = forall arg. KindOf (Apply Succ_0123456789Sym0 arg) ~ KindOf (Succ_0123456789Sym1 arg) => - Succ_0123456789Sym0KindInference - type instance Apply Succ_0123456789Sym0 l = Succ_0123456789Sym1 l - type family Pred_0123456789 (a :: [Bool]) :: [Bool] where - Pred_0123456789 '[] = Apply ErrorSym0 "pred 0" - Pred_0123456789 ((:) False as) = Apply (Apply (:$) TrueSym0) (Apply PredSym0 as) - Pred_0123456789 ((:) True as) = Apply (Apply (:$) FalseSym0) as - type Pred_0123456789Sym1 (t :: [Bool]) = Pred_0123456789 t - instance SuppressUnusedWarnings Pred_0123456789Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Pred_0123456789Sym0KindInference GHC.Tuple.()) - data Pred_0123456789Sym0 (l :: TyFun [Bool] [Bool]) - = forall arg. KindOf (Apply Pred_0123456789Sym0 arg) ~ KindOf (Pred_0123456789Sym1 arg) => - Pred_0123456789Sym0KindInference - type instance Apply Pred_0123456789Sym0 l = Pred_0123456789Sym1 l - type family Case_0123456789 i arg_0123456789 t where - Case_0123456789 i arg_0123456789 True = '[] - Case_0123456789 i arg_0123456789 False = Apply SuccSym0 (Apply ToEnumSym0 (Apply PredSym0 i)) - type family Case_0123456789 i arg_0123456789 t where - Case_0123456789 i arg_0123456789 True = Apply ErrorSym0 "negative toEnum" - Case_0123456789 i arg_0123456789 False = Case_0123456789 i arg_0123456789 (Apply (Apply (:==$) i) (FromInteger 0)) - type family Case_0123456789 arg_0123456789 t where - Case_0123456789 arg_0123456789 i = Case_0123456789 i arg_0123456789 (Apply (Apply (:<$) i) (FromInteger 0)) - type family ToEnum_0123456789 (a :: GHC.TypeLits.Nat) :: [Bool] where - ToEnum_0123456789 arg_0123456789 = Case_0123456789 arg_0123456789 arg_0123456789 - type ToEnum_0123456789Sym1 (t :: GHC.TypeLits.Nat) = - ToEnum_0123456789 t - instance SuppressUnusedWarnings ToEnum_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) ToEnum_0123456789Sym0KindInference GHC.Tuple.()) - data ToEnum_0123456789Sym0 (l :: TyFun GHC.TypeLits.Nat [Bool]) - = forall arg. KindOf (Apply ToEnum_0123456789Sym0 arg) ~ KindOf (ToEnum_0123456789Sym1 arg) => - ToEnum_0123456789Sym0KindInference - type instance Apply ToEnum_0123456789Sym0 l = ToEnum_0123456789Sym1 l - type family FromEnum_0123456789 (a :: [Bool]) :: GHC.TypeLits.Nat where - FromEnum_0123456789 '[] = FromInteger 0 - FromEnum_0123456789 ((:) False as) = Apply (Apply (:*$) (FromInteger 2)) (Apply FromEnumSym0 as) - FromEnum_0123456789 ((:) True as) = Apply (Apply (:+$) (FromInteger 1)) (Apply (Apply (:*$) (FromInteger 2)) (Apply FromEnumSym0 as)) - type FromEnum_0123456789Sym1 (t :: [Bool]) = FromEnum_0123456789 t - instance SuppressUnusedWarnings FromEnum_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) FromEnum_0123456789Sym0KindInference GHC.Tuple.()) - data FromEnum_0123456789Sym0 (l :: TyFun [Bool] GHC.TypeLits.Nat) - = forall arg. KindOf (Apply FromEnum_0123456789Sym0 arg) ~ KindOf (FromEnum_0123456789Sym1 arg) => - FromEnum_0123456789Sym0KindInference - type instance Apply FromEnum_0123456789Sym0 l = FromEnum_0123456789Sym1 l - instance PEnum (KProxy :: KProxy [Bool]) where - type Succ (a :: [Bool]) = Apply Succ_0123456789Sym0 a - type Pred (a :: [Bool]) = Apply Pred_0123456789Sym0 a - type ToEnum (a :: GHC.TypeLits.Nat) = Apply ToEnum_0123456789Sym0 a - type FromEnum (a :: [Bool]) = Apply FromEnum_0123456789Sym0 a - instance SEnum (KProxy :: KProxy [Bool]) where - sSucc :: - forall (t0 :: [Bool]). - Sing t0 - -> Sing (Apply (SuccSym0 :: TyFun [Bool] [Bool] -> *) t0 :: [Bool]) - sPred :: - forall (t0 :: [Bool]). - Sing t0 - -> Sing (Apply (PredSym0 :: TyFun [Bool] [Bool] -> *) t0 :: [Bool]) - sToEnum :: - forall (t0 :: GHC.TypeLits.Nat). - Sing t0 - -> Sing (Apply (ToEnumSym0 :: TyFun GHC.TypeLits.Nat [Bool] - -> *) t0 :: [Bool]) - sFromEnum :: - forall (t0 :: [Bool]). - Sing t0 - -> Sing (Apply (FromEnumSym0 :: TyFun [Bool] GHC.TypeLits.Nat - -> *) t0 :: GHC.TypeLits.Nat) - sSucc SNil - = let - lambda :: t0 ~ '[] => Sing (Apply SuccSym0 t0 :: [Bool]) - lambda - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) STrue) SNil - in lambda - sSucc (SCons SFalse sAs) - = let - lambda :: - forall as. t0 ~ Apply (Apply (:$) FalseSym0) as => - Sing as -> Sing (Apply SuccSym0 t0 :: [Bool]) - lambda as - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) STrue) as - in lambda sAs - sSucc (SCons STrue sAs) - = let - lambda :: - forall as. t0 ~ Apply (Apply (:$) TrueSym0) as => - Sing as -> Sing (Apply SuccSym0 t0 :: [Bool]) - lambda as - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SFalse) - (applySing (singFun1 (Proxy :: Proxy SuccSym0) sSucc) as) - in lambda sAs - sPred SNil - = let - lambda :: t0 ~ '[] => Sing (Apply PredSym0 t0 :: [Bool]) - lambda = sError (sing :: Sing "pred 0") - in lambda - sPred (SCons SFalse sAs) - = let - lambda :: - forall as. t0 ~ Apply (Apply (:$) FalseSym0) as => - Sing as -> Sing (Apply PredSym0 t0 :: [Bool]) - lambda as - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) STrue) - (applySing (singFun1 (Proxy :: Proxy PredSym0) sPred) as) - in lambda sAs - sPred (SCons STrue sAs) - = let - lambda :: - forall as. t0 ~ Apply (Apply (:$) TrueSym0) as => - Sing as -> Sing (Apply PredSym0 t0 :: [Bool]) - lambda as - = applySing - (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) SFalse) as - in lambda sAs - sToEnum sArg_0123456789 - = let - lambda :: - forall arg_0123456789. t0 ~ arg_0123456789 => - Sing arg_0123456789 -> Sing (Apply ToEnumSym0 t0 :: [Bool]) - lambda arg_0123456789 - = case arg_0123456789 of { - sI - -> let - lambda :: - forall i. i ~ arg_0123456789 => - Sing i -> Sing (Case_0123456789 arg_0123456789 i :: [Bool]) - lambda i - = case - applySing - (applySing (singFun2 (Proxy :: Proxy (:<$)) (%:<)) i) - (sFromInteger (sing :: Sing 0)) - of { - STrue - -> let - lambda :: - TrueSym0 ~ Apply (Apply (:<$) i) (FromInteger 0) => - Sing (Case_0123456789 i arg_0123456789 TrueSym0 :: [Bool]) - lambda = sError (sing :: Sing "negative toEnum") - in lambda - SFalse - -> let - lambda :: - FalseSym0 ~ Apply (Apply (:<$) i) (FromInteger 0) => - Sing (Case_0123456789 i arg_0123456789 FalseSym0 :: [Bool]) - lambda - = case - applySing - (applySing - (singFun2 (Proxy :: Proxy (:==$)) (%:==)) i) - (sFromInteger (sing :: Sing 0)) - of { - STrue - -> let - lambda :: - TrueSym0 ~ Apply (Apply (:==$) i) (FromInteger 0) => - Sing (Case_0123456789 i arg_0123456789 TrueSym0 :: [Bool]) - lambda = SNil - in lambda - SFalse - -> let - lambda :: - FalseSym0 ~ Apply (Apply (:==$) i) (FromInteger 0) => - Sing (Case_0123456789 i arg_0123456789 FalseSym0 :: [Bool]) - lambda - = applySing - (singFun1 (Proxy :: Proxy SuccSym0) sSucc) - (applySing - (singFun1 - (Proxy :: Proxy ToEnumSym0) sToEnum) - (applySing - (singFun1 - (Proxy :: Proxy PredSym0) sPred) - i)) - in lambda } :: - Sing (Case_0123456789 i arg_0123456789 (Apply (Apply (:==$) i) (FromInteger 0)) :: [Bool]) - in lambda } :: - Sing (Case_0123456789 i arg_0123456789 (Apply (Apply (:<$) i) (FromInteger 0)) :: [Bool]) - in lambda sI } :: - Sing (Case_0123456789 arg_0123456789 arg_0123456789 :: [Bool]) - in lambda sArg_0123456789 - sFromEnum SNil - = let - lambda :: - t0 ~ '[] => Sing (Apply FromEnumSym0 t0 :: GHC.TypeLits.Nat) - lambda = sFromInteger (sing :: Sing 0) - in lambda - sFromEnum (SCons SFalse sAs) - = let - lambda :: - forall as. t0 ~ Apply (Apply (:$) FalseSym0) as => - Sing as -> Sing (Apply FromEnumSym0 t0 :: GHC.TypeLits.Nat) - lambda as - = applySing - (applySing - (singFun2 (Proxy :: Proxy (:*$)) (%:*)) - (sFromInteger (sing :: Sing 2))) - (applySing (singFun1 (Proxy :: Proxy FromEnumSym0) sFromEnum) as) - in lambda sAs - sFromEnum (SCons STrue sAs) - = let - lambda :: - forall as. t0 ~ Apply (Apply (:$) TrueSym0) as => - Sing as -> Sing (Apply FromEnumSym0 t0 :: GHC.TypeLits.Nat) - lambda as - = applySing - (applySing - (singFun2 (Proxy :: Proxy (:+$)) (%:+)) - (sFromInteger (sing :: Sing 1))) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:*$)) (%:*)) - (sFromInteger (sing :: Sing 2))) - (applySing (singFun1 (Proxy :: Proxy FromEnumSym0) sFromEnum) as)) - in lambda sAs diff --git a/tests/compile-and-dump/Singletons/T136.ghc80.template b/tests/compile-and-dump/Singletons/T136.ghc80.template --- a/tests/compile-and-dump/Singletons/T136.ghc80.template +++ b/tests/compile-and-dump/Singletons/T136.ghc80.template @@ -86,12 +86,12 @@ = forall arg. KindOf (Apply FromEnum_0123456789Sym0 arg) ~ KindOf (FromEnum_0123456789Sym1 arg) => FromEnum_0123456789Sym0KindInference type instance Apply FromEnum_0123456789Sym0 l = FromEnum_0123456789Sym1 l - instance PEnum (KProxy :: KProxy [Bool]) where + instance PEnum (Proxy :: Proxy [Bool]) where type Succ (a :: [Bool]) = Apply Succ_0123456789Sym0 a type Pred (a :: [Bool]) = Apply Pred_0123456789Sym0 a type ToEnum (a :: GHC.Types.Nat) = Apply ToEnum_0123456789Sym0 a type FromEnum (a :: [Bool]) = Apply FromEnum_0123456789Sym0 a - instance SEnum (KProxy :: KProxy [Bool]) where + instance SEnum [Bool] where sSucc :: forall (t0 :: [Bool]). Sing t0 diff --git a/tests/compile-and-dump/Singletons/T136b.ghc710.template b/tests/compile-and-dump/Singletons/T136b.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/T136b.ghc710.template +++ /dev/null @@ -1,50 +0,0 @@ -Singletons/T136b.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| class C a where - meth :: a -> a |] - ======> - class C a where - meth :: a -> a - type MethSym1 (t :: a0123456789) = Meth t - instance SuppressUnusedWarnings MethSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) MethSym0KindInference GHC.Tuple.()) - data MethSym0 (l :: TyFun a0123456789 a0123456789) - = forall arg. KindOf (Apply MethSym0 arg) ~ KindOf (MethSym1 arg) => - MethSym0KindInference - type instance Apply MethSym0 l = MethSym1 l - class kproxy ~ KProxy => PC (kproxy :: KProxy a) where - type family Meth (arg :: a) :: a - class kproxy ~ KProxy => SC (kproxy :: KProxy a) where - sMeth :: forall (t :: a). Sing t -> Sing (Apply MethSym0 t :: a) -Singletons/T136b.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| instance C Bool where - meth = not |] - ======> - instance C Bool where - meth = not - type family Meth_0123456789 (a :: Bool) :: Bool where - Meth_0123456789 a_0123456789 = Apply NotSym0 a_0123456789 - type Meth_0123456789Sym1 (t :: Bool) = Meth_0123456789 t - instance SuppressUnusedWarnings Meth_0123456789Sym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) Meth_0123456789Sym0KindInference GHC.Tuple.()) - data Meth_0123456789Sym0 (l :: TyFun Bool Bool) - = forall arg. KindOf (Apply Meth_0123456789Sym0 arg) ~ KindOf (Meth_0123456789Sym1 arg) => - Meth_0123456789Sym0KindInference - type instance Apply Meth_0123456789Sym0 l = Meth_0123456789Sym1 l - instance PC (KProxy :: KProxy Bool) where - type Meth (a :: Bool) = Apply Meth_0123456789Sym0 a - instance SC (KProxy :: KProxy Bool) where - sMeth :: - forall (t :: Bool). - Sing t -> Sing (Apply (MethSym0 :: TyFun Bool Bool -> *) t :: Bool) - sMeth sA_0123456789 - = let - lambda :: - forall a_0123456789. t ~ a_0123456789 => - Sing a_0123456789 -> Sing (Apply MethSym0 t :: Bool) - lambda a_0123456789 - = applySing (singFun1 (Proxy :: Proxy NotSym0) sNot) a_0123456789 - in lambda sA_0123456789 diff --git a/tests/compile-and-dump/Singletons/T136b.ghc80.template b/tests/compile-and-dump/Singletons/T136b.ghc80.template --- a/tests/compile-and-dump/Singletons/T136b.ghc80.template +++ b/tests/compile-and-dump/Singletons/T136b.ghc80.template @@ -13,9 +13,9 @@ = forall arg. KindOf (Apply MethSym0 arg) ~ KindOf (MethSym1 arg) => MethSym0KindInference type instance Apply MethSym0 l = MethSym1 l - class kproxy ~ KProxy => PC (kproxy :: KProxy a) where + class kproxy ~ Proxy => PC (kproxy :: Proxy a) where type Meth (arg :: a) :: a - class kproxy ~ KProxy => SC (kproxy :: KProxy a) where + class SC a where sMeth :: forall (t :: a). Sing t -> Sing (Apply MethSym0 t :: a) Singletons/T136b.hs:(0,0)-(0,0): Splicing declarations singletons @@ -34,9 +34,9 @@ = forall arg. KindOf (Apply Meth_0123456789Sym0 arg) ~ KindOf (Meth_0123456789Sym1 arg) => Meth_0123456789Sym0KindInference type instance Apply Meth_0123456789Sym0 l = Meth_0123456789Sym1 l - instance PC (KProxy :: KProxy Bool) where + instance PC (Proxy :: Proxy Bool) where type Meth (a :: Bool) = Apply Meth_0123456789Sym0 a - instance SC (KProxy :: KProxy Bool) where + instance SC Bool where sMeth :: forall (t :: Bool). Sing t diff --git a/tests/compile-and-dump/Singletons/T29.ghc710.template b/tests/compile-and-dump/Singletons/T29.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/T29.ghc710.template +++ /dev/null @@ -1,127 +0,0 @@ -Singletons/T29.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| foo :: Bool -> Bool - foo x = not $ x - bar :: Bool -> Bool - bar x = not . not . not $ x - baz :: Bool -> Bool - baz x = not $! x - ban :: Bool -> Bool - ban x = not . not . not $! x |] - ======> - foo :: Bool -> Bool - foo x = (not $ x) - bar :: Bool -> Bool - bar x = ((not . (not . not)) $ x) - baz :: Bool -> Bool - baz x = (not $! x) - ban :: Bool -> Bool - ban x = ((not . (not . not)) $! x) - type BanSym1 (t :: Bool) = Ban t - instance SuppressUnusedWarnings BanSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BanSym0KindInference GHC.Tuple.()) - data BanSym0 (l :: TyFun Bool Bool) - = forall arg. KindOf (Apply BanSym0 arg) ~ KindOf (BanSym1 arg) => - BanSym0KindInference - type instance Apply BanSym0 l = BanSym1 l - type BazSym1 (t :: Bool) = Baz t - instance SuppressUnusedWarnings BazSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BazSym0KindInference GHC.Tuple.()) - data BazSym0 (l :: TyFun Bool Bool) - = forall arg. KindOf (Apply BazSym0 arg) ~ KindOf (BazSym1 arg) => - BazSym0KindInference - type instance Apply BazSym0 l = BazSym1 l - type BarSym1 (t :: Bool) = Bar t - instance SuppressUnusedWarnings BarSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.()) - data BarSym0 (l :: TyFun Bool Bool) - = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) => - BarSym0KindInference - type instance Apply BarSym0 l = BarSym1 l - type FooSym1 (t :: Bool) = Foo t - instance SuppressUnusedWarnings FooSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.()) - data FooSym0 (l :: TyFun Bool Bool) - = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) => - FooSym0KindInference - type instance Apply FooSym0 l = FooSym1 l - type family Ban (a :: Bool) :: Bool where - Ban x = Apply (Apply ($!$) (Apply (Apply (:.$) NotSym0) (Apply (Apply (:.$) NotSym0) NotSym0))) x - type family Baz (a :: Bool) :: Bool where - Baz x = Apply (Apply ($!$) NotSym0) x - type family Bar (a :: Bool) :: Bool where - Bar x = Apply (Apply ($$) (Apply (Apply (:.$) NotSym0) (Apply (Apply (:.$) NotSym0) NotSym0))) x - type family Foo (a :: Bool) :: Bool where - Foo x = Apply (Apply ($$) NotSym0) x - sBan :: - forall (t :: Bool). Sing t -> Sing (Apply BanSym0 t :: Bool) - sBaz :: - forall (t :: Bool). Sing t -> Sing (Apply BazSym0 t :: Bool) - sBar :: - forall (t :: Bool). Sing t -> Sing (Apply BarSym0 t :: Bool) - sFoo :: - forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: Bool) - sBan sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply BanSym0 t :: Bool) - lambda x - = applySing - (applySing - (singFun2 (Proxy :: Proxy ($!$)) (%$!)) - (applySing - (applySing - (singFun3 (Proxy :: Proxy (:.$)) (%:.)) - (singFun1 (Proxy :: Proxy NotSym0) sNot)) - (applySing - (applySing - (singFun3 (Proxy :: Proxy (:.$)) (%:.)) - (singFun1 (Proxy :: Proxy NotSym0) sNot)) - (singFun1 (Proxy :: Proxy NotSym0) sNot)))) - x - in lambda sX - sBaz sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply BazSym0 t :: Bool) - lambda x - = applySing - (applySing - (singFun2 (Proxy :: Proxy ($!$)) (%$!)) - (singFun1 (Proxy :: Proxy NotSym0) sNot)) - x - in lambda sX - sBar sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply BarSym0 t :: Bool) - lambda x - = applySing - (applySing - (singFun2 (Proxy :: Proxy ($$)) (%$)) - (applySing - (applySing - (singFun3 (Proxy :: Proxy (:.$)) (%:.)) - (singFun1 (Proxy :: Proxy NotSym0) sNot)) - (applySing - (applySing - (singFun3 (Proxy :: Proxy (:.$)) (%:.)) - (singFun1 (Proxy :: Proxy NotSym0) sNot)) - (singFun1 (Proxy :: Proxy NotSym0) sNot)))) - x - in lambda sX - sFoo sX - = let - lambda :: - forall x. t ~ x => Sing x -> Sing (Apply FooSym0 t :: Bool) - lambda x - = applySing - (applySing - (singFun2 (Proxy :: Proxy ($$)) (%$)) - (singFun1 (Proxy :: Proxy NotSym0) sNot)) - x - in lambda sX diff --git a/tests/compile-and-dump/Singletons/T33.ghc710.template b/tests/compile-and-dump/Singletons/T33.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/T33.ghc710.template +++ /dev/null @@ -1,34 +0,0 @@ -Singletons/T33.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| foo :: (Bool, Bool) -> () - foo ~(_, _) = () |] - ======> - foo :: (Bool, Bool) -> () - foo ~(_, _) = GHC.Tuple.() - type FooSym1 (t :: (Bool, Bool)) = Foo t - instance SuppressUnusedWarnings FooSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.()) - data FooSym0 (l :: TyFun (Bool, Bool) ()) - = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) => - FooSym0KindInference - type instance Apply FooSym0 l = FooSym1 l - type family Foo (a :: (Bool, Bool)) :: () where - Foo '(_z_0123456789, _z_0123456789) = Tuple0Sym0 - sFoo :: - forall (t :: (Bool, Bool)). Sing t -> Sing (Apply FooSym0 t :: ()) - sFoo (STuple2 _s_z_0123456789 _s_z_0123456789) - = let - lambda :: - forall _z_0123456789 - _z_0123456789. t ~ Apply (Apply Tuple2Sym0 _z_0123456789) _z_0123456789 => - Sing _z_0123456789 - -> Sing _z_0123456789 -> Sing (Apply FooSym0 t :: ()) - lambda _z_0123456789 _z_0123456789 = STuple0 - in lambda _s_z_0123456789 _s_z_0123456789 - -Singletons/T33.hs:0:0: Warning: - Lazy pattern converted into regular pattern in promotion - -Singletons/T33.hs:0:0: Warning: - Lazy pattern converted into regular pattern during singleton generation. diff --git a/tests/compile-and-dump/Singletons/T54.ghc710.template b/tests/compile-and-dump/Singletons/T54.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/T54.ghc710.template +++ /dev/null @@ -1,59 +0,0 @@ -Singletons/T54.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| g :: Bool -> Bool - g e = (case [not] of { [_] -> not }) e |] - ======> - g :: Bool -> Bool - g e = case [not] of { [_] -> not } e - type Let0123456789Scrutinee_0123456789Sym1 t = - Let0123456789Scrutinee_0123456789 t - instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where - suppressUnusedWarnings _ - = snd - (GHC.Tuple.(,) - Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.()) - data Let0123456789Scrutinee_0123456789Sym0 l - = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) => - Let0123456789Scrutinee_0123456789Sym0KindInference - type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l - type family Let0123456789Scrutinee_0123456789 e where - Let0123456789Scrutinee_0123456789 e = Apply (Apply (:$) NotSym0) '[] - type family Case_0123456789 e t where - Case_0123456789 e '[_z_0123456789] = NotSym0 - type GSym1 (t :: Bool) = G t - instance SuppressUnusedWarnings GSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) GSym0KindInference GHC.Tuple.()) - data GSym0 (l :: TyFun Bool Bool) - = forall arg. KindOf (Apply GSym0 arg) ~ KindOf (GSym1 arg) => - GSym0KindInference - type instance Apply GSym0 l = GSym1 l - type family G (a :: Bool) :: Bool where - G e = Apply (Case_0123456789 e (Let0123456789Scrutinee_0123456789Sym1 e)) e - sG :: forall (t :: Bool). Sing t -> Sing (Apply GSym0 t :: Bool) - sG sE - = let - lambda :: forall e. t ~ e => Sing e -> Sing (Apply GSym0 t :: Bool) - lambda e - = applySing - (let - sScrutinee_0123456789 :: - Sing (Let0123456789Scrutinee_0123456789Sym1 e) - sScrutinee_0123456789 - = applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (singFun1 (Proxy :: Proxy NotSym0) sNot)) - SNil - in case sScrutinee_0123456789 of { - SCons _s_z_0123456789 SNil - -> let - lambda :: - forall _z_0123456789. Apply (Apply (:$) _z_0123456789) '[] ~ Let0123456789Scrutinee_0123456789Sym1 e => - Sing _z_0123456789 - -> Sing (Case_0123456789 e (Apply (Apply (:$) _z_0123456789) '[])) - lambda _z_0123456789 = singFun1 (Proxy :: Proxy NotSym0) sNot - in lambda _s_z_0123456789 } :: - Sing (Case_0123456789 e (Let0123456789Scrutinee_0123456789Sym1 e))) - e - in lambda sE diff --git a/tests/compile-and-dump/Singletons/T78.ghc710.template b/tests/compile-and-dump/Singletons/T78.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/T78.ghc710.template +++ /dev/null @@ -1,42 +0,0 @@ -Singletons/T78.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| foo :: MaybeBool -> Bool - foo (Just False) = False - foo (Just True) = True - foo Nothing = False |] - ======> - foo :: MaybeBool -> Bool - foo (Just False) = False - foo (Just True) = True - foo Nothing = False - type FooSym1 (t :: Maybe Bool) = Foo t - instance SuppressUnusedWarnings FooSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.()) - data FooSym0 (l :: TyFun (Maybe Bool) Bool) - = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) => - FooSym0KindInference - type instance Apply FooSym0 l = FooSym1 l - type family Foo (a :: Maybe Bool) :: Bool where - Foo (Just False) = FalseSym0 - Foo (Just True) = TrueSym0 - Foo Nothing = FalseSym0 - sFoo :: - forall (t :: Maybe Bool). Sing t -> Sing (Apply FooSym0 t :: Bool) - sFoo (SJust SFalse) - = let - lambda :: - t ~ Apply JustSym0 FalseSym0 => Sing (Apply FooSym0 t :: Bool) - lambda = SFalse - in lambda - sFoo (SJust STrue) - = let - lambda :: - t ~ Apply JustSym0 TrueSym0 => Sing (Apply FooSym0 t :: Bool) - lambda = STrue - in lambda - sFoo SNothing - = let - lambda :: t ~ NothingSym0 => Sing (Apply FooSym0 t :: Bool) - lambda = SFalse - in lambda diff --git a/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc710.template b/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc710.template +++ /dev/null @@ -1,404 +0,0 @@ -Singletons/TopLevelPatterns.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| data Bool = False | True - data Foo = Bar Bool Bool |] - ======> - data Bool = False | True - data Foo = Bar Bool Bool - type FalseSym0 = False - type TrueSym0 = True - type BarSym2 (t :: Bool) (t :: Bool) = Bar t t - instance SuppressUnusedWarnings BarSym1 where - suppressUnusedWarnings _ - = Data.Tuple.snd (GHC.Tuple.(,) BarSym1KindInference GHC.Tuple.()) - data BarSym1 (l :: Bool) (l :: TyFun Bool Foo) - = forall arg. KindOf (Apply (BarSym1 l) arg) ~ KindOf (BarSym2 l arg) => - BarSym1KindInference - type instance Apply (BarSym1 l) l = BarSym2 l l - instance SuppressUnusedWarnings BarSym0 where - suppressUnusedWarnings _ - = Data.Tuple.snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.()) - data BarSym0 (l :: TyFun Bool (TyFun Bool Foo -> *)) - = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) => - BarSym0KindInference - type instance Apply BarSym0 l = BarSym1 l - data instance Sing (z :: Bool) - = z ~ False => SFalse | z ~ True => STrue - type SBool = (Sing :: Bool -> *) - instance SingKind (KProxy :: KProxy Bool) where - type DemoteRep (KProxy :: KProxy Bool) = Bool - fromSing SFalse = False - fromSing STrue = True - toSing False = SomeSing SFalse - toSing True = SomeSing STrue - data instance Sing (z :: Foo) - = forall (n :: Bool) (n :: Bool). z ~ Bar n n => - SBar (Sing (n :: Bool)) (Sing (n :: Bool)) - type SFoo = (Sing :: Foo -> *) - instance SingKind (KProxy :: KProxy Foo) where - type DemoteRep (KProxy :: KProxy Foo) = Foo - fromSing (SBar b b) = Bar (fromSing b) (fromSing b) - toSing (Bar b b) - = case - GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy Bool)) - (toSing b :: SomeSing (KProxy :: KProxy Bool)) - of { - GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SBar c c) } - instance SingI False where - sing = SFalse - instance SingI True where - sing = STrue - instance (SingI n, SingI n) => - SingI (Bar (n :: Bool) (n :: Bool)) where - sing = SBar sing sing -Singletons/TopLevelPatterns.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| otherwise :: Bool - otherwise = True - id :: a -> a - id x = x - not :: Bool -> Bool - not True = False - not False = True - false_ = False - f, g :: Bool -> Bool - [f, g] = [not, id] - h, i :: Bool -> Bool - (h, i) = (f, g) - j, k :: Bool - (Bar j k) = Bar True (h False) - l, m :: Bool - [l, m] = [not True, id False] |] - ======> - otherwise :: Bool - otherwise = True - id :: forall a. a -> a - id x = x - not :: Bool -> Bool - not True = False - not False = True - false_ = False - f :: Bool -> Bool - g :: Bool -> Bool - [f, g] = [not, id] - h :: Bool -> Bool - i :: Bool -> Bool - (h, i) = (f, g) - j :: Bool - k :: Bool - Bar j k = Bar True (h False) - l :: Bool - m :: Bool - [l, m] = [not True, id False] - type family Case_0123456789 a_0123456789 t where - Case_0123456789 a_0123456789 '[y_0123456789, - _z_0123456789] = y_0123456789 - type family Case_0123456789 a_0123456789 t where - Case_0123456789 a_0123456789 '[_z_0123456789, - y_0123456789] = y_0123456789 - type family Case_0123456789 a_0123456789 t where - Case_0123456789 a_0123456789 '(y_0123456789, - _z_0123456789) = y_0123456789 - type family Case_0123456789 a_0123456789 t where - Case_0123456789 a_0123456789 '(_z_0123456789, - y_0123456789) = y_0123456789 - type family Case_0123456789 t where - Case_0123456789 (Bar y_0123456789 _z_0123456789) = y_0123456789 - type family Case_0123456789 t where - Case_0123456789 (Bar _z_0123456789 y_0123456789) = y_0123456789 - type family Case_0123456789 t where - Case_0123456789 '[y_0123456789, _z_0123456789] = y_0123456789 - type family Case_0123456789 t where - Case_0123456789 '[_z_0123456789, y_0123456789] = y_0123456789 - type False_Sym0 = False_ - type NotSym1 (t :: Bool) = Not t - instance SuppressUnusedWarnings NotSym0 where - suppressUnusedWarnings _ - = Data.Tuple.snd (GHC.Tuple.(,) NotSym0KindInference GHC.Tuple.()) - data NotSym0 (l :: TyFun Bool Bool) - = forall arg. KindOf (Apply NotSym0 arg) ~ KindOf (NotSym1 arg) => - NotSym0KindInference - type instance Apply NotSym0 l = NotSym1 l - type IdSym1 (t :: a0123456789) = Id t - instance SuppressUnusedWarnings IdSym0 where - suppressUnusedWarnings _ - = Data.Tuple.snd (GHC.Tuple.(,) IdSym0KindInference GHC.Tuple.()) - data IdSym0 (l :: TyFun a0123456789 a0123456789) - = forall arg. KindOf (Apply IdSym0 arg) ~ KindOf (IdSym1 arg) => - IdSym0KindInference - type instance Apply IdSym0 l = IdSym1 l - type FSym1 (t :: Bool) = F t - instance SuppressUnusedWarnings FSym0 where - suppressUnusedWarnings _ - = Data.Tuple.snd (GHC.Tuple.(,) FSym0KindInference GHC.Tuple.()) - data FSym0 (l :: TyFun Bool Bool) - = forall arg. KindOf (Apply FSym0 arg) ~ KindOf (FSym1 arg) => - FSym0KindInference - type instance Apply FSym0 l = FSym1 l - type GSym1 (t :: Bool) = G t - instance SuppressUnusedWarnings GSym0 where - suppressUnusedWarnings _ - = Data.Tuple.snd (GHC.Tuple.(,) GSym0KindInference GHC.Tuple.()) - data GSym0 (l :: TyFun Bool Bool) - = forall arg. KindOf (Apply GSym0 arg) ~ KindOf (GSym1 arg) => - GSym0KindInference - type instance Apply GSym0 l = GSym1 l - type HSym1 (t :: Bool) = H t - instance SuppressUnusedWarnings HSym0 where - suppressUnusedWarnings _ - = Data.Tuple.snd (GHC.Tuple.(,) HSym0KindInference GHC.Tuple.()) - data HSym0 (l :: TyFun Bool Bool) - = forall arg. KindOf (Apply HSym0 arg) ~ KindOf (HSym1 arg) => - HSym0KindInference - type instance Apply HSym0 l = HSym1 l - type ISym1 (t :: Bool) = I t - instance SuppressUnusedWarnings ISym0 where - suppressUnusedWarnings _ - = Data.Tuple.snd (GHC.Tuple.(,) ISym0KindInference GHC.Tuple.()) - data ISym0 (l :: TyFun Bool Bool) - = forall arg. KindOf (Apply ISym0 arg) ~ KindOf (ISym1 arg) => - ISym0KindInference - type instance Apply ISym0 l = ISym1 l - type JSym0 = J - type KSym0 = K - type LSym0 = L - type MSym0 = M - type OtherwiseSym0 = Otherwise - type X_0123456789Sym0 = X_0123456789 - type X_0123456789Sym0 = X_0123456789 - type X_0123456789Sym0 = X_0123456789 - type X_0123456789Sym0 = X_0123456789 - type family False_ where - False_ = FalseSym0 - type family Not (a :: Bool) :: Bool where - Not True = FalseSym0 - Not False = TrueSym0 - type family Id (a :: a) :: a where - Id x = x - type family F (a :: Bool) :: Bool where - F a_0123456789 = Apply (Case_0123456789 a_0123456789 X_0123456789Sym0) a_0123456789 - type family G (a :: Bool) :: Bool where - G a_0123456789 = Apply (Case_0123456789 a_0123456789 X_0123456789Sym0) a_0123456789 - type family H (a :: Bool) :: Bool where - H a_0123456789 = Apply (Case_0123456789 a_0123456789 X_0123456789Sym0) a_0123456789 - type family I (a :: Bool) :: Bool where - I a_0123456789 = Apply (Case_0123456789 a_0123456789 X_0123456789Sym0) a_0123456789 - type family J :: Bool where - J = Case_0123456789 X_0123456789Sym0 - type family K :: Bool where - K = Case_0123456789 X_0123456789Sym0 - type family L :: Bool where - L = Case_0123456789 X_0123456789Sym0 - type family M :: Bool where - M = Case_0123456789 X_0123456789Sym0 - type family Otherwise :: Bool where - Otherwise = TrueSym0 - type family X_0123456789 where - X_0123456789 = Apply (Apply (:$) NotSym0) (Apply (Apply (:$) IdSym0) '[]) - type family X_0123456789 where - X_0123456789 = Apply (Apply Tuple2Sym0 FSym0) GSym0 - type family X_0123456789 where - X_0123456789 = Apply (Apply BarSym0 TrueSym0) (Apply HSym0 FalseSym0) - type family X_0123456789 where - X_0123456789 = Apply (Apply (:$) (Apply NotSym0 TrueSym0)) (Apply (Apply (:$) (Apply IdSym0 FalseSym0)) '[]) - sFalse_ :: Sing False_Sym0 - sNot :: - forall (t :: Bool). Sing t -> Sing (Apply NotSym0 t :: Bool) - sId :: forall (t :: a). Sing t -> Sing (Apply IdSym0 t :: a) - sF :: forall (t :: Bool). Sing t -> Sing (Apply FSym0 t :: Bool) - sG :: forall (t :: Bool). Sing t -> Sing (Apply GSym0 t :: Bool) - sH :: forall (t :: Bool). Sing t -> Sing (Apply HSym0 t :: Bool) - sI :: forall (t :: Bool). Sing t -> Sing (Apply ISym0 t :: Bool) - sJ :: Sing (JSym0 :: Bool) - sK :: Sing (KSym0 :: Bool) - sL :: Sing (LSym0 :: Bool) - sM :: Sing (MSym0 :: Bool) - sOtherwise :: Sing (OtherwiseSym0 :: Bool) - sX_0123456789 :: Sing X_0123456789Sym0 - sX_0123456789 :: Sing X_0123456789Sym0 - sX_0123456789 :: Sing X_0123456789Sym0 - sX_0123456789 :: Sing X_0123456789Sym0 - sFalse_ = SFalse - sNot STrue - = let - lambda :: t ~ TrueSym0 => Sing (Apply NotSym0 t :: Bool) - lambda = SFalse - in lambda - sNot SFalse - = let - lambda :: t ~ FalseSym0 => Sing (Apply NotSym0 t :: Bool) - lambda = STrue - in lambda - sId sX - = let - lambda :: forall x. t ~ x => Sing x -> Sing (Apply IdSym0 t :: a) - lambda x = x - in lambda sX - sF sA_0123456789 - = let - lambda :: - forall a_0123456789. t ~ a_0123456789 => - Sing a_0123456789 -> Sing (Apply FSym0 t :: Bool) - lambda a_0123456789 - = applySing - (case sX_0123456789 of { - SCons sY_0123456789 (SCons _s_z_0123456789 SNil) - -> let - lambda :: - forall y_0123456789 - _z_0123456789. Apply (Apply (:$) y_0123456789) (Apply (Apply (:$) _z_0123456789) '[]) ~ X_0123456789Sym0 => - Sing y_0123456789 - -> Sing _z_0123456789 - -> Sing (Case_0123456789 a_0123456789 (Apply (Apply (:$) y_0123456789) (Apply (Apply (:$) _z_0123456789) '[]))) - lambda y_0123456789 _z_0123456789 = y_0123456789 - in lambda sY_0123456789 _s_z_0123456789 } :: - Sing (Case_0123456789 a_0123456789 X_0123456789Sym0)) - a_0123456789 - in lambda sA_0123456789 - sG sA_0123456789 - = let - lambda :: - forall a_0123456789. t ~ a_0123456789 => - Sing a_0123456789 -> Sing (Apply GSym0 t :: Bool) - lambda a_0123456789 - = applySing - (case sX_0123456789 of { - SCons _s_z_0123456789 (SCons sY_0123456789 SNil) - -> let - lambda :: - forall _z_0123456789 - y_0123456789. Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) y_0123456789) '[]) ~ X_0123456789Sym0 => - Sing _z_0123456789 - -> Sing y_0123456789 - -> Sing (Case_0123456789 a_0123456789 (Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) y_0123456789) '[]))) - lambda _z_0123456789 y_0123456789 = y_0123456789 - in lambda _s_z_0123456789 sY_0123456789 } :: - Sing (Case_0123456789 a_0123456789 X_0123456789Sym0)) - a_0123456789 - in lambda sA_0123456789 - sH sA_0123456789 - = let - lambda :: - forall a_0123456789. t ~ a_0123456789 => - Sing a_0123456789 -> Sing (Apply HSym0 t :: Bool) - lambda a_0123456789 - = applySing - (case sX_0123456789 of { - STuple2 sY_0123456789 _s_z_0123456789 - -> let - lambda :: - forall y_0123456789 - _z_0123456789. Apply (Apply Tuple2Sym0 y_0123456789) _z_0123456789 ~ X_0123456789Sym0 => - Sing y_0123456789 - -> Sing _z_0123456789 - -> Sing (Case_0123456789 a_0123456789 (Apply (Apply Tuple2Sym0 y_0123456789) _z_0123456789)) - lambda y_0123456789 _z_0123456789 = y_0123456789 - in lambda sY_0123456789 _s_z_0123456789 } :: - Sing (Case_0123456789 a_0123456789 X_0123456789Sym0)) - a_0123456789 - in lambda sA_0123456789 - sI sA_0123456789 - = let - lambda :: - forall a_0123456789. t ~ a_0123456789 => - Sing a_0123456789 -> Sing (Apply ISym0 t :: Bool) - lambda a_0123456789 - = applySing - (case sX_0123456789 of { - STuple2 _s_z_0123456789 sY_0123456789 - -> let - lambda :: - forall _z_0123456789 - y_0123456789. Apply (Apply Tuple2Sym0 _z_0123456789) y_0123456789 ~ X_0123456789Sym0 => - Sing _z_0123456789 - -> Sing y_0123456789 - -> Sing (Case_0123456789 a_0123456789 (Apply (Apply Tuple2Sym0 _z_0123456789) y_0123456789)) - lambda _z_0123456789 y_0123456789 = y_0123456789 - in lambda _s_z_0123456789 sY_0123456789 } :: - Sing (Case_0123456789 a_0123456789 X_0123456789Sym0)) - a_0123456789 - in lambda sA_0123456789 - sJ - = case sX_0123456789 of { - SBar sY_0123456789 _s_z_0123456789 - -> let - lambda :: - forall y_0123456789 - _z_0123456789. Apply (Apply BarSym0 y_0123456789) _z_0123456789 ~ X_0123456789Sym0 => - Sing y_0123456789 - -> Sing _z_0123456789 - -> Sing (Case_0123456789 (Apply (Apply BarSym0 y_0123456789) _z_0123456789) :: Bool) - lambda y_0123456789 _z_0123456789 = y_0123456789 - in lambda sY_0123456789 _s_z_0123456789 } :: - Sing (Case_0123456789 X_0123456789Sym0 :: Bool) - sK - = case sX_0123456789 of { - SBar _s_z_0123456789 sY_0123456789 - -> let - lambda :: - forall _z_0123456789 - y_0123456789. Apply (Apply BarSym0 _z_0123456789) y_0123456789 ~ X_0123456789Sym0 => - Sing _z_0123456789 - -> Sing y_0123456789 - -> Sing (Case_0123456789 (Apply (Apply BarSym0 _z_0123456789) y_0123456789) :: Bool) - lambda _z_0123456789 y_0123456789 = y_0123456789 - in lambda _s_z_0123456789 sY_0123456789 } :: - Sing (Case_0123456789 X_0123456789Sym0 :: Bool) - sL - = case sX_0123456789 of { - SCons sY_0123456789 (SCons _s_z_0123456789 SNil) - -> let - lambda :: - forall y_0123456789 - _z_0123456789. Apply (Apply (:$) y_0123456789) (Apply (Apply (:$) _z_0123456789) '[]) ~ X_0123456789Sym0 => - Sing y_0123456789 - -> Sing _z_0123456789 - -> Sing (Case_0123456789 (Apply (Apply (:$) y_0123456789) (Apply (Apply (:$) _z_0123456789) '[])) :: Bool) - lambda y_0123456789 _z_0123456789 = y_0123456789 - in lambda sY_0123456789 _s_z_0123456789 } :: - Sing (Case_0123456789 X_0123456789Sym0 :: Bool) - sM - = case sX_0123456789 of { - SCons _s_z_0123456789 (SCons sY_0123456789 SNil) - -> let - lambda :: - forall _z_0123456789 - y_0123456789. Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) y_0123456789) '[]) ~ X_0123456789Sym0 => - Sing _z_0123456789 - -> Sing y_0123456789 - -> Sing (Case_0123456789 (Apply (Apply (:$) _z_0123456789) (Apply (Apply (:$) y_0123456789) '[])) :: Bool) - lambda _z_0123456789 y_0123456789 = y_0123456789 - in lambda _s_z_0123456789 sY_0123456789 } :: - Sing (Case_0123456789 X_0123456789Sym0 :: Bool) - sOtherwise = STrue - sX_0123456789 - = applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (singFun1 (Proxy :: Proxy NotSym0) sNot)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (singFun1 (Proxy :: Proxy IdSym0) sId)) - SNil) - sX_0123456789 - = applySing - (applySing - (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) - (singFun1 (Proxy :: Proxy FSym0) sF)) - (singFun1 (Proxy :: Proxy GSym0) sG) - sX_0123456789 - = applySing - (applySing (singFun2 (Proxy :: Proxy BarSym0) SBar) STrue) - (applySing (singFun1 (Proxy :: Proxy HSym0) sH) SFalse) - sX_0123456789 - = applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing (singFun1 (Proxy :: Proxy NotSym0) sNot) STrue)) - (applySing - (applySing - (singFun2 (Proxy :: Proxy (:$)) SCons) - (applySing (singFun1 (Proxy :: Proxy IdSym0) sId) SFalse)) - SNil) diff --git a/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc80.template b/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc80.template --- a/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc80.template +++ b/tests/compile-and-dump/Singletons/TopLevelPatterns.ghc80.template @@ -25,8 +25,8 @@ data instance Sing (z :: Bool) = z ~ False => SFalse | z ~ True => STrue type SBool = (Sing :: Bool -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy Bool) where - type DemoteRep (KProxy :: KProxy Bool) = Bool + instance SingKind Bool where + type DemoteRep Bool = Bool fromSing SFalse = False fromSing STrue = True toSing False = SomeSing SFalse @@ -35,14 +35,13 @@ = forall (n :: Bool) (n :: Bool). z ~ Bar n n => SBar (Sing (n :: Bool)) (Sing (n :: Bool)) type SFoo = (Sing :: Foo -> GHC.Types.Type) - instance SingKind (KProxy :: KProxy Foo) where - type DemoteRep (KProxy :: KProxy Foo) = Foo + instance SingKind Foo where + type DemoteRep Foo = Foo fromSing (SBar b b) = Bar (fromSing b) (fromSing b) toSing (Bar b b) = case GHC.Tuple.(,) - (toSing b :: SomeSing (KProxy :: KProxy Bool)) - (toSing b :: SomeSing (KProxy :: KProxy Bool)) + (toSing b :: SomeSing Bool) (toSing b :: SomeSing Bool) of { GHC.Tuple.(,) (SomeSing c) (SomeSing c) -> SomeSing (SBar c c) } instance SingI False where diff --git a/tests/compile-and-dump/Singletons/Undef.ghc710.template b/tests/compile-and-dump/Singletons/Undef.ghc710.template deleted file mode 100644 --- a/tests/compile-and-dump/Singletons/Undef.ghc710.template +++ /dev/null @@ -1,49 +0,0 @@ -Singletons/Undef.hs:(0,0)-(0,0): Splicing declarations - singletons - [d| foo :: Bool -> Bool - foo = undefined - bar :: Bool -> Bool - bar = error "urk" |] - ======> - foo :: Bool -> Bool - foo = undefined - bar :: Bool -> Bool - bar = error "urk" - type BarSym1 (t :: Bool) = Bar t - instance SuppressUnusedWarnings BarSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) BarSym0KindInference GHC.Tuple.()) - data BarSym0 (l :: TyFun Bool Bool) - = forall arg. KindOf (Apply BarSym0 arg) ~ KindOf (BarSym1 arg) => - BarSym0KindInference - type instance Apply BarSym0 l = BarSym1 l - type FooSym1 (t :: Bool) = Foo t - instance SuppressUnusedWarnings FooSym0 where - suppressUnusedWarnings _ - = snd (GHC.Tuple.(,) FooSym0KindInference GHC.Tuple.()) - data FooSym0 (l :: TyFun Bool Bool) - = forall arg. KindOf (Apply FooSym0 arg) ~ KindOf (FooSym1 arg) => - FooSym0KindInference - type instance Apply FooSym0 l = FooSym1 l - type family Bar (a :: Bool) :: Bool where - Bar a_0123456789 = Apply (Apply ErrorSym0 "urk") a_0123456789 - type family Foo (a :: Bool) :: Bool where - Foo a_0123456789 = Apply Any a_0123456789 - sBar :: - forall (t :: Bool). Sing t -> Sing (Apply BarSym0 t :: Bool) - sFoo :: - forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: Bool) - sBar sA_0123456789 - = let - lambda :: - forall a_0123456789. t ~ a_0123456789 => - Sing a_0123456789 -> Sing (Apply BarSym0 t :: Bool) - lambda a_0123456789 = sError (sing :: Sing "urk") - in lambda sA_0123456789 - sFoo sA_0123456789 - = let - lambda :: - forall a_0123456789. t ~ a_0123456789 => - Sing a_0123456789 -> Sing (Apply FooSym0 t :: Bool) - lambda a_0123456789 = undefined - in lambda sA_0123456789