{-# OPTIONS_HADDOCK show-extensions #-}
{-# LANGUAGE NoIncoherentInstances #-}

-- {-# LANGUAGE ConstraintKinds -}
-- {-# LANGUAGE GADTSyntax, NoMonoLocalBinds #-}
-- {-# LANGUAGE RankNTypes #-}

{-# LANGUAGE
     DataKinds
   , ExistentialQuantification
   , FlexibleContexts
   , FlexibleInstances
   , FunctionalDependencies
   , InstanceSigs
   , LambdaCase
   , MultiParamTypeClasses
   , PolyKinds
   , ScopedTypeVariables
   , StandaloneDeriving
   , TypeFamilies, NoMonoLocalBinds
   , TypeOperators
   , UndecidableInstances
   , ViewPatterns

   , DefaultSignatures
   , FlexibleContexts
   , StandaloneDeriving
   , TypeOperators
   #-}

{-# LANGUAGE NoMonomorphismRestriction #-}

-- UndecidableInstances is needed for a nested type family instance ^

module Vivid.SynthDef.TypesafeArgs (

   -- * Type Set Operations
     SubsetBoolToBool -- (..)
   , ElemBoolToBool
   , SetInsert --(..)
   , SetEqual --(..)
   , SetUnion --(..)

   , IsSubsetOf --(..)
   , Bool_IsSubsetOf(..)
   , Subset -- (..)

   , IsElemOf
   , Bool_IsElemOf(..)
   , Elem

   -- * Type arguments
   , TagList(..)
   , VarList(..)
   , V
   , Vs(..)
      -- | This is aliased as 'V':
   , Variable(..)
   , I(..)
   , VarSet(..)
   , TypedVarList -- (..)
   , emptyVarSet
   , iToLiteralVar
   , iToVar
   , AddParams(..)

   -- * Other
--    , (?>) -- not exporting so it doesn't pollute namespace
   , toI
   , toF
   , GetSymbolVals(..)
   ) where

import Control.Arrow (first, second)
import GHC.Exts
import GHC.Generics
import GHC.TypeLits
import qualified Data.Map as Map
import Data.Proxy
import Data.Type.Bool
import System.Random -- For a Random instance

type family SubsetBoolToBool (a :: Bool_IsSubsetOf) :: Bool where
   SubsetBoolToBool 'True_IsSubsetOf = 'True
   SubsetBoolToBool 'False_IsSubsetOf = 'False


type family ElemBoolToBool (a :: Bool_IsElemOf) :: Bool where
   ElemBoolToBool 'True_IsElemOf = 'True
   ElemBoolToBool 'False_IsElemOf = 'False

-- | So for example if you have:
-- 
--   @
--   foo = sd (440 ::I "freq") $ do
--      s <- sinOsc (freq_ (A::A "freq!!!"))
--      out 0 [s,s]
--   @
--
--   It'll tell you that you have an invalid synthdef with the error:
-- 
--   @
--     Couldn't match type ‘'False_IsSubsetOf’ with ‘'True_IsSubsetOf’
--                             In the first argument of ‘sinOsc’, namely
--       ‘(freq_ (V :: A "freq!!!"))’
--   @
data Bool_IsSubsetOf
   = True_IsSubsetOf
   | False_IsSubsetOf

type family SetInsert (s :: x) (sSet :: [x]) :: [x] where
   SetInsert e (e ': xs) = (e ': xs)
   SetInsert e xs = e ': xs

type family SetUnion (a :: [x]) (b :: [x]) :: [x] where
   SetUnion '[] bs = bs
   SetUnion (anA ': as) bs = SetUnion as (SetInsert anA bs)

type family SetUnions (a :: [[x]]) :: [x] where
   SetUnions '[] = '[]
   SetUnions (x ': xs) = SetUnion x (SetUnions xs)

-- | >>  .  :kind! SetIntersection '[4,3,4,5] '[7,5,3]
--   >> SetIntersection '[4,3,4,5] '[7,5,3] :: [GHC.TypeLits.Nat]
--   >> = '[3, 5]
type family SetIntersection (a :: [x]) (b :: [x]) :: [x] where
   SetIntersection a b = SetIntersectionPrime a b b

type family SetIntersectionPrime (a :: [x]) (b :: [x]) (allB :: [x]) :: [x] where
   SetIntersectionPrime '[] b allB = '[]
   SetIntersectionPrime (a ': as) '[] allB =
      SetIntersectionPrime as allB allB
   SetIntersectionPrime (a ': as) (a ': bs) allB =
      a ': SetIntersectionPrime as allB allB
   SetIntersectionPrime (a ': as) (b ': bs) allB =
      SetIntersectionPrime (a ': as) bs allB

type family IsSubsetOf (a :: [x]) (b :: [x]) :: Bool_IsSubsetOf where
   IsSubsetOf a b = IsSubsetOfPrime a b b

type family IsSubsetOfPrime (a :: [x]) (b :: [x]) (fullBs :: [x]) :: Bool_IsSubsetOf where
   IsSubsetOfPrime '[] b fullBs = 'True_IsSubsetOf
   IsSubsetOfPrime (a ': as) (a ': bs) fullBs =
      IsSubsetOfPrime as fullBs fullBs
   IsSubsetOfPrime (a ': as) (b ': bs) fullBs =
      IsSubsetOfPrime (a ': as) bs fullBs
   IsSubsetOfPrime as '[] fullBs = 'False_IsSubsetOf

data Bool_IsElemOf
   = True_IsElemOf
   | False_IsElemOf

-- Can rewrite in terms of IsSubsetOf
-- (And have 'Elem' vs 'IsElemOf' -- first is the constraint)
type family IsElemOf (a :: x) (l :: [x]) :: Bool_IsElemOf where
   IsElemOf a '[] = 'False_IsElemOf
   IsElemOf a (a ': b) = 'True_IsElemOf
   IsElemOf a (notA ': b) = IsElemOf a b

-- | >>  >  :kind! SetEqual '["bye", "hi","bye","bye"] '["bye","hi","hi"]
--   >> SetEqual '["bye","hi","bye","bye"] '["bye","hi","hi"] :: Bool
--   >> = 'True
type family SetEqual (a :: [x]) (b :: [x]) :: Bool where
   SetEqual a b =
         SubsetBoolToBool (IsSubsetOf a b)
      && SubsetBoolToBool (IsSubsetOf b a)


data Variable (a :: Symbol) =
   KnownSymbol a => V


data Vs (a :: [Symbol]) = Vs

instance Show (Variable a) where
   show :: Variable a -> String
show Variable a
V = String
"(V::V " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show (Proxy a -> String
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal (Proxy a
forall k (t :: k). Proxy t
Proxy::Proxy a)) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"

type V = Variable

{-
 >  getSymbolVals (Vs::Vs '["yes", "yes", "yall"])
["yes","yes","yall"]
-}

class GetSymbolVals x where
   getSymbolVals :: x -> [String]

instance GetSymbolVals (proxy '[]) where
   getSymbolVals :: proxy '[] -> [String]
getSymbolVals proxy '[]
_ = []

instance (KnownSymbol x, GetSymbolVals (Proxy (xs::[Symbol]))) =>
      GetSymbolVals (proxy (x ': xs)) where
   getSymbolVals :: proxy (x : xs) -> [String]
getSymbolVals proxy (x : xs)
_ =
      Proxy x -> String
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal (Proxy x
forall k (t :: k). Proxy t
Proxy::Proxy x) String -> [String] -> [String]
forall a. a -> [a] -> [a]
: Proxy xs -> [String]
forall x. GetSymbolVals x => x -> [String]
getSymbolVals (Proxy xs
forall k (t :: k). Proxy t
Proxy::Proxy xs)



data VarSet (s :: [Symbol]) = VarSet

instance (GetSymbolVals (VarSet xs)) => Show (VarSet xs) where
   show :: VarSet xs -> String
show VarSet xs
argSet =
      String
"(VarSet::VarSet "String -> ShowS
forall a. [a] -> [a] -> [a]
++[String] -> String
forall a. Show a => a -> String
show (VarSet xs -> [String]
forall x. GetSymbolVals x => x -> [String]
getSymbolVals VarSet xs
argSet)String -> ShowS
forall a. [a] -> [a] -> [a]
++String
")"

addVarToSet :: Variable sym -> VarSet syms -> VarSet (sym ': syms)
addVarToSet :: Variable sym -> VarSet syms -> VarSet (sym : syms)
addVarToSet Variable sym
V VarSet syms
VarSet = VarSet (sym : syms)
forall (s :: [Symbol]). VarSet s
VarSet

emptyVarSet :: VarSet '[]
emptyVarSet :: VarSet '[]
emptyVarSet = VarSet '[]
forall (s :: [Symbol]). VarSet s
VarSet

data I (x :: Symbol) =
   KnownSymbol x => I Float

instance (KnownSymbol s) => Show (I s) where
   show :: I s -> String
show (I Float
f) =
      String
"(" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Float -> String
forall a. Show a => a -> String
show Float
f String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"::I " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show (Proxy s -> String
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal (Proxy s
forall k (t :: k). Proxy t
Proxy::Proxy s)) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"
deriving instance (KnownSymbol s) => Eq (I s)
deriving instance (KnownSymbol s) => Read (I s)
deriving instance (KnownSymbol s) => Ord (I s)

toI :: (Real n, KnownSymbol a) => n -> I a
toI :: n -> I a
toI = Float -> I a
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> I a) -> (n -> Float) -> n -> I a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. n -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac

toF :: (Real n) => n -> Float
toF :: n -> Float
toF = n -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac

instance (KnownSymbol s) => Num (I s) where
   fromInteger :: Integer -> I s
fromInteger = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> I s) -> (Integer -> Float) -> Integer -> I s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Float
forall a. Num a => Integer -> a
fromInteger
   + :: I s -> I s -> I s
(+) (I Float
a) (I Float
b) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float
a Float -> Float -> Float
forall a. Num a => a -> a -> a
+ Float
b)
   (-) (I Float
a) (I Float
b) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float
a Float -> Float -> Float
forall a. Num a => a -> a -> a
- Float
b)
   abs :: I s -> I s
abs (I Float
a) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> Float
forall a. Num a => a -> a
abs Float
a)
   * :: I s -> I s -> I s
(*) (I Float
a) (I Float
b) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float
a Float -> Float -> Float
forall a. Num a => a -> a -> a
* Float
b)
   signum :: I s -> I s
signum (I Float
a) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> Float
forall a. Num a => a -> a
signum Float
a)

{-
 .  map (* 20) [3..5] :: [I "note"]
[(60.0::I "note"),(80.0::I "note"),(100.0::I "note")]-}
-- etc

instance (KnownSymbol s) => Fractional (I s) where
   fromRational :: Rational -> I s
fromRational = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> I s) -> (Rational -> Float) -> Rational -> I s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Float
forall a. Fractional a => Rational -> a
fromRational
   / :: I s -> I s -> I s
(/) (I Float
a) (I Float
b) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float
a Float -> Float -> Float
forall a. Fractional a => a -> a -> a
/ Float
b)

instance (KnownSymbol s) => Enum (I s) where
   fromEnum :: I s -> Int
fromEnum (I Float
f) = Float -> Int
forall a. Enum a => a -> Int
fromEnum Float
f
   toEnum :: Int -> I s
toEnum = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> I s) -> (Int -> Float) -> Int -> I s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Float
forall a. Enum a => Int -> a
toEnum

instance (KnownSymbol s) => Real (I s) where
   toRational :: I s -> Rational
toRational (I Float
f) = Float -> Rational
forall a. Real a => a -> Rational
toRational Float
f

instance (KnownSymbol s) => RealFrac (I s) where
   properFraction :: I s -> (b, I s)
properFraction (I Float
f) = (Float -> I s) -> (b, Float) -> (b, I s)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I ((b, Float) -> (b, I s)) -> (b, Float) -> (b, I s)
forall a b. (a -> b) -> a -> b
$ Float -> (b, Float)
forall a b. (RealFrac a, Integral b) => a -> (b, a)
properFraction Float
f
   truncate :: I s -> b
truncate (I Float
f) = Float -> b
forall a b. (RealFrac a, Integral b) => a -> b
truncate Float
f
   round :: I s -> b
round (I Float
f) = Float -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Float
f
   ceiling :: I s -> b
ceiling (I Float
f) = Float -> b
forall a b. (RealFrac a, Integral b) => a -> b
ceiling Float
f
   floor :: I s -> b
floor (I Float
f) = Float -> b
forall a b. (RealFrac a, Integral b) => a -> b
floor Float
f

instance (KnownSymbol s) => Floating (I s) where
   pi :: I s
pi = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I Float
forall a. Floating a => a
pi
   exp :: I s -> I s
exp (I Float
i) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> Float
forall a. Floating a => a -> a
exp Float
i)
   log :: I s -> I s
log (I Float
i) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> Float
forall a. Floating a => a -> a
log Float
i)
   sin :: I s -> I s
sin (I Float
i) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> Float
forall a. Floating a => a -> a
sin Float
i)
   cos :: I s -> I s
cos (I Float
i) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> Float
forall a. Floating a => a -> a
cos Float
i)
   asin :: I s -> I s
asin (I Float
i) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> Float
forall a. Floating a => a -> a
asin Float
i)
   acos :: I s -> I s
acos (I Float
i) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> Float
forall a. Floating a => a -> a
acos Float
i)
   atan :: I s -> I s
atan (I Float
i) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> Float
forall a. Floating a => a -> a
atan Float
i)
   sinh :: I s -> I s
sinh (I Float
i) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> Float
forall a. Floating a => a -> a
sinh Float
i)
   cosh :: I s -> I s
cosh (I Float
i) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> Float
forall a. Floating a => a -> a
cosh Float
i)
   asinh :: I s -> I s
asinh (I Float
i) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> Float
forall a. Floating a => a -> a
asinh Float
i)
   acosh :: I s -> I s
acosh (I Float
i) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> Float
forall a. Floating a => a -> a
acosh Float
i)
   atanh :: I s -> I s
atanh (I Float
i) = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> Float
forall a. Floating a => a -> a
atanh Float
i)

instance (KnownSymbol s) => RealFloat (I s) where
   floatRadix :: I s -> Integer
floatRadix (I Float
i) = Float -> Integer
forall a. RealFloat a => a -> Integer
floatRadix Float
i
   floatDigits :: I s -> Int
floatDigits (I Float
i) = Float -> Int
forall a. RealFloat a => a -> Int
floatDigits Float
i
   floatRange :: I s -> (Int, Int)
floatRange (I Float
i) = Float -> (Int, Int)
forall a. RealFloat a => a -> (Int, Int)
floatRange Float
i
   decodeFloat :: I s -> (Integer, Int)
decodeFloat (I Float
i) = Float -> (Integer, Int)
forall a. RealFloat a => a -> (Integer, Int)
decodeFloat Float
i
   encodeFloat :: Integer -> Int -> I s
encodeFloat Integer
a Int
b = Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (Float -> I s) -> Float -> I s
forall a b. (a -> b) -> a -> b
$ Integer -> Int -> Float
forall a. RealFloat a => Integer -> Int -> a
encodeFloat Integer
a Int
b
   isNaN :: I s -> Bool
isNaN (I Float
i) = Float -> Bool
forall a. RealFloat a => a -> Bool
isNaN Float
i
   isInfinite :: I s -> Bool
isInfinite (I Float
i) = Float -> Bool
forall a. RealFloat a => a -> Bool
isInfinite Float
i
   isDenormalized :: I s -> Bool
isDenormalized (I Float
i) = Float -> Bool
forall a. RealFloat a => a -> Bool
isDenormalized Float
i
   isNegativeZero :: I s -> Bool
isNegativeZero (I Float
i) = Float -> Bool
forall a. RealFloat a => a -> Bool
isNegativeZero Float
i
   isIEEE :: I s -> Bool
isIEEE (I Float
i) = Float -> Bool
forall a. RealFloat a => a -> Bool
isIEEE Float
i

instance (KnownSymbol s) => Random (I s) where
   randomR :: RandomGen g => (I s, I s) -> g -> (I s, g)
   randomR :: (I s, I s) -> g -> (I s, g)
randomR (I Float
rangeLo, I Float
rangeHi) g
gen =
      (Float -> I s) -> (Float, g) -> (I s, g)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I ((Float, g) -> (I s, g)) -> (Float, g) -> (I s, g)
forall a b. (a -> b) -> a -> b
$ (Float, Float) -> g -> (Float, g)
forall a g. (Random a, RandomGen g) => (a, a) -> g -> (a, g)
randomR (Float
rangeLo, Float
rangeHi) g
gen

   random :: RandomGen g => g -> (I s, g)
   random :: g -> (I s, g)
random g
gen = (Float -> I s) -> (Float, g) -> (I s, g)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first Float -> I s
forall (x :: Symbol). KnownSymbol x => Float -> I x
I (g -> (Float, g)
forall a g. (Random a, RandomGen g) => g -> (a, g)
random g
gen)

type TypedVarList (c :: [Symbol]) = ([(String, Float)], VarSet c)

iToLiteralVar :: KnownSymbol s => I s -> (String, Float)
iToLiteralVar :: I s -> (String, Float)
iToLiteralVar i :: I s
i@(I Float
f) = (I s -> String
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal I s
i, Float
f)

iToVar :: KnownSymbol s => I s -> V s
iToVar :: I s -> V s
iToVar I s
_ = V s
forall (a :: Symbol). KnownSymbol a => Variable a
V

infixr ?>
(?>) :: (KnownSymbol a, VarList b) => I a -> b -> TypedVarList (a ': InnerVars b)
?> :: I a -> b -> TypedVarList (a : InnerVars b)
(?>) I a
a b
b =
   let ([(String, Float)]
re, VarSet (InnerVars b)
name) = b -> ([(String, Float)], VarSet (InnerVars b))
forall from. VarList from => from -> TypedVarList (InnerVars from)
makeTypedVarList b
b
   in (I a -> (String, Float)
forall (s :: Symbol). KnownSymbol s => I s -> (String, Float)
iToLiteralVar I a
a (String, Float) -> [(String, Float)] -> [(String, Float)]
forall a. a -> [a] -> [a]
: [(String, Float)]
re, Variable a -> VarSet (InnerVars b) -> VarSet (a : InnerVars b)
forall (sym :: Symbol) (syms :: [Symbol]).
Variable sym -> VarSet syms -> VarSet (sym : syms)
addVarToSet {- (iToArg a) -} Variable a
forall (a :: Symbol). KnownSymbol a => Variable a
V VarSet (InnerVars b)
name)

class VarList from where
   type InnerVars from :: [Symbol]
   makeTypedVarList :: from -> TypedVarList (InnerVars from)

{-
   default makeTypedVarList :: (Generic from) => from -> TypedVarList (InnerVars from)
   makeTypedVarList = undefined
-}

infixl `AddParams`

class TagList from where
   type AllTags from :: [Symbol]
   tagStrings :: from -> [String]

-- | Lets you combine sets of arguments. e.g.
-- 
--   > (1 ::I "foo", 2 ::I "bar") `AddParams` (3 ::I "baz")
-- 
--   means the same thing as
-- 
--   > (1 ::I "foo", 2 ::I "bar", 3 ::I "baz")
--   
-- 
--   This is left-biased, just like 'Map.union'
-- 
--   i.e. if you say:
-- 
--   > (99 ::I "same") `AddParams` (0 ::I "same")
-- 
--   It'll mean the same as
-- 
--   > (99 ::I "same")
data AddParams a b
   = (VarList a, VarList b) => AddParams a b

deriving instance (Show a, Show b) => Show (AddParams a b)

instance VarList (AddParams a b) where
   type InnerVars (AddParams a b) = SetUnion (InnerVars a) (InnerVars b)
   makeTypedVarList :: AddParams a b -> TypedVarList (InnerVars (AddParams a b))
makeTypedVarList (a
a `AddParams` b
b) =
        let ([(String, Float)] -> Map String Float
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList -> Map String Float
fooA, VarSet (InnerVars a)
_) = a -> ([(String, Float)], VarSet (InnerVars a))
forall from. VarList from => from -> TypedVarList (InnerVars from)
makeTypedVarList a
a
            ([(String, Float)] -> Map String Float
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList -> Map String Float
fooB, VarSet (InnerVars b)
_) = b -> ([(String, Float)], VarSet (InnerVars b))
forall from. VarList from => from -> TypedVarList (InnerVars from)
makeTypedVarList b
b
            args :: [(String, Float)]
args = Map String Float -> [(String, Float)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map String Float -> [(String, Float)])
-> Map String Float -> [(String, Float)]
forall a b. (a -> b) -> a -> b
$ Map String Float
fooA Map String Float -> Map String Float -> Map String Float
forall k a. Ord k => Map k a -> Map k a -> Map k a
`Map.union` Map String Float
fooB
        in ([(String, Float)]
args, VarSet (InnerVars (AddParams a b))
forall (s :: [Symbol]). VarSet s
VarSet :: VarSet (InnerVars (AddParams a b)))

{-
type family Subset (a :: [Symbol]) (b :: [Symbol]) :: Constraint where
   Subset a b = IsSubsetOf a b ~ 'True_IsSubsetOf

type family Elem (a :: Symbol) (b :: [Symbol]) :: Constraint where
   Elem a b = IsElemOf a b ~ 'True_IsElemOf
-}


type family Subset (as :: [Symbol]) (bs :: [Symbol]) :: Constraint where
   Subset '[] bs = ()
   Subset (a ': as) bs = (Elem a bs, Subset as bs)

type family Elem (a :: Symbol) (xs :: [Symbol]) :: Constraint where
   Elem a (a ': xs) = ()
   Elem a (x ': xs) = Elem a xs


-- INSTANCES:

-- | Wheeeeeeeeeeeeeeee!

instance VarList (TypedVarList a) where
   type InnerVars (TypedVarList a) = a
   makeTypedVarList :: TypedVarList a -> TypedVarList (InnerVars (TypedVarList a))
makeTypedVarList = TypedVarList a -> TypedVarList (InnerVars (TypedVarList a))
forall a. a -> a
id

instance VarList () where
   type InnerVars () = '[]
   makeTypedVarList :: () -> TypedVarList (InnerVars ())
makeTypedVarList () = ([], VarSet '[]
VarSet (InnerVars ())
emptyVarSet)

instance
   (KnownSymbol a) =>
   VarList (I a)
   where
      type InnerVars (I a) = '[a]
      makeTypedVarList :: I a -> TypedVarList (InnerVars (I a))
makeTypedVarList I a
x =
         ([I a -> (String, Float)
forall (s :: Symbol). KnownSymbol s => I s -> (String, Float)
iToLiteralVar (I a
x)], VarSet '[a]
forall (s :: [Symbol]). VarSet s
VarSet::VarSet '[a])

instance
   (KnownSymbol a, KnownSymbol b) =>
   VarList (I a, I b)
   where
      type InnerVars (I a, I b) =
         '[a, b]
      makeTypedVarList :: (I a, I b) -> TypedVarList (InnerVars (I a, I b))
makeTypedVarList (I a
a,I b
b) =
         I a
a I a -> I b -> TypedVarList (a : InnerVars (I b))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c) =>
   VarList (I a, I b, I c)
   where
      type InnerVars (I a, I b, I c) =
         '[a,b,c]
      makeTypedVarList :: (I a, I b, I c) -> TypedVarList (InnerVars (I a, I b, I c))
makeTypedVarList (I a
a,I b
b,I c
c) =
         I a
a I a
-> TypedVarList '[b, c]
-> TypedVarList (a : InnerVars (TypedVarList '[b, c]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b -> I c -> TypedVarList (b : InnerVars (I c))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d) =>
   VarList (I a, I b, I c, I d)
   where
      type InnerVars (I a, I b, I c, I d) =
         '[a,b,c,d]
      makeTypedVarList :: (I a, I b, I c, I d)
-> TypedVarList (InnerVars (I a, I b, I c, I d))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d) =
         I a
a I a
-> TypedVarList '[b, c, d]
-> TypedVarList (a : InnerVars (TypedVarList '[b, c, d]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList '[c, d]
-> TypedVarList (b : InnerVars (TypedVarList '[c, d]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c -> I d -> TypedVarList (c : InnerVars (I d))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e) =>
   VarList
     (I a, I b, I c, I d, I e)
   where
      type InnerVars (I a, I b, I c, I d, I e) =
         '[a,b,c,d,e]
      makeTypedVarList :: (I a, I b, I c, I d, I e)
-> TypedVarList (InnerVars (I a, I b, I c, I d, I e))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e) =
         I a
a I a
-> TypedVarList '[b, c, d, e]
-> TypedVarList (a : InnerVars (TypedVarList '[b, c, d, e]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList '[c, d, e]
-> TypedVarList (b : InnerVars (TypedVarList '[c, d, e]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList '[d, e]
-> TypedVarList (c : InnerVars (TypedVarList '[d, e]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d -> I e -> TypedVarList (d : InnerVars (I e))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f) =
         '[a,b,c,d,e,f]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f)
-> TypedVarList (InnerVars (I a, I b, I c, I d, I e, I f))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f) =
         I a
a I a
-> TypedVarList '[b, c, d, e, f]
-> TypedVarList (a : InnerVars (TypedVarList '[b, c, d, e, f]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList '[c, d, e, f]
-> TypedVarList (b : InnerVars (TypedVarList '[c, d, e, f]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList '[d, e, f]
-> TypedVarList (c : InnerVars (TypedVarList '[d, e, f]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList '[e, f]
-> TypedVarList (d : InnerVars (TypedVarList '[e, f]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e -> I f -> TypedVarList (e : InnerVars (I f))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g) =
         '[a,b,c,d,e,f,g]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g)
-> TypedVarList (InnerVars (I a, I b, I c, I d, I e, I f, I g))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g) =
         I a
a I a
-> TypedVarList '[b, c, d, e, f, g]
-> TypedVarList (a : InnerVars (TypedVarList '[b, c, d, e, f, g]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList '[c, d, e, f, g]
-> TypedVarList (b : InnerVars (TypedVarList '[c, d, e, f, g]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList '[d, e, f, g]
-> TypedVarList (c : InnerVars (TypedVarList '[d, e, f, g]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList '[e, f, g]
-> TypedVarList (d : InnerVars (TypedVarList '[e, f, g]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList '[f, g]
-> TypedVarList (e : InnerVars (TypedVarList '[f, g]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f -> I g -> TypedVarList (f : InnerVars (I g))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h) =
         '[a,b,c,d,e,f,g,h]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h)
-> TypedVarList
     (InnerVars (I a, I b, I c, I d, I e, I f, I g, I h))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h) =
         I a
a I a
-> TypedVarList '[b, c, d, e, f, g, h]
-> TypedVarList
     (a : InnerVars (TypedVarList '[b, c, d, e, f, g, h]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList '[c, d, e, f, g, h]
-> TypedVarList (b : InnerVars (TypedVarList '[c, d, e, f, g, h]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList '[d, e, f, g, h]
-> TypedVarList (c : InnerVars (TypedVarList '[d, e, f, g, h]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList '[e, f, g, h]
-> TypedVarList (d : InnerVars (TypedVarList '[e, f, g, h]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList '[f, g, h]
-> TypedVarList (e : InnerVars (TypedVarList '[f, g, h]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList '[g, h]
-> TypedVarList (f : InnerVars (TypedVarList '[g, h]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g -> I h -> TypedVarList (g : InnerVars (I h))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i) =
         '[a,b,c,d,e,f,g,h,i]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i)
-> TypedVarList
     (InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i) =
         I a
a I a
-> TypedVarList '[b, c, d, e, f, g, h, i]
-> TypedVarList
     (a : InnerVars (TypedVarList '[b, c, d, e, f, g, h, i]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList '[c, d, e, f, g, h, i]
-> TypedVarList
     (b : InnerVars (TypedVarList '[c, d, e, f, g, h, i]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList '[d, e, f, g, h, i]
-> TypedVarList (c : InnerVars (TypedVarList '[d, e, f, g, h, i]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList '[e, f, g, h, i]
-> TypedVarList (d : InnerVars (TypedVarList '[e, f, g, h, i]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList '[f, g, h, i]
-> TypedVarList (e : InnerVars (TypedVarList '[f, g, h, i]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList '[g, h, i]
-> TypedVarList (f : InnerVars (TypedVarList '[g, h, i]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList '[h, i]
-> TypedVarList (g : InnerVars (TypedVarList '[h, i]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h -> I i -> TypedVarList (h : InnerVars (I i))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i


instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j) =
         '[a,b,c,d,e,f,g,h,i,j]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j)
-> TypedVarList
     (InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j) =
         I a
a I a
-> TypedVarList '[b, c, d, e, f, g, h, i, j]
-> TypedVarList
     (a : InnerVars (TypedVarList '[b, c, d, e, f, g, h, i, j]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList '[c, d, e, f, g, h, i, j]
-> TypedVarList
     (b : InnerVars (TypedVarList '[c, d, e, f, g, h, i, j]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList '[d, e, f, g, h, i, j]
-> TypedVarList
     (c : InnerVars (TypedVarList '[d, e, f, g, h, i, j]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList '[e, f, g, h, i, j]
-> TypedVarList (d : InnerVars (TypedVarList '[e, f, g, h, i, j]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList '[f, g, h, i, j]
-> TypedVarList (e : InnerVars (TypedVarList '[f, g, h, i, j]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList '[g, h, i, j]
-> TypedVarList (f : InnerVars (TypedVarList '[g, h, i, j]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList '[h, i, j]
-> TypedVarList (g : InnerVars (TypedVarList '[h, i, j]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList '[i, j]
-> TypedVarList (h : InnerVars (TypedVarList '[i, j]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i -> I j -> TypedVarList (i : InnerVars (I j))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j


instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k) =
         '[a,b,c,d,e,f,g,h,i,j,k]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k)
-> TypedVarList
     (InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k) =
         I a
a I a
-> TypedVarList '[b, c, d, e, f, g, h, i, j, k]
-> TypedVarList
     (a : InnerVars (TypedVarList '[b, c, d, e, f, g, h, i, j, k]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList '[c, d, e, f, g, h, i, j, k]
-> TypedVarList
     (b : InnerVars (TypedVarList '[c, d, e, f, g, h, i, j, k]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList '[d, e, f, g, h, i, j, k]
-> TypedVarList
     (c : InnerVars (TypedVarList '[d, e, f, g, h, i, j, k]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList '[e, f, g, h, i, j, k]
-> TypedVarList
     (d : InnerVars (TypedVarList '[e, f, g, h, i, j, k]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList '[f, g, h, i, j, k]
-> TypedVarList (e : InnerVars (TypedVarList '[f, g, h, i, j, k]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList '[g, h, i, j, k]
-> TypedVarList (f : InnerVars (TypedVarList '[g, h, i, j, k]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList '[h, i, j, k]
-> TypedVarList (g : InnerVars (TypedVarList '[h, i, j, k]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList '[i, j, k]
-> TypedVarList (h : InnerVars (TypedVarList '[i, j, k]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList '[j, k]
-> TypedVarList (i : InnerVars (TypedVarList '[j, k]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j -> I k -> TypedVarList (j : InnerVars (I k))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l) =
         '[a,b,c,d,e,f,g,h,i,j,k,l]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l)
-> TypedVarList
     (InnerVars
        (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k,I l
l) =
         I a
a I a
-> TypedVarList '[b, c, d, e, f, g, h, i, j, k, l]
-> TypedVarList
     (a : InnerVars (TypedVarList '[b, c, d, e, f, g, h, i, j, k, l]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList '[c, d, e, f, g, h, i, j, k, l]
-> TypedVarList
     (b : InnerVars (TypedVarList '[c, d, e, f, g, h, i, j, k, l]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList '[d, e, f, g, h, i, j, k, l]
-> TypedVarList
     (c : InnerVars (TypedVarList '[d, e, f, g, h, i, j, k, l]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList '[e, f, g, h, i, j, k, l]
-> TypedVarList
     (d : InnerVars (TypedVarList '[e, f, g, h, i, j, k, l]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList '[f, g, h, i, j, k, l]
-> TypedVarList
     (e : InnerVars (TypedVarList '[f, g, h, i, j, k, l]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList '[g, h, i, j, k, l]
-> TypedVarList (f : InnerVars (TypedVarList '[g, h, i, j, k, l]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList '[h, i, j, k, l]
-> TypedVarList (g : InnerVars (TypedVarList '[h, i, j, k, l]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList '[i, j, k, l]
-> TypedVarList (h : InnerVars (TypedVarList '[i, j, k, l]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList '[j, k, l]
-> TypedVarList (i : InnerVars (TypedVarList '[j, k, l]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j
-> TypedVarList '[k, l]
-> TypedVarList (j : InnerVars (TypedVarList '[k, l]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k I k -> I l -> TypedVarList (k : InnerVars (I l))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I l
l

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l, KnownSymbol m
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m) =
         '[a,b,c,d,e,f,g,h,i,j,k,l,m]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m)
-> TypedVarList
     (InnerVars
        (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k,I l
l,I m
m) =
         I a
a I a
-> TypedVarList '[b, c, d, e, f, g, h, i, j, k, l, m]
-> TypedVarList
     (a : InnerVars
            (TypedVarList '[b, c, d, e, f, g, h, i, j, k, l, m]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList '[c, d, e, f, g, h, i, j, k, l, m]
-> TypedVarList
     (b : InnerVars (TypedVarList '[c, d, e, f, g, h, i, j, k, l, m]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList '[d, e, f, g, h, i, j, k, l, m]
-> TypedVarList
     (c : InnerVars (TypedVarList '[d, e, f, g, h, i, j, k, l, m]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList '[e, f, g, h, i, j, k, l, m]
-> TypedVarList
     (d : InnerVars (TypedVarList '[e, f, g, h, i, j, k, l, m]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList '[f, g, h, i, j, k, l, m]
-> TypedVarList
     (e : InnerVars (TypedVarList '[f, g, h, i, j, k, l, m]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList '[g, h, i, j, k, l, m]
-> TypedVarList
     (f : InnerVars (TypedVarList '[g, h, i, j, k, l, m]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList '[h, i, j, k, l, m]
-> TypedVarList (g : InnerVars (TypedVarList '[h, i, j, k, l, m]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList '[i, j, k, l, m]
-> TypedVarList (h : InnerVars (TypedVarList '[i, j, k, l, m]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList '[j, k, l, m]
-> TypedVarList (i : InnerVars (TypedVarList '[j, k, l, m]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j
-> TypedVarList '[k, l, m]
-> TypedVarList (j : InnerVars (TypedVarList '[k, l, m]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k I k
-> TypedVarList '[l, m]
-> TypedVarList (k : InnerVars (TypedVarList '[l, m]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I l
l I l -> I m -> TypedVarList (l : InnerVars (I m))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I m
m

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l, KnownSymbol m, KnownSymbol n
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n) =
         '[a,b,c,d,e,f,g,h,i,j,k,l,m,n]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
 I n)
-> TypedVarList
     (InnerVars
        (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
         I n))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k,I l
l,I m
m,I n
n) =
         I a
a I a
-> TypedVarList '[b, c, d, e, f, g, h, i, j, k, l, m, n]
-> TypedVarList
     (a : InnerVars
            (TypedVarList '[b, c, d, e, f, g, h, i, j, k, l, m, n]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList '[c, d, e, f, g, h, i, j, k, l, m, n]
-> TypedVarList
     (b : InnerVars
            (TypedVarList '[c, d, e, f, g, h, i, j, k, l, m, n]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList '[d, e, f, g, h, i, j, k, l, m, n]
-> TypedVarList
     (c : InnerVars (TypedVarList '[d, e, f, g, h, i, j, k, l, m, n]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList '[e, f, g, h, i, j, k, l, m, n]
-> TypedVarList
     (d : InnerVars (TypedVarList '[e, f, g, h, i, j, k, l, m, n]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList '[f, g, h, i, j, k, l, m, n]
-> TypedVarList
     (e : InnerVars (TypedVarList '[f, g, h, i, j, k, l, m, n]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList '[g, h, i, j, k, l, m, n]
-> TypedVarList
     (f : InnerVars (TypedVarList '[g, h, i, j, k, l, m, n]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList '[h, i, j, k, l, m, n]
-> TypedVarList
     (g : InnerVars (TypedVarList '[h, i, j, k, l, m, n]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList '[i, j, k, l, m, n]
-> TypedVarList (h : InnerVars (TypedVarList '[i, j, k, l, m, n]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList '[j, k, l, m, n]
-> TypedVarList (i : InnerVars (TypedVarList '[j, k, l, m, n]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j
-> TypedVarList '[k, l, m, n]
-> TypedVarList (j : InnerVars (TypedVarList '[k, l, m, n]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k I k
-> TypedVarList '[l, m, n]
-> TypedVarList (k : InnerVars (TypedVarList '[l, m, n]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I l
l I l
-> TypedVarList '[m, n]
-> TypedVarList (l : InnerVars (TypedVarList '[m, n]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I m
m I m -> I n -> TypedVarList (m : InnerVars (I n))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I n
n

-- 15:
instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l, KnownSymbol m, KnownSymbol n, KnownSymbol o
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o) =
         '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
 I n, I o)
-> TypedVarList
     (InnerVars
        (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
         I n, I o))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k,I l
l,I m
m,I n
n,I o
o) =
         I a
a I a
-> TypedVarList '[b, c, d, e, f, g, h, i, j, k, l, m, n, o]
-> TypedVarList
     (a : InnerVars
            (TypedVarList '[b, c, d, e, f, g, h, i, j, k, l, m, n, o]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList '[c, d, e, f, g, h, i, j, k, l, m, n, o]
-> TypedVarList
     (b : InnerVars
            (TypedVarList '[c, d, e, f, g, h, i, j, k, l, m, n, o]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList '[d, e, f, g, h, i, j, k, l, m, n, o]
-> TypedVarList
     (c : InnerVars
            (TypedVarList '[d, e, f, g, h, i, j, k, l, m, n, o]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList '[e, f, g, h, i, j, k, l, m, n, o]
-> TypedVarList
     (d : InnerVars (TypedVarList '[e, f, g, h, i, j, k, l, m, n, o]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList '[f, g, h, i, j, k, l, m, n, o]
-> TypedVarList
     (e : InnerVars (TypedVarList '[f, g, h, i, j, k, l, m, n, o]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList '[g, h, i, j, k, l, m, n, o]
-> TypedVarList
     (f : InnerVars (TypedVarList '[g, h, i, j, k, l, m, n, o]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList '[h, i, j, k, l, m, n, o]
-> TypedVarList
     (g : InnerVars (TypedVarList '[h, i, j, k, l, m, n, o]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList '[i, j, k, l, m, n, o]
-> TypedVarList
     (h : InnerVars (TypedVarList '[i, j, k, l, m, n, o]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList '[j, k, l, m, n, o]
-> TypedVarList (i : InnerVars (TypedVarList '[j, k, l, m, n, o]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j
-> TypedVarList '[k, l, m, n, o]
-> TypedVarList (j : InnerVars (TypedVarList '[k, l, m, n, o]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k I k
-> TypedVarList '[l, m, n, o]
-> TypedVarList (k : InnerVars (TypedVarList '[l, m, n, o]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I l
l I l
-> TypedVarList '[m, n, o]
-> TypedVarList (l : InnerVars (TypedVarList '[m, n, o]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I m
m I m
-> TypedVarList '[n, o]
-> TypedVarList (m : InnerVars (TypedVarList '[n, o]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I n
n I n -> I o -> TypedVarList (n : InnerVars (I o))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I o
o

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l, KnownSymbol m, KnownSymbol n, KnownSymbol o
   ,KnownSymbol p
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p) =
         '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
 I n, I o, I p)
-> TypedVarList
     (InnerVars
        (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
         I n, I o, I p))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k,I l
l,I m
m,I n
n,I o
o,I p
p) =
         I a
a I a
-> TypedVarList '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p]
-> TypedVarList
     (a : InnerVars
            (TypedVarList '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList '[c, d, e, f, g, h, i, j, k, l, m, n, o, p]
-> TypedVarList
     (b : InnerVars
            (TypedVarList '[c, d, e, f, g, h, i, j, k, l, m, n, o, p]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList '[d, e, f, g, h, i, j, k, l, m, n, o, p]
-> TypedVarList
     (c : InnerVars
            (TypedVarList '[d, e, f, g, h, i, j, k, l, m, n, o, p]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList '[e, f, g, h, i, j, k, l, m, n, o, p]
-> TypedVarList
     (d : InnerVars
            (TypedVarList '[e, f, g, h, i, j, k, l, m, n, o, p]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList '[f, g, h, i, j, k, l, m, n, o, p]
-> TypedVarList
     (e : InnerVars (TypedVarList '[f, g, h, i, j, k, l, m, n, o, p]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList '[g, h, i, j, k, l, m, n, o, p]
-> TypedVarList
     (f : InnerVars (TypedVarList '[g, h, i, j, k, l, m, n, o, p]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList '[h, i, j, k, l, m, n, o, p]
-> TypedVarList
     (g : InnerVars (TypedVarList '[h, i, j, k, l, m, n, o, p]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList '[i, j, k, l, m, n, o, p]
-> TypedVarList
     (h : InnerVars (TypedVarList '[i, j, k, l, m, n, o, p]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList '[j, k, l, m, n, o, p]
-> TypedVarList
     (i : InnerVars (TypedVarList '[j, k, l, m, n, o, p]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j
-> TypedVarList '[k, l, m, n, o, p]
-> TypedVarList (j : InnerVars (TypedVarList '[k, l, m, n, o, p]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k I k
-> TypedVarList '[l, m, n, o, p]
-> TypedVarList (k : InnerVars (TypedVarList '[l, m, n, o, p]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I l
l I l
-> TypedVarList '[m, n, o, p]
-> TypedVarList (l : InnerVars (TypedVarList '[m, n, o, p]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I m
m I m
-> TypedVarList '[n, o, p]
-> TypedVarList (m : InnerVars (TypedVarList '[n, o, p]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I n
n I n
-> TypedVarList '[o, p]
-> TypedVarList (n : InnerVars (TypedVarList '[o, p]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I o
o I o -> I p -> TypedVarList (o : InnerVars (I p))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I p
p

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l, KnownSymbol m, KnownSymbol n, KnownSymbol o
   ,KnownSymbol p,KnownSymbol q
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q) =
         '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
 I n, I o, I p, I q)
-> TypedVarList
     (InnerVars
        (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
         I n, I o, I p, I q))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k,I l
l,I m
m,I n
n,I o
o,I p
p,I q
q) =
         I a
a I a
-> TypedVarList '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q]
-> TypedVarList
     (a : InnerVars
            (TypedVarList '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q]
-> TypedVarList
     (b : InnerVars
            (TypedVarList '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList '[d, e, f, g, h, i, j, k, l, m, n, o, p, q]
-> TypedVarList
     (c : InnerVars
            (TypedVarList '[d, e, f, g, h, i, j, k, l, m, n, o, p, q]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList '[e, f, g, h, i, j, k, l, m, n, o, p, q]
-> TypedVarList
     (d : InnerVars
            (TypedVarList '[e, f, g, h, i, j, k, l, m, n, o, p, q]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList '[f, g, h, i, j, k, l, m, n, o, p, q]
-> TypedVarList
     (e : InnerVars
            (TypedVarList '[f, g, h, i, j, k, l, m, n, o, p, q]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList '[g, h, i, j, k, l, m, n, o, p, q]
-> TypedVarList
     (f : InnerVars (TypedVarList '[g, h, i, j, k, l, m, n, o, p, q]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList '[h, i, j, k, l, m, n, o, p, q]
-> TypedVarList
     (g : InnerVars (TypedVarList '[h, i, j, k, l, m, n, o, p, q]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList '[i, j, k, l, m, n, o, p, q]
-> TypedVarList
     (h : InnerVars (TypedVarList '[i, j, k, l, m, n, o, p, q]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList '[j, k, l, m, n, o, p, q]
-> TypedVarList
     (i : InnerVars (TypedVarList '[j, k, l, m, n, o, p, q]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j
-> TypedVarList '[k, l, m, n, o, p, q]
-> TypedVarList
     (j : InnerVars (TypedVarList '[k, l, m, n, o, p, q]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k I k
-> TypedVarList '[l, m, n, o, p, q]
-> TypedVarList (k : InnerVars (TypedVarList '[l, m, n, o, p, q]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I l
l I l
-> TypedVarList '[m, n, o, p, q]
-> TypedVarList (l : InnerVars (TypedVarList '[m, n, o, p, q]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I m
m I m
-> TypedVarList '[n, o, p, q]
-> TypedVarList (m : InnerVars (TypedVarList '[n, o, p, q]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I n
n I n
-> TypedVarList '[o, p, q]
-> TypedVarList (n : InnerVars (TypedVarList '[o, p, q]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I o
o I o
-> TypedVarList '[p, q]
-> TypedVarList (o : InnerVars (TypedVarList '[p, q]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I p
p I p -> I q -> TypedVarList (p : InnerVars (I q))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I q
q


instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l, KnownSymbol m, KnownSymbol n, KnownSymbol o
   ,KnownSymbol p,KnownSymbol q,KnownSymbol r
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r) =
         '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
 I n, I o, I p, I q, I r)
-> TypedVarList
     (InnerVars
        (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
         I n, I o, I p, I q, I r))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k,I l
l,I m
m,I n
n,I o
o,I p
p,I q
q,I r
r) =
         I a
a I a
-> TypedVarList
     '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r]
-> TypedVarList
     (a : InnerVars
            (TypedVarList
               '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r]
-> TypedVarList
     (b : InnerVars
            (TypedVarList '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r]
-> TypedVarList
     (c : InnerVars
            (TypedVarList '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList '[e, f, g, h, i, j, k, l, m, n, o, p, q, r]
-> TypedVarList
     (d : InnerVars
            (TypedVarList '[e, f, g, h, i, j, k, l, m, n, o, p, q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList '[f, g, h, i, j, k, l, m, n, o, p, q, r]
-> TypedVarList
     (e : InnerVars
            (TypedVarList '[f, g, h, i, j, k, l, m, n, o, p, q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList '[g, h, i, j, k, l, m, n, o, p, q, r]
-> TypedVarList
     (f : InnerVars
            (TypedVarList '[g, h, i, j, k, l, m, n, o, p, q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList '[h, i, j, k, l, m, n, o, p, q, r]
-> TypedVarList
     (g : InnerVars (TypedVarList '[h, i, j, k, l, m, n, o, p, q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList '[i, j, k, l, m, n, o, p, q, r]
-> TypedVarList
     (h : InnerVars (TypedVarList '[i, j, k, l, m, n, o, p, q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList '[j, k, l, m, n, o, p, q, r]
-> TypedVarList
     (i : InnerVars (TypedVarList '[j, k, l, m, n, o, p, q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j
-> TypedVarList '[k, l, m, n, o, p, q, r]
-> TypedVarList
     (j : InnerVars (TypedVarList '[k, l, m, n, o, p, q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k I k
-> TypedVarList '[l, m, n, o, p, q, r]
-> TypedVarList
     (k : InnerVars (TypedVarList '[l, m, n, o, p, q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I l
l I l
-> TypedVarList '[m, n, o, p, q, r]
-> TypedVarList (l : InnerVars (TypedVarList '[m, n, o, p, q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I m
m I m
-> TypedVarList '[n, o, p, q, r]
-> TypedVarList (m : InnerVars (TypedVarList '[n, o, p, q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I n
n I n
-> TypedVarList '[o, p, q, r]
-> TypedVarList (n : InnerVars (TypedVarList '[o, p, q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I o
o I o
-> TypedVarList '[p, q, r]
-> TypedVarList (o : InnerVars (TypedVarList '[p, q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I p
p I p
-> TypedVarList '[q, r]
-> TypedVarList (p : InnerVars (TypedVarList '[q, r]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I q
q I q -> I r -> TypedVarList (q : InnerVars (I r))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I r
r

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l, KnownSymbol m, KnownSymbol n, KnownSymbol o
   ,KnownSymbol p,KnownSymbol q,KnownSymbol r,KnownSymbol s
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s) =
         '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
 I n, I o, I p, I q, I r, I s)
-> TypedVarList
     (InnerVars
        (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
         I n, I o, I p, I q, I r, I s))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k,I l
l,I m
m,I n
n,I o
o,I p
p,I q
q,I r
r,I s
s) =
         I a
a I a
-> TypedVarList
     '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s]
-> TypedVarList
     (a : InnerVars
            (TypedVarList
               '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList
     '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s]
-> TypedVarList
     (b : InnerVars
            (TypedVarList
               '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s]
-> TypedVarList
     (c : InnerVars
            (TypedVarList '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s]
-> TypedVarList
     (d : InnerVars
            (TypedVarList '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList '[f, g, h, i, j, k, l, m, n, o, p, q, r, s]
-> TypedVarList
     (e : InnerVars
            (TypedVarList '[f, g, h, i, j, k, l, m, n, o, p, q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList '[g, h, i, j, k, l, m, n, o, p, q, r, s]
-> TypedVarList
     (f : InnerVars
            (TypedVarList '[g, h, i, j, k, l, m, n, o, p, q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList '[h, i, j, k, l, m, n, o, p, q, r, s]
-> TypedVarList
     (g : InnerVars
            (TypedVarList '[h, i, j, k, l, m, n, o, p, q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList '[i, j, k, l, m, n, o, p, q, r, s]
-> TypedVarList
     (h : InnerVars (TypedVarList '[i, j, k, l, m, n, o, p, q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList '[j, k, l, m, n, o, p, q, r, s]
-> TypedVarList
     (i : InnerVars (TypedVarList '[j, k, l, m, n, o, p, q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j
-> TypedVarList '[k, l, m, n, o, p, q, r, s]
-> TypedVarList
     (j : InnerVars (TypedVarList '[k, l, m, n, o, p, q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k I k
-> TypedVarList '[l, m, n, o, p, q, r, s]
-> TypedVarList
     (k : InnerVars (TypedVarList '[l, m, n, o, p, q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I l
l I l
-> TypedVarList '[m, n, o, p, q, r, s]
-> TypedVarList
     (l : InnerVars (TypedVarList '[m, n, o, p, q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I m
m I m
-> TypedVarList '[n, o, p, q, r, s]
-> TypedVarList (m : InnerVars (TypedVarList '[n, o, p, q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I n
n I n
-> TypedVarList '[o, p, q, r, s]
-> TypedVarList (n : InnerVars (TypedVarList '[o, p, q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I o
o I o
-> TypedVarList '[p, q, r, s]
-> TypedVarList (o : InnerVars (TypedVarList '[p, q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I p
p I p
-> TypedVarList '[q, r, s]
-> TypedVarList (p : InnerVars (TypedVarList '[q, r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I q
q I q
-> TypedVarList '[r, s]
-> TypedVarList (q : InnerVars (TypedVarList '[r, s]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I r
r I r -> I s -> TypedVarList (r : InnerVars (I s))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I s
s


instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l, KnownSymbol m, KnownSymbol n, KnownSymbol o
   ,KnownSymbol p,KnownSymbol q,KnownSymbol r,KnownSymbol s,KnownSymbol t
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s,I t)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s,I t) =
         '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
 I n, I o, I p, I q, I r, I s, I t)
-> TypedVarList
     (InnerVars
        (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
         I n, I o, I p, I q, I r, I s, I t))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k,I l
l,I m
m,I n
n,I o
o,I p
p,I q
q,I r
r,I s
s,I t
t) =
         I a
a I a
-> TypedVarList
     '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t]
-> TypedVarList
     (a : InnerVars
            (TypedVarList
               '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList
     '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t]
-> TypedVarList
     (b : InnerVars
            (TypedVarList
               '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList
     '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t]
-> TypedVarList
     (c : InnerVars
            (TypedVarList
               '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t]
-> TypedVarList
     (d : InnerVars
            (TypedVarList '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList '[f, g, h, i, j, k, l, m, n, o, p, q, r, s, t]
-> TypedVarList
     (e : InnerVars
            (TypedVarList '[f, g, h, i, j, k, l, m, n, o, p, q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList '[g, h, i, j, k, l, m, n, o, p, q, r, s, t]
-> TypedVarList
     (f : InnerVars
            (TypedVarList '[g, h, i, j, k, l, m, n, o, p, q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList '[h, i, j, k, l, m, n, o, p, q, r, s, t]
-> TypedVarList
     (g : InnerVars
            (TypedVarList '[h, i, j, k, l, m, n, o, p, q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList '[i, j, k, l, m, n, o, p, q, r, s, t]
-> TypedVarList
     (h : InnerVars
            (TypedVarList '[i, j, k, l, m, n, o, p, q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList '[j, k, l, m, n, o, p, q, r, s, t]
-> TypedVarList
     (i : InnerVars (TypedVarList '[j, k, l, m, n, o, p, q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j
-> TypedVarList '[k, l, m, n, o, p, q, r, s, t]
-> TypedVarList
     (j : InnerVars (TypedVarList '[k, l, m, n, o, p, q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k I k
-> TypedVarList '[l, m, n, o, p, q, r, s, t]
-> TypedVarList
     (k : InnerVars (TypedVarList '[l, m, n, o, p, q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I l
l I l
-> TypedVarList '[m, n, o, p, q, r, s, t]
-> TypedVarList
     (l : InnerVars (TypedVarList '[m, n, o, p, q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I m
m I m
-> TypedVarList '[n, o, p, q, r, s, t]
-> TypedVarList
     (m : InnerVars (TypedVarList '[n, o, p, q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I n
n I n
-> TypedVarList '[o, p, q, r, s, t]
-> TypedVarList (n : InnerVars (TypedVarList '[o, p, q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I o
o I o
-> TypedVarList '[p, q, r, s, t]
-> TypedVarList (o : InnerVars (TypedVarList '[p, q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I p
p I p
-> TypedVarList '[q, r, s, t]
-> TypedVarList (p : InnerVars (TypedVarList '[q, r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I q
q I q
-> TypedVarList '[r, s, t]
-> TypedVarList (q : InnerVars (TypedVarList '[r, s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I r
r I r
-> TypedVarList '[s, t]
-> TypedVarList (r : InnerVars (TypedVarList '[s, t]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I s
s I s -> I t -> TypedVarList (s : InnerVars (I t))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I t
t


instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l, KnownSymbol m, KnownSymbol n, KnownSymbol o
   ,KnownSymbol p,KnownSymbol q,KnownSymbol r,KnownSymbol s,KnownSymbol t
   ,KnownSymbol u
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s,I t,I u)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s,I t,I u) =
         '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
 I n, I o, I p, I q, I r, I s, I t, I u)
-> TypedVarList
     (InnerVars
        (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
         I n, I o, I p, I q, I r, I s, I t, I u))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k,I l
l,I m
m,I n
n,I o
o,I p
p,I q
q,I r
r,I s
s,I t
t,I u
u) =
         I a
a I a
-> TypedVarList
     '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u]
-> TypedVarList
     (a : InnerVars
            (TypedVarList
               '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList
     '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u]
-> TypedVarList
     (b : InnerVars
            (TypedVarList
               '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList
     '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u]
-> TypedVarList
     (c : InnerVars
            (TypedVarList
               '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList
     '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u]
-> TypedVarList
     (d : InnerVars
            (TypedVarList
               '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList '[f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u]
-> TypedVarList
     (e : InnerVars
            (TypedVarList '[f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList '[g, h, i, j, k, l, m, n, o, p, q, r, s, t, u]
-> TypedVarList
     (f : InnerVars
            (TypedVarList '[g, h, i, j, k, l, m, n, o, p, q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList '[h, i, j, k, l, m, n, o, p, q, r, s, t, u]
-> TypedVarList
     (g : InnerVars
            (TypedVarList '[h, i, j, k, l, m, n, o, p, q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList '[i, j, k, l, m, n, o, p, q, r, s, t, u]
-> TypedVarList
     (h : InnerVars
            (TypedVarList '[i, j, k, l, m, n, o, p, q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList '[j, k, l, m, n, o, p, q, r, s, t, u]
-> TypedVarList
     (i : InnerVars
            (TypedVarList '[j, k, l, m, n, o, p, q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j
-> TypedVarList '[k, l, m, n, o, p, q, r, s, t, u]
-> TypedVarList
     (j : InnerVars (TypedVarList '[k, l, m, n, o, p, q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k I k
-> TypedVarList '[l, m, n, o, p, q, r, s, t, u]
-> TypedVarList
     (k : InnerVars (TypedVarList '[l, m, n, o, p, q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I l
l I l
-> TypedVarList '[m, n, o, p, q, r, s, t, u]
-> TypedVarList
     (l : InnerVars (TypedVarList '[m, n, o, p, q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I m
m I m
-> TypedVarList '[n, o, p, q, r, s, t, u]
-> TypedVarList
     (m : InnerVars (TypedVarList '[n, o, p, q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I n
n I n
-> TypedVarList '[o, p, q, r, s, t, u]
-> TypedVarList
     (n : InnerVars (TypedVarList '[o, p, q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I o
o I o
-> TypedVarList '[p, q, r, s, t, u]
-> TypedVarList (o : InnerVars (TypedVarList '[p, q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I p
p I p
-> TypedVarList '[q, r, s, t, u]
-> TypedVarList (p : InnerVars (TypedVarList '[q, r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I q
q I q
-> TypedVarList '[r, s, t, u]
-> TypedVarList (q : InnerVars (TypedVarList '[r, s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I r
r I r
-> TypedVarList '[s, t, u]
-> TypedVarList (r : InnerVars (TypedVarList '[s, t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I s
s I s
-> TypedVarList '[t, u]
-> TypedVarList (s : InnerVars (TypedVarList '[t, u]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I t
t I t -> I u -> TypedVarList (t : InnerVars (I u))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I u
u


instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l, KnownSymbol m, KnownSymbol n, KnownSymbol o
   ,KnownSymbol p,KnownSymbol q,KnownSymbol r,KnownSymbol s,KnownSymbol t
   ,KnownSymbol u,KnownSymbol v
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s,I t,I u,I v)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s,I t,I u,I v) =
         '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
 I n, I o, I p, I q, I r, I s, I t, I u, I v)
-> TypedVarList
     (InnerVars
        (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
         I n, I o, I p, I q, I r, I s, I t, I u, I v))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k,I l
l,I m
m,I n
n,I o
o,I p
p,I q
q,I r
r,I s
s,I t
t,I u
u,I v
v) =
         I a
a I a
-> TypedVarList
     '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]
-> TypedVarList
     (a : InnerVars
            (TypedVarList
               '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList
     '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]
-> TypedVarList
     (b : InnerVars
            (TypedVarList
               '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList
     '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]
-> TypedVarList
     (c : InnerVars
            (TypedVarList
               '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList
     '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]
-> TypedVarList
     (d : InnerVars
            (TypedVarList
               '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList
     '[f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]
-> TypedVarList
     (e : InnerVars
            (TypedVarList
               '[f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList '[g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]
-> TypedVarList
     (f : InnerVars
            (TypedVarList '[g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList '[h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]
-> TypedVarList
     (g : InnerVars
            (TypedVarList '[h, i, j, k, l, m, n, o, p, q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList '[i, j, k, l, m, n, o, p, q, r, s, t, u, v]
-> TypedVarList
     (h : InnerVars
            (TypedVarList '[i, j, k, l, m, n, o, p, q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList '[j, k, l, m, n, o, p, q, r, s, t, u, v]
-> TypedVarList
     (i : InnerVars
            (TypedVarList '[j, k, l, m, n, o, p, q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j
-> TypedVarList '[k, l, m, n, o, p, q, r, s, t, u, v]
-> TypedVarList
     (j : InnerVars
            (TypedVarList '[k, l, m, n, o, p, q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k I k
-> TypedVarList '[l, m, n, o, p, q, r, s, t, u, v]
-> TypedVarList
     (k : InnerVars (TypedVarList '[l, m, n, o, p, q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I l
l I l
-> TypedVarList '[m, n, o, p, q, r, s, t, u, v]
-> TypedVarList
     (l : InnerVars (TypedVarList '[m, n, o, p, q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I m
m I m
-> TypedVarList '[n, o, p, q, r, s, t, u, v]
-> TypedVarList
     (m : InnerVars (TypedVarList '[n, o, p, q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I n
n I n
-> TypedVarList '[o, p, q, r, s, t, u, v]
-> TypedVarList
     (n : InnerVars (TypedVarList '[o, p, q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I o
o I o
-> TypedVarList '[p, q, r, s, t, u, v]
-> TypedVarList
     (o : InnerVars (TypedVarList '[p, q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I p
p I p
-> TypedVarList '[q, r, s, t, u, v]
-> TypedVarList (p : InnerVars (TypedVarList '[q, r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I q
q I q
-> TypedVarList '[r, s, t, u, v]
-> TypedVarList (q : InnerVars (TypedVarList '[r, s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I r
r I r
-> TypedVarList '[s, t, u, v]
-> TypedVarList (r : InnerVars (TypedVarList '[s, t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I s
s I s
-> TypedVarList '[t, u, v]
-> TypedVarList (s : InnerVars (TypedVarList '[t, u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I t
t I t
-> TypedVarList '[u, v]
-> TypedVarList (t : InnerVars (TypedVarList '[u, v]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I u
u I u -> I v -> TypedVarList (u : InnerVars (I v))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I v
v


instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l, KnownSymbol m, KnownSymbol n, KnownSymbol o
   ,KnownSymbol p,KnownSymbol q,KnownSymbol r,KnownSymbol s,KnownSymbol t
   ,KnownSymbol u,KnownSymbol v,KnownSymbol w
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s,I t,I u,I v,I w)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s,I t,I u,I v,I w) =
         '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
 I n, I o, I p, I q, I r, I s, I t, I u, I v, I w)
-> TypedVarList
     (InnerVars
        (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
         I n, I o, I p, I q, I r, I s, I t, I u, I v, I w))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k,I l
l,I m
m,I n
n,I o
o,I p
p,I q
q,I r
r,I s
s,I t
t,I u
u,I v
v,I w
w) =
         I a
a I a
-> TypedVarList
     '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]
-> TypedVarList
     (a : InnerVars
            (TypedVarList
               '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v,
                 w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList
     '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]
-> TypedVarList
     (b : InnerVars
            (TypedVarList
               '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList
     '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]
-> TypedVarList
     (c : InnerVars
            (TypedVarList
               '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList
     '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]
-> TypedVarList
     (d : InnerVars
            (TypedVarList
               '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList
     '[f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]
-> TypedVarList
     (e : InnerVars
            (TypedVarList
               '[f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList
     '[g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]
-> TypedVarList
     (f : InnerVars
            (TypedVarList
               '[g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList '[h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]
-> TypedVarList
     (g : InnerVars
            (TypedVarList '[h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList '[i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]
-> TypedVarList
     (h : InnerVars
            (TypedVarList '[i, j, k, l, m, n, o, p, q, r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList '[j, k, l, m, n, o, p, q, r, s, t, u, v, w]
-> TypedVarList
     (i : InnerVars
            (TypedVarList '[j, k, l, m, n, o, p, q, r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j
-> TypedVarList '[k, l, m, n, o, p, q, r, s, t, u, v, w]
-> TypedVarList
     (j : InnerVars
            (TypedVarList '[k, l, m, n, o, p, q, r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k I k
-> TypedVarList '[l, m, n, o, p, q, r, s, t, u, v, w]
-> TypedVarList
     (k : InnerVars
            (TypedVarList '[l, m, n, o, p, q, r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I l
l I l
-> TypedVarList '[m, n, o, p, q, r, s, t, u, v, w]
-> TypedVarList
     (l : InnerVars (TypedVarList '[m, n, o, p, q, r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I m
m I m
-> TypedVarList '[n, o, p, q, r, s, t, u, v, w]
-> TypedVarList
     (m : InnerVars (TypedVarList '[n, o, p, q, r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I n
n I n
-> TypedVarList '[o, p, q, r, s, t, u, v, w]
-> TypedVarList
     (n : InnerVars (TypedVarList '[o, p, q, r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I o
o I o
-> TypedVarList '[p, q, r, s, t, u, v, w]
-> TypedVarList
     (o : InnerVars (TypedVarList '[p, q, r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I p
p I p
-> TypedVarList '[q, r, s, t, u, v, w]
-> TypedVarList
     (p : InnerVars (TypedVarList '[q, r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I q
q I q
-> TypedVarList '[r, s, t, u, v, w]
-> TypedVarList (q : InnerVars (TypedVarList '[r, s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I r
r I r
-> TypedVarList '[s, t, u, v, w]
-> TypedVarList (r : InnerVars (TypedVarList '[s, t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I s
s I s
-> TypedVarList '[t, u, v, w]
-> TypedVarList (s : InnerVars (TypedVarList '[t, u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I t
t I t
-> TypedVarList '[u, v, w]
-> TypedVarList (t : InnerVars (TypedVarList '[u, v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I u
u I u
-> TypedVarList '[v, w]
-> TypedVarList (u : InnerVars (TypedVarList '[v, w]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I v
v I v -> I w -> TypedVarList (v : InnerVars (I w))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I w
w


instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l, KnownSymbol m, KnownSymbol n, KnownSymbol o
   ,KnownSymbol p,KnownSymbol q,KnownSymbol r,KnownSymbol s,KnownSymbol t
   ,KnownSymbol u,KnownSymbol v,KnownSymbol w,KnownSymbol x
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s,I t,I u,I v,I w,I x)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s,I t,I u,I v,I w,I x) =
         '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
 I n, I o, I p, I q, I r, I s, I t, I u, I v, I w, I x)
-> TypedVarList
     (InnerVars
        (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
         I n, I o, I p, I q, I r, I s, I t, I u, I v, I w, I x))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k,I l
l,I m
m,I n
n,I o
o,I p
p,I q
q,I r
r,I s
s,I t
t,I u
u,I v
v,I w
w,I x
x) =
         I a
a I a
-> TypedVarList
     '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w,
       x]
-> TypedVarList
     (a : InnerVars
            (TypedVarList
               '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w,
                 x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList
     '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]
-> TypedVarList
     (b : InnerVars
            (TypedVarList
               '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w,
                 x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList
     '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]
-> TypedVarList
     (c : InnerVars
            (TypedVarList
               '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList
     '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]
-> TypedVarList
     (d : InnerVars
            (TypedVarList
               '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList
     '[f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]
-> TypedVarList
     (e : InnerVars
            (TypedVarList
               '[f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList
     '[g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]
-> TypedVarList
     (f : InnerVars
            (TypedVarList
               '[g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList
     '[h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]
-> TypedVarList
     (g : InnerVars
            (TypedVarList
               '[h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList '[i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]
-> TypedVarList
     (h : InnerVars
            (TypedVarList '[i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList '[j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]
-> TypedVarList
     (i : InnerVars
            (TypedVarList '[j, k, l, m, n, o, p, q, r, s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j
-> TypedVarList '[k, l, m, n, o, p, q, r, s, t, u, v, w, x]
-> TypedVarList
     (j : InnerVars
            (TypedVarList '[k, l, m, n, o, p, q, r, s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k I k
-> TypedVarList '[l, m, n, o, p, q, r, s, t, u, v, w, x]
-> TypedVarList
     (k : InnerVars
            (TypedVarList '[l, m, n, o, p, q, r, s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I l
l I l
-> TypedVarList '[m, n, o, p, q, r, s, t, u, v, w, x]
-> TypedVarList
     (l : InnerVars
            (TypedVarList '[m, n, o, p, q, r, s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I m
m I m
-> TypedVarList '[n, o, p, q, r, s, t, u, v, w, x]
-> TypedVarList
     (m : InnerVars (TypedVarList '[n, o, p, q, r, s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I n
n I n
-> TypedVarList '[o, p, q, r, s, t, u, v, w, x]
-> TypedVarList
     (n : InnerVars (TypedVarList '[o, p, q, r, s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I o
o I o
-> TypedVarList '[p, q, r, s, t, u, v, w, x]
-> TypedVarList
     (o : InnerVars (TypedVarList '[p, q, r, s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I p
p I p
-> TypedVarList '[q, r, s, t, u, v, w, x]
-> TypedVarList
     (p : InnerVars (TypedVarList '[q, r, s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I q
q I q
-> TypedVarList '[r, s, t, u, v, w, x]
-> TypedVarList
     (q : InnerVars (TypedVarList '[r, s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I r
r I r
-> TypedVarList '[s, t, u, v, w, x]
-> TypedVarList (r : InnerVars (TypedVarList '[s, t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I s
s I s
-> TypedVarList '[t, u, v, w, x]
-> TypedVarList (s : InnerVars (TypedVarList '[t, u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I t
t I t
-> TypedVarList '[u, v, w, x]
-> TypedVarList (t : InnerVars (TypedVarList '[u, v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I u
u I u
-> TypedVarList '[v, w, x]
-> TypedVarList (u : InnerVars (TypedVarList '[v, w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I v
v I v
-> TypedVarList '[w, x]
-> TypedVarList (v : InnerVars (TypedVarList '[w, x]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I w
w I w -> I x -> TypedVarList (w : InnerVars (I x))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I x
x


instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l, KnownSymbol m, KnownSymbol n, KnownSymbol o
   ,KnownSymbol p, KnownSymbol q, KnownSymbol r, KnownSymbol s, KnownSymbol t
   ,KnownSymbol u, KnownSymbol v, KnownSymbol w, KnownSymbol x, KnownSymbol y
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s,I t,I u,I v,I w,I x,I y)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s,I t,I u,I v,I w,I x,I y) =
         '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
 I n, I o, I p, I q, I r, I s, I t, I u, I v, I w, I x, I y)
-> TypedVarList
     (InnerVars
        (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
         I n, I o, I p, I q, I r, I s, I t, I u, I v, I w, I x, I y))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k,I l
l,I m
m,I n
n,I o
o,I p
p,I q
q,I r
r,I s
s,I t
t,I u
u,I v
v,I w
w,I x
x,I y
y) =
         I a
a I a
-> TypedVarList
     '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w,
       x, y]
-> TypedVarList
     (a : InnerVars
            (TypedVarList
               '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w,
                 x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList
     '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
       y]
-> TypedVarList
     (b : InnerVars
            (TypedVarList
               '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
                 y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList
     '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]
-> TypedVarList
     (c : InnerVars
            (TypedVarList
               '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
                 y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList
     '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]
-> TypedVarList
     (d : InnerVars
            (TypedVarList
               '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList
     '[f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]
-> TypedVarList
     (e : InnerVars
            (TypedVarList
               '[f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList
     '[g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]
-> TypedVarList
     (f : InnerVars
            (TypedVarList
               '[g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList
     '[h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]
-> TypedVarList
     (g : InnerVars
            (TypedVarList
               '[h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList
     '[i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]
-> TypedVarList
     (h : InnerVars
            (TypedVarList
               '[i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList '[j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]
-> TypedVarList
     (i : InnerVars
            (TypedVarList '[j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j
-> TypedVarList '[k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]
-> TypedVarList
     (j : InnerVars
            (TypedVarList '[k, l, m, n, o, p, q, r, s, t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k I k
-> TypedVarList '[l, m, n, o, p, q, r, s, t, u, v, w, x, y]
-> TypedVarList
     (k : InnerVars
            (TypedVarList '[l, m, n, o, p, q, r, s, t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I l
l I l
-> TypedVarList '[m, n, o, p, q, r, s, t, u, v, w, x, y]
-> TypedVarList
     (l : InnerVars
            (TypedVarList '[m, n, o, p, q, r, s, t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I m
m I m
-> TypedVarList '[n, o, p, q, r, s, t, u, v, w, x, y]
-> TypedVarList
     (m : InnerVars
            (TypedVarList '[n, o, p, q, r, s, t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I n
n I n
-> TypedVarList '[o, p, q, r, s, t, u, v, w, x, y]
-> TypedVarList
     (n : InnerVars (TypedVarList '[o, p, q, r, s, t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I o
o I o
-> TypedVarList '[p, q, r, s, t, u, v, w, x, y]
-> TypedVarList
     (o : InnerVars (TypedVarList '[p, q, r, s, t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I p
p I p
-> TypedVarList '[q, r, s, t, u, v, w, x, y]
-> TypedVarList
     (p : InnerVars (TypedVarList '[q, r, s, t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I q
q I q
-> TypedVarList '[r, s, t, u, v, w, x, y]
-> TypedVarList
     (q : InnerVars (TypedVarList '[r, s, t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I r
r I r
-> TypedVarList '[s, t, u, v, w, x, y]
-> TypedVarList
     (r : InnerVars (TypedVarList '[s, t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I s
s I s
-> TypedVarList '[t, u, v, w, x, y]
-> TypedVarList (s : InnerVars (TypedVarList '[t, u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I t
t I t
-> TypedVarList '[u, v, w, x, y]
-> TypedVarList (t : InnerVars (TypedVarList '[u, v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I u
u I u
-> TypedVarList '[v, w, x, y]
-> TypedVarList (u : InnerVars (TypedVarList '[v, w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I v
v I v
-> TypedVarList '[w, x, y]
-> TypedVarList (v : InnerVars (TypedVarList '[w, x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I w
w I w
-> TypedVarList '[x, y]
-> TypedVarList (w : InnerVars (TypedVarList '[x, y]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I x
x I x -> I y -> TypedVarList (x : InnerVars (I y))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I y
y


instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e
   ,KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j
   ,KnownSymbol k, KnownSymbol l, KnownSymbol m, KnownSymbol n, KnownSymbol o
   ,KnownSymbol p, KnownSymbol q, KnownSymbol r, KnownSymbol s, KnownSymbol t
   ,KnownSymbol u, KnownSymbol v, KnownSymbol w, KnownSymbol x, KnownSymbol y
   ,KnownSymbol z
   ) =>
   VarList
     (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s,I t,I u,I v,I w,I x,I y,I z)
   where
      type InnerVars (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m, I n, I o,I p,I q,I r,I s,I t,I u,I v,I w,I x,I y,I z) =
         '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z]
      makeTypedVarList :: (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
 I n, I o, I p, I q, I r, I s, I t, I u, I v, I w, I x, I y, I z)
-> TypedVarList
     (InnerVars
        (I a, I b, I c, I d, I e, I f, I g, I h, I i, I j, I k, I l, I m,
         I n, I o, I p, I q, I r, I s, I t, I u, I v, I w, I x, I y, I z))
makeTypedVarList (I a
a,I b
b,I c
c,I d
d,I e
e,I f
f,I g
g,I h
h,I i
i,I j
j,I k
k,I l
l,I m
m,I n
n,I o
o,I p
p,I q
q,I r
r,I s
s,I t
t,I u
u,I v
v,I w
w,I x
x,I y
y,I z
z) =
         I a
a I a
-> TypedVarList
     '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w,
       x, y, z]
-> TypedVarList
     (a : InnerVars
            (TypedVarList
               '[b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w,
                 x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I b
b I b
-> TypedVarList
     '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
       y, z]
-> TypedVarList
     (b : InnerVars
            (TypedVarList
               '[c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
                 y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I c
c I c
-> TypedVarList
     '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y,
       z]
-> TypedVarList
     (c : InnerVars
            (TypedVarList
               '[d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y,
                 z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I d
d I d
-> TypedVarList
     '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]
-> TypedVarList
     (d : InnerVars
            (TypedVarList
               '[e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y,
                 z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I e
e I e
-> TypedVarList
     '[f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]
-> TypedVarList
     (e : InnerVars
            (TypedVarList
               '[f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I f
f I f
-> TypedVarList
     '[g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]
-> TypedVarList
     (f : InnerVars
            (TypedVarList
               '[g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I g
g I g
-> TypedVarList
     '[h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]
-> TypedVarList
     (g : InnerVars
            (TypedVarList
               '[h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I h
h I h
-> TypedVarList
     '[i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]
-> TypedVarList
     (h : InnerVars
            (TypedVarList
               '[i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I i
i I i
-> TypedVarList
     '[j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]
-> TypedVarList
     (i : InnerVars
            (TypedVarList
               '[j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I j
j I j
-> TypedVarList '[k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]
-> TypedVarList
     (j : InnerVars
            (TypedVarList '[k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I k
k I k
-> TypedVarList '[l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]
-> TypedVarList
     (k : InnerVars
            (TypedVarList '[l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I l
l I l
-> TypedVarList '[m, n, o, p, q, r, s, t, u, v, w, x, y, z]
-> TypedVarList
     (l : InnerVars
            (TypedVarList '[m, n, o, p, q, r, s, t, u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I m
m I m
-> TypedVarList '[n, o, p, q, r, s, t, u, v, w, x, y, z]
-> TypedVarList
     (m : InnerVars
            (TypedVarList '[n, o, p, q, r, s, t, u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I n
n I n
-> TypedVarList '[o, p, q, r, s, t, u, v, w, x, y, z]
-> TypedVarList
     (n : InnerVars
            (TypedVarList '[o, p, q, r, s, t, u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I o
o I o
-> TypedVarList '[p, q, r, s, t, u, v, w, x, y, z]
-> TypedVarList
     (o : InnerVars (TypedVarList '[p, q, r, s, t, u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I p
p I p
-> TypedVarList '[q, r, s, t, u, v, w, x, y, z]
-> TypedVarList
     (p : InnerVars (TypedVarList '[q, r, s, t, u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I q
q I q
-> TypedVarList '[r, s, t, u, v, w, x, y, z]
-> TypedVarList
     (q : InnerVars (TypedVarList '[r, s, t, u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I r
r I r
-> TypedVarList '[s, t, u, v, w, x, y, z]
-> TypedVarList
     (r : InnerVars (TypedVarList '[s, t, u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I s
s I s
-> TypedVarList '[t, u, v, w, x, y, z]
-> TypedVarList
     (s : InnerVars (TypedVarList '[t, u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I t
t I t
-> TypedVarList '[u, v, w, x, y, z]
-> TypedVarList (t : InnerVars (TypedVarList '[u, v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I u
u I u
-> TypedVarList '[v, w, x, y, z]
-> TypedVarList (u : InnerVars (TypedVarList '[v, w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I v
v I v
-> TypedVarList '[w, x, y, z]
-> TypedVarList (v : InnerVars (TypedVarList '[w, x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I w
w I w
-> TypedVarList '[x, y, z]
-> TypedVarList (w : InnerVars (TypedVarList '[x, y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I x
x I x
-> TypedVarList '[y, z]
-> TypedVarList (x : InnerVars (TypedVarList '[y, z]))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I y
y I y -> I z -> TypedVarList (y : InnerVars (I z))
forall (a :: Symbol) b.
(KnownSymbol a, VarList b) =>
I a -> b -> TypedVarList (a : InnerVars b)
?> I z
z




(##) :: (KnownSymbol a, TagList b) => V a -> b -> [String]
## :: V a -> b -> [String]
(##) (V a
_::V a) b
b = Proxy a -> String
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal (Proxy a
forall k (t :: k). Proxy t
Proxy::Proxy a) String -> [String] -> [String]
forall a. a -> [a] -> [a]
: b -> [String]
forall from. TagList from => from -> [String]
tagStrings b
b

instance TagList () where
   type AllTags () = '[]
   tagStrings :: () -> [String]
tagStrings () = []

instance (KnownSymbol a) => TagList (V a) where
   type AllTags (V a) = '[a]
   tagStrings :: V a -> [String]
tagStrings (V a
_ :: V a) = [Proxy a -> String
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal (Proxy a
forall k (t :: k). Proxy t
Proxy::Proxy a)]

instance (KnownSymbol a, KnownSymbol b) => TagList (V a, V b) where
   type AllTags (V a, V b) = '[a, b]
   tagStrings :: (V a, V b) -> [String]
tagStrings (V a
a,V b
b) = V a
a V a -> V b -> [String]
forall (a :: Symbol) b.
(KnownSymbol a, TagList b) =>
V a -> b -> [String]
## V b
b

-- Also works:
-- instance (KnownSymbol a , TagList (V b,V c)) => TagList (V a, V b, V c) where
instance (KnownSymbol a, KnownSymbol b, KnownSymbol c) => TagList (V a, V b, V c) where
   type AllTags (V a, V b, V c) = '[a, b, c]
   tagStrings :: (V a, V b, V c) -> [String]
tagStrings (V a
a,V b
b,V c
c) = V a
a V a -> (V b, V c) -> [String]
forall (a :: Symbol) b.
(KnownSymbol a, TagList b) =>
V a -> b -> [String]
## (V b
b,V c
c)

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d) =>
      TagList (V a,V b,V c,V d) where
   type AllTags (V a,V b,V c,V d) =
      '[a,b,c,d]
   tagStrings :: (V a, V b, V c, V d) -> [String]
tagStrings (V a
a,V b
b,V c
c,V d
d) = V a
a V a -> (V b, V c, V d) -> [String]
forall (a :: Symbol) b.
(KnownSymbol a, TagList b) =>
V a -> b -> [String]
## (V b
b,V c
c,V d
d)

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e) =>
      TagList (V a,V b,V c,V d,V e) where
   type AllTags (V a,V b,V c,V d,V e) =
      '[a,b,c,d,e]
   tagStrings :: (V a, V b, V c, V d, V e) -> [String]
tagStrings (V a
a,V b
b,V c
c,V d
d,V e
e) = V a
a V a -> (V b, V c, V d, V e) -> [String]
forall (a :: Symbol) b.
(KnownSymbol a, TagList b) =>
V a -> b -> [String]
## (V b
b,V c
c,V d
d,V e
e)

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f
   ) =>
      TagList (V a,V b,V c,V d,V e,V f) where
   type AllTags (V a,V b,V c,V d,V e,V f) =
      '[a,b,c,d,e,f]
   tagStrings :: (V a, V b, V c, V d, V e, V f) -> [String]
tagStrings (V a
a,V b
b,V c
c,V d
d,V e
e,V f
f) = V a
a V a -> (V b, V c, V d, V e, V f) -> [String]
forall (a :: Symbol) b.
(KnownSymbol a, TagList b) =>
V a -> b -> [String]
## (V b
b,V c
c,V d
d,V e
e,V f
f)

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g
   ) =>
      TagList (V a,V b,V c,V d,V e,V f,V g) where
   type AllTags (V a,V b,V c,V d,V e,V f,V g) =
      '[a,b,c,d,e,f,g]
   tagStrings :: (V a, V b, V c, V d, V e, V f, V g) -> [String]
tagStrings (V a
a,V b
b,V c
c,V d
d,V e
e,V f
f,V g
g) = V a
a V a -> (V b, V c, V d, V e, V f, V g) -> [String]
forall (a :: Symbol) b.
(KnownSymbol a, TagList b) =>
V a -> b -> [String]
## (V b
b,V c
c,V d
d,V e
e,V f
f,V g
g)

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h
   ) =>
      TagList (V a,V b,V c,V d,V e,V f,V g,V h) where
   type AllTags (V a,V b,V c,V d,V e,V f,V g,V h) =
      '[a,b,c,d,e,f,g,h]
   tagStrings :: (V a, V b, V c, V d, V e, V f, V g, V h) -> [String]
tagStrings (V a
a,V b
b,V c
c,V d
d,V e
e,V f
f,V g
g,V h
h) = V a
a V a -> (V b, V c, V d, V e, V f, V g, V h) -> [String]
forall (a :: Symbol) b.
(KnownSymbol a, TagList b) =>
V a -> b -> [String]
## (V b
b,V c
c,V d
d,V e
e,V f
f,V g
g,V h
h)

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i
   ) =>
      TagList (V a,V b,V c,V d,V e,V f,V g,V h,V i) where
   type AllTags (V a,V b,V c,V d,V e,V f,V g,V h,V i) =
      '[a,b,c,d,e,f,g,h,i]
   tagStrings :: (V a, V b, V c, V d, V e, V f, V g, V h, V i) -> [String]
tagStrings (V a
a,V b
b,V c
c,V d
d,V e
e,V f
f,V g
g,V h
h,V i
i) = V a
a V a -> (V b, V c, V d, V e, V f, V g, V h, V i) -> [String]
forall (a :: Symbol) b.
(KnownSymbol a, TagList b) =>
V a -> b -> [String]
## (V b
b,V c
c,V d
d,V e
e,V f
f,V g
g,V h
h,V i
i)

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j
   ) =>
      TagList (V a,V b,V c,V d,V e,V f,V g,V h,V i,V j) where
   type AllTags (V a,V b,V c,V d,V e,V f,V g,V h,V i,V j) =
      '[a,b,c,d,e,f,g,h,i,j]
   tagStrings :: (V a, V b, V c, V d, V e, V f, V g, V h, V i, V j) -> [String]
tagStrings (V a
a,V b
b,V c
c,V d
d,V e
e,V f
f,V g
g,V h
h,V i
i,V j
j) = V a
a V a -> (V b, V c, V d, V e, V f, V g, V h, V i, V j) -> [String]
forall (a :: Symbol) b.
(KnownSymbol a, TagList b) =>
V a -> b -> [String]
## (V b
b,V c
c,V d
d,V e
e,V f
f,V g
g,V h
h,V i
i,V j
j)

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k
   ) =>
      TagList (V a,V b,V c,V d,V e,V f,V g,V h,V i,V j,V k) where
   type AllTags (V a,V b,V c,V d,V e,V f,V g,V h,V i,V j,V k) =
      '[a,b,c,d,e,f,g,h,i,j,k]
   tagStrings :: (V a, V b, V c, V d, V e, V f, V g, V h, V i, V j, V k) -> [String]
tagStrings (V a
a,V b
b,V c
c,V d
d,V e
e,V f
f,V g
g,V h
h,V i
i,V j
j,V k
k) = V a
a V a
-> (V b, V c, V d, V e, V f, V g, V h, V i, V j, V k) -> [String]
forall (a :: Symbol) b.
(KnownSymbol a, TagList b) =>
V a -> b -> [String]
## (V b
b,V c
c,V d
d,V e
e,V f
f,V g
g,V h
h,V i
i,V j
j,V k
k)

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l
   ) =>
      TagList (V a,V b,V c,V d,V e,V f,V g,V h,V i,V j,V k,V l) where
   type AllTags (V a,V b,V c,V d,V e,V f,V g,V h,V i,V j,V k,V l) =
      '[a,b,c,d,e,f,g,h,i,j,k,l]
   tagStrings :: (V a, V b, V c, V d, V e, V f, V g, V h, V i, V j, V k, V l)
-> [String]
tagStrings (V a
a,V b
b,V c
c,V d
d,V e
e,V f
f,V g
g,V h
h,V i
i,V j
j,V k
k,V l
l) = V a
a V a
-> (V b, V c, V d, V e, V f, V g, V h, V i, V j, V k, V l)
-> [String]
forall (a :: Symbol) b.
(KnownSymbol a, TagList b) =>
V a -> b -> [String]
## (V b
b,V c
c,V d
d,V e
e,V f
f,V g
g,V h
h,V i
i,V j
j,V k
k,V l
l)

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l, KnownSymbol m
   ) =>
      TagList (V a,V b,V c,V d,V e,V f,V g,V h,V i,V j,V k,V l,V m) where
   type AllTags (V a,V b,V c,V d,V e,V f,V g,V h,V i,V j,V k,V l,V m) =
      '[a,b,c,d,e,f,g,h,i,j,k,l,m]
   tagStrings :: (V a, V b, V c, V d, V e, V f, V g, V h, V i, V j, V k, V l, V m)
-> [String]
tagStrings (V a
a,V b
b,V c
c,V d
d,V e
e,V f
f,V g
g,V h
h,V i
i,V j
j,V k
k,V l
l,V m
m) = V a
a V a
-> (V b, V c, V d, V e, V f, V g, V h, V i, V j, V k, V l, V m)
-> [String]
forall (a :: Symbol) b.
(KnownSymbol a, TagList b) =>
V a -> b -> [String]
## (V b
b,V c
c,V d
d,V e
e,V f
f,V g
g,V h
h,V i
i,V j
j,V k
k,V l
l,V m
m)

instance
   (KnownSymbol a, KnownSymbol b, KnownSymbol c, KnownSymbol d, KnownSymbol e,
    KnownSymbol f, KnownSymbol g, KnownSymbol h, KnownSymbol i, KnownSymbol j,
    KnownSymbol k, KnownSymbol l, KnownSymbol m, KnownSymbol n
   ) =>
      TagList (V a,V b,V c,V d,V e,V f,V g,V h,V i,V j,V k,V l,V m,V