Is there a way to limit the type of connection?

Question

In Haskell, is there an OR method in conjunction with several type constraints, so that joining is done if any of them are?

For example, suppose I had a GADT parameter specified by the DataKind parameter, and I wanted some constructors to return values ​​only for specific constructors of this type, the pseudo-Haskell:

 {-# LANGUAGE GADTs #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE DataKinds #-} module Temp where data Color = White | Red | Blue | Yellow | Green | Tawny | Purple | Black data Fruit (c :: Color) where Banana :: (c ~ Green | c ~ Yellow | c ~ Black) => Fruit c Apple :: (c ~ Red | c ~ Green ) => Fruit c Grape :: (c ~ Red | c ~ Green | c ~ White) => Fruit c Orange :: (c ~ Tawny ) => Fruit c 

I can try to implement OR using cool classes:

 {-# LANGUAGE GADTs #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE DataKinds #-} module Temp where data Color = White | Red | Blue | Yellow | Green | Tawny | Purple | Black data Fruit (c :: Color) where Banana :: BananaColor c => Fruit c Apple :: AppleColor c => Fruit c Grape :: GrapeColor c => Fruit c Orange :: OrangeColor c => Fruit c class BananaColor (c :: Color) instance BananaColor Green instance BananaColor Yellow instance BananaColor Black class AppleColor (c :: Color) instance AppleColor Red instance AppleColor Green class GrapeColor (c :: Color) instance GrapeColor Red instance GrapeColor Green instance GrapeColor White class OrangeColor (c :: Color) instance OrangeColor Tawny 

But not only is it verbose, but also slightly different from what I intended in that the original union was closed, but all classes are open. Nothing prevents anyone from identifying

 instance OrangeColor Blue 

And since it is open, the compiler cannot conclude that [Apple, Grape, Banana] should be of type [Fruit Green] , if not specified.

Answer 1

I can’t think of a way to literally implement either for Constraint s, unfortunately, but if we just combine the equalities, as in your example, we can tweak your approach to the class of classes and make it closed by type families and raised Booleans. This will only work in GHC 7.6 and above; at the end, I mentioned how it would be better in GHC 7.8 and how to do it in GHC 7.4.

The idea is this: just as we could declare a value level function isBananaColor :: Color -> Bool , we can also declare a level function like isBananaColor :: Color -> Bool :

 type family IsBananaColor (c :: Color) :: Bool type instance IsBananaColor Green = True type instance IsBananaColor Yellow = True type instance IsBananaColor Black = True type instance IsBananaColor White = False type instance IsBananaColor Red = False type instance IsBananaColor Blue = False type instance IsBananaColor Tawny = False type instance IsBananaColor Purple = False 

If we like, we can even add

 type BananaColor c = IsBananaColor c ~ True 

Then we repeat this for each color of the fruit and define Fruit as in your second example:

 {-# LANGUAGE GADTs #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE TypeFamilies #-} data Color = White | Red | Blue | Yellow | Green | Tawny | Purple | Black data Fruit (c :: Color) where Banana :: BananaColor c => Fruit c Apple :: AppleColor c => Fruit c Grape :: GrapeColor c => Fruit c Orange :: OrangeColor c => Fruit c type family IsBananaColor (c :: Color) :: Bool type instance IsBananaColor Green = True type instance IsBananaColor Yellow = True type instance IsBananaColor Black = True type instance IsBananaColor White = False type instance IsBananaColor Red = False type instance IsBananaColor Blue = False type instance IsBananaColor Tawny = False type instance IsBananaColor Purple = False type BananaColor c = IsBananaColor c ~ True type family IsAppleColor (c :: Color) :: Bool type instance IsAppleColor Red = True type instance IsAppleColor Green = True type instance IsAppleColor White = False type instance IsAppleColor Blue = False type instance IsAppleColor Yellow = False type instance IsAppleColor Tawny = False type instance IsAppleColor Purple = False type instance IsAppleColor Black = False type AppleColor c = IsAppleColor c ~ True type family IsGrapeColor (c :: Color) :: Bool type instance IsGrapeColor Red = True type instance IsGrapeColor Green = True type instance IsGrapeColor White = True type instance IsGrapeColor Blue = False type instance IsGrapeColor Yellow = False type instance IsGrapeColor Tawny = False type instance IsGrapeColor Purple = False type instance IsGrapeColor Black = False type GrapeColor c = IsGrapeColor c ~ True -- For consistency type family IsOrangeColor (c :: Color) :: Bool type instance IsOrangeColor Tawny = True type instance IsOrangeColor White = False type instance IsOrangeColor Red = False type instance IsOrangeColor Blue = False type instance IsOrangeColor Yellow = False type instance IsOrangeColor Green = False type instance IsOrangeColor Purple = False type instance IsOrangeColor Black = False type OrangeColor c = IsOrangeColor c ~ True 

(If you want, you can get rid of the -XConstraintKinds and type XYZColor c = IsXYZColor c ~ True types and simply define Fruit constructors as XYZ :: IsXYZColor c ~ True => Fruit c .)

Now, what are you buying, and that he is not buying you? On the positive side, you get the opportunity to determine your type the way you want, which is definitely a victory; and since Color closed, no one can add more instances of the instance family and violate this.

However, there are also disadvantages. You will not get the conclusion you want to tell you automatically that [Apple, Grape, Banana] is of type Fruit Green ; what's worse is that [Apple, Grape, Banana] is a valid type (AppleColor c, GrapeColor c, BananaColor c) => [Fruit c] . Yes, there is no way to monomorphize this, but the GHC cannot understand this. To be completely honest, I can’t imagine what solution these properties will give you, although I’m always ready to be surprised. Another obvious problem with this solution is how long it takes: you need to define all eight color cases for each IsXYZColor type IsXYZColor ! (Using a new type of family for each is also annoying, but inevitable with decisions of this form.)

---

I mentioned above that GHC 7.8 will do it better; this will be done by eliminating the need to list each individual case for each individual IsXYZColor class. How? Well, Richard Eisenberg et al. Introduced closed overlapping ordered type families in the GHC HEAD, and it will be available in 7.8. There's a document entitled POPL 2014 (and an extended version ) on this topic, and Richard also wrote an introductory blog post (looks like outdated syntax).

The idea is to allow type instances of types to be declared as ordinary functions: all equations must be declared in one place (excluding the open world assumption) and checked in order, which allows overlapping. Sort of

 type family IsBananaColor (c :: Color) :: Bool type instance IsBananaColor Green = True type instance IsBananaColor Yellow = True type instance IsBananaColor Black = True type instance IsBananaColor c = False 

ambiguous, because IsBananaColor Green corresponds to both the first and last equations; but in a normal function, it will work fine. So the new syntax is:

 type family IsBananaColor (c :: Color) :: Bool where IsBananaColor Green = True IsBananaColor Yellow = True IsBananaColor Black = True IsBananaColor c = False 

This type family ... where { ... } block defines a type family the way you want to define it; it signals that this type family is closed, ordered, and overlapping, as described above. Thus, the code in GHC 7.8 will look like this: (unverified since it is not installed on my machine):

 {-# LANGUAGE GADTs #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE TypeFamilies #-} data Color = White | Red | Blue | Yellow | Green | Tawny | Purple | Black data Fruit (c :: Color) where Banana :: IsBananaColor c ~ True => Fruit c Apple :: IsAppleColor c ~ True => Fruit c Grape :: IsGrapeColor c ~ True => Fruit c Orange :: IsOrangeColor c ~ True => Fruit c type family IsBananaColor (c :: Color) :: Bool where IsBananaColor Green = True IsBananaColor Yellow = True IsBananaColor Black = True IsBananaColor c = False type family IsAppleColor (c :: Color) :: Bool where IsAppleColor Red = True IsAppleColor Green = True IsAppleColor c = False type IsGrapeColor (c :: Color) :: Bool where IsGrapeColor Red = True IsGrapeColor Green = True IsGrapeColor White = True IsGrapeColor c = False type family IsOrangeColor (c :: Color) :: Bool where IsOrangeColor Tawny = True IsOrangeColor c = False 

Hooray, we can read it without falling asleep from boredom! In fact, you will notice that I switched to the explicit version of IsXYZColor c ~ True for this code; I did this because, because the template for the additional four synonyms became much more obvious and annoying with these shorter definitions!

---

However, release in the opposite direction and make this code more ugly. What for? Well, GHC 7.4 (which, alas, I still have on my machine) does not support type families with a result type not * . What can we do instead? We can use type classes and functional dependencies to fake. The idea is that instead of isBananaColor :: Color -> Bool we have a class like IsBananaColor :: Color -> Bool -> Constraint , and we add a functional color dependency to a Boolean. Then IsBananaColor cb doable if and only if IsBananaColor c ~ b in a more pleasant version; because Color is closed, and we have a functional dependence on it, it still gives us the same properties that it is just more ugly (although mostly conceptual). Without further ado, full code:

 {-# LANGUAGE GADTs #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE FunctionalDependencies #-} {-# LANGUAGE FlexibleContexts #-} data Color = White | Red | Blue | Yellow | Green | Tawny | Purple | Black data Fruit (c :: Color) where Banana :: BananaColor c => Fruit c Apple :: AppleColor c => Fruit c Grape :: GrapeColor c => Fruit c Orange :: OrangeColor c => Fruit c class IsBananaColor (c :: Color) (b :: Bool) | c -> b instance IsBananaColor Green True instance IsBananaColor Yellow True instance IsBananaColor Black True instance IsBananaColor White False instance IsBananaColor Red False instance IsBananaColor Blue False instance IsBananaColor Tawny False instance IsBananaColor Purple False type BananaColor c = IsBananaColor c True class IsAppleColor (c :: Color) (b :: Bool) | c -> b instance IsAppleColor Red True instance IsAppleColor Green True instance IsAppleColor White False instance IsAppleColor Blue False instance IsAppleColor Yellow False instance IsAppleColor Tawny False instance IsAppleColor Purple False instance IsAppleColor Black False type AppleColor c = IsAppleColor c True class IsGrapeColor (c :: Color) (b :: Bool) | c -> b instance IsGrapeColor Red True instance IsGrapeColor Green True instance IsGrapeColor White True instance IsGrapeColor Blue False instance IsGrapeColor Yellow False instance IsGrapeColor Tawny False instance IsGrapeColor Purple False instance IsGrapeColor Black False type GrapeColor c = IsGrapeColor c True class IsOrangeColor (c :: Color) (b :: Bool) | c -> b instance IsOrangeColor Tawny True instance IsOrangeColor White False instance IsOrangeColor Red False instance IsOrangeColor Blue False instance IsOrangeColor Yellow False instance IsOrangeColor Green False instance IsOrangeColor Purple False instance IsOrangeColor Black False type OrangeColor c = IsOrangeColor c True 

Answer 2

Below is my attempt to code the problem. The basic idea is to represent fruits as a type class and various types of fruits as types that implement this type of class

 data Color = White | Red | Blue | Yellow | Green | Tawny | Purple | Black class Fruit a where getColor :: a -> Color data Banana where GreenBanana :: Banana YellowBanana :: Banana BlackBanana :: Banana instance Fruit Banana where getColor GreenBanana = Green getColor YellowBanana = Yellow getColor BlackBanana = Black data Apple where GreenApple :: Apple RedApple :: Apple instance Fruit Apple where getColor GreenApple = Green getColor RedApple = Red 

Your last line of questions says that you want something like [Fruit Green] , which obviously means that Fruit Green should be a type where the value constructor value is used in the code above. We need to make Green as a type, as shown below:

 data Red = Red data Green = Green data Black = Black data Fruit c where GreenBanana :: Fruit Green BlackBanana :: Fruit Black RedApple :: Fruit Red GreenApple :: Fruit Green greenFruits :: [Fruit Green] greenFruits = [GreenBanana, GreenApple]