Hello,
Hello all,
Given an HList (http://homepages.cwi.nl/~ralf/HList/) would it be possible to do the following:
Create a class/function/magicks that would essentially do what hOccursMany does, except it would not return a list of elements, but a new HList. For example, would this allow us to be able to write more lax typing constraints and say extract only things that are in lists.
ie) HCons "hi" (HCons [2.2,3.3] (HCons 'a' hNil)) -> HCons "hi" (HCons [2.2,3.3] hNil)
(removing the Char element).
I tried to write something like this but I did not get very far, is it even possible? I'm new to this type-level programming :)
One approach is to write a HList filter function. You need to use type-level bools, type-level apply, and break up the filter function into two parts; you need a second typeclass to discriminate on the HBool which results from applying your predicate to each element of the HList. Below is some code that works for me. -Jeff --------------------------------------------------------- {-# OPTIONS -fglasgow-exts -fallow-undecidable-instances -fallow-overlapping-instances #-} module MyHList where class TypeCast a b | a -> b, b->a where typeCast :: a -> b class TypeCast' t a b | t a -> b, t b -> a where typeCast' :: t->a->b class TypeCast'' t a b | t a -> b, t b -> a where typeCast'' :: t->a->b instance TypeCast' () a b => TypeCast a b where typeCast x = typeCast' () x instance TypeCast'' t a b => TypeCast' t a b where typeCast' = typeCast'' instance TypeCast'' () a a where typeCast'' _ x = x data HNil = HNil deriving (Show, Read, Eq) data HCons e l = HCons e l deriving (Show, Read, Eq) data HTrue = HTrue deriving (Eq, Show) data HFalse = HFalse deriving (Eq, Show) class HApply f e v | f e -> v where hApply :: f -> e -> v -- This HFilter uses an accumulator to avoid using typecast. -- class HFilter acc p l l' | acc p l -> l' where hFilter :: acc -> p -> l -> l' instance HFilter acc p HNil acc where hFilter acc _ _ = acc instance (HApply p x b, HFilter1 b x acc p xs xs') => HFilter acc p (HCons x xs) xs' where hFilter acc p (HCons x xs) = hFilter1 (hApply p x) x acc p xs class HFilter1 b x acc p xs xs' | b x acc p xs -> xs' where hFilter1 :: b -> x -> acc -> p -> xs -> xs' instance HFilter acc p xs xs' => HFilter1 HFalse x acc p xs xs' where hFilter1 _ _ acc p xs = hFilter acc p xs instance HFilter (HCons x acc) p xs xs' => HFilter1 HTrue x acc p xs xs' where hFilter1 _ x acc p xs = hFilter (HCons x acc) p xs -- Here is a specific type-level function to check if something is a list. -- Can't avoid the typeCast here because of functional dependencies on HApply -- data IsList = IsList instance HApply IsList [a] HTrue where hApply _ _ = undefined instance TypeCast HFalse b => HApply (IsList) a b where hApply _ _ = undefined test = hFilter HNil IsList $ HCons "hi" (HCons [2.2,3.3] (HCons 'a' HNil)) --- This e-mail may contain confidential and/or privileged information. If you are not the intended recipient (or have received this e-mail in error) please notify the sender immediately and destroy this e-mail. Any unauthorized copying, disclosure or distribution of the material in this e-mail is strictly forbidden.