gadt

In the end of the "5. Full OTT" section of Towards Observational Type Theory the authors show how to define coercible-under-constructors indexed data types in OTT. The idea is basically to turn indexed data types into parameterized like this: data IFin : ℕ -> Set where zero : ∀ {n} -> IFin (suc n) suc : ∀ {n} -> IFin n -> IFin (suc n) data PFin (m : ℕ) : Set where zero : ∀ {n} -> suc n ≡ m -> PFin m suc : ∀ {n} -> suc n ≡ m -> PFin n -> PFin m Conor also mentions this technique at the bottom of observational type theory (delivery) : The fix, of course, is to do what the GADT people did, and

Is there an equivalent of makeLenses for GADTs? If I have a simple GADT like: data D a b where D :: (Ord a, Ord b) => !a -> !b -> D a b Is there a way to generate lenses automatically by passing in a constructor and a list of field names? I don't think it can be done automatically, but writing some lenses by hand isn't that hard in this particular case: {-# LANGUAGE GADTs #-} import Control.Lens data D a b where D :: (Ord a, Ord b) => !a -> !b -> D a b field1 :: Lens' (D a b) a field1 f (D x y) = fmap (\x' -> D x' y) (f x) field2 :: Lens' (D a b) b field2 f (D x y) = fmap (\y' -> D x y') (f y)

data Foo a is defined like: data Foo a where Foo :: (Typeable a, Show a) => a -> Foo a -- perhaps more constructors instance Show a => Show (Foo a) where show (Foo a) = show a with some instances: fiveFoo :: Foo Int fiveFoo = Foo 5 falseFoo :: Foo Bool falseFoo = Foo False How can I define any function from b -> Foo a , for example: getFoo :: (Show a, Typeable a) => String -> Foo a getFoo "five" = fiveFoo getFoo "false" = falseFoo Here getFoo does not type check with Couldn't match type ‘a’ with ‘Bool’ . The only thing that I am interested in here is for a to be of class Show so I can use

András Kovács proposed this question in response to an answer to a previous question. In a lens-style uniplate library for types of kind * -> * based on the class class Uniplate1 f where uniplate1 :: Applicative m => f a -> (forall b. f b -> m (f b)) -> m (f a) analogous to the class for types of kind * class Uniplate on where uniplate :: Applicative m => on -> (on -> m on) -> m on is it possible to implement analogs to contexts and holes , which both have the type Uniplate on => on -> [(on, on -> on)] without requiring Typeable1 ? It's clear that this could be implemented in the old-style of

This data type can have type role HCons' representational representational , which allows using coerce to add or remove newtypes applied to the elements, without needing to traverse the list. data HNil' = HNil' data HCons' a b = HCons' a b However the syntax for those lists is not as nice as those with the following GADT data HList (l::[*]) where HNil :: HList '[] HCons :: e -> HList l -> HList (e ': l) I have a class to convert between these two representations , such that Prime (HList [a,b]) ~ HCons' a (HCons' b HNil') . Does that class make coerceHList :: Coercible (Prime a) (Prime b) =>