gadt

Here's an untyped lambda calculus whose terms are indexed by their free variables. I'm using the singletons library for singleton values of type-level strings. {-# LANGUAGE DataKinds #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-} import Data.Singletons import Data.Singletons.TypeLits data Expr (free :: [Symbol]) where Var :: Sing a -> Expr '[a] Lam :: Sing a -> Expr as -> Expr (Remove a as) App :: Expr free1 -> Expr free2 -> Expr (Union free1 free2) A Var introduces a free variable. A

Suppose I have the following code: {-# LANGUAGE GADTs, DeriveDataTypeable, StandaloneDeriving #-} import Data.Typeable class Eq t => OnlyEq t class (Eq t, Typeable t) => BothEqAndTypeable t data Wrapper a where Wrap :: BothEqAndTypeable a => a -> Wrapper a deriving instance Eq (Wrapper a) deriving instance Typeable1 Wrapper Then, the following instance declaration works, without a constraint on t : instance OnlyEq (Wrapper t) and does what I expect it to do. But the following instance declaration doesn't work: instance BothEqAndTypeable (Wrapper t) since GHC - I'm using 7.6.1 - complains that:

I'm learning about existential quantification, phantom types, and GADTs at the moment. How do I go about creating a heterogeneous list of a data type with a phantom variable? For example: {-# LANGUAGE GADTs #-} {-# LANGUAGE ExistentialQuantification #-} data Toy a where TBool :: Bool -> Toy Bool TInt :: Int -> Toy Int instance Show (Toy a) where show (TBool b) = "TBool " ++ show b show (TInt i) = "TInt " ++ show i bools :: [Toy Bool] bools = [TBool False, TBool True] ints :: [Toy Int] ints = map TInt [0..9] Having functions like below are OK: isBool :: Toy a -> Bool isBool (TBool _) = True

As an exercise I'm trying to recreate Lisp's apply in Haskell. I do not intend to use this for any practical purpose, I just think it's a nice opportunity to get more familiar with Haskell's type system and type systems in general. (So I am also not looking for other people's implementations.) My idea is the following: I can use GADTs to "tag" a list with the type of the function it can be applied to. So, I redefine Nil and Cons in a similar way that we would encode list length in the type using a Nat definition, but instead of using Peano numbers the length is in a way encoded in the tagging

I have an ADT representing the AST for a simple language: data UTerm = UTrue | UFalse | UIf UTerm UTerm UTerm | UZero | USucc UTerm | UIsZero UTerm This data structure can represent invalid terms that don't follow the type rules of the language, like UIsZero UFalse , so I'd like to use a GADT that enforces well-typedness: {-# LANGUAGE GADTs #-} data TTerm a where TTrue :: TTerm Bool TFalse :: TTerm Bool TIf :: TTerm Bool -> TTerm a -> TTerm a -> TTerm a TZero :: TTerm Int TSucc :: TTerm Int -> TTerm Int TIsZero :: TTerm Int -> TTerm Bool My problem is to type check a UTerm and convert it into

I'm covering GADT's using learnyouahaskell and I'm interested in their possible uses. I understand that their main characteristic is allowing explicit type setting. Such as: data Users a where GetUserName :: Int -> Users String GetUserId :: String -> Users Int usersFunction :: Users a -> a usersFunction (GetUserName id) | id == 100 = "Bob" | id == 200 = "Phil" | otherwise = "No corresponding user" usersFunction (GetUserId name) | name == "Bob" = 100 | name == "Phil" = 200 | otherwise = 0 main = do print $ usersFunction (GetUserName 100) Apart from adding additional type safety when working