>I think you are confusing Dependent Types with Functional Dependencies.
Actually the two are not that dissimilar... If we allow types to depend
on types (which is what Functional Dependencies allow) IE:
class a b | a -> b
instance Int Float
instance Float Int
For example is really a function on the type level mapping a to b. All
that is missing is a way to make types depend on values... which can
be done with dictionary passing. Here is an example:
class ReifyBool t w where
reifyBool :: Prelude.Bool -> t -> w
instance (Apply t AllTrue w,Apply t AllFalse w) => ReifyBool t w where
reifyBool Prelude.True t = apply t AllTrue
reifyBool Prelude.False t = apply t AllFalse
The limitation here is that an 'instance' must exist for each possibility
in the program, so we are limited to a finite range of values... although
we can use type recursion in the class to make the code smaller, we still
must have some limit known at compile time, for example Int:
class (NotNegative m,NotPositive n) => ReifyNotPositive m t i n w where
reifyNotPositive :: Integral i => m -> t -> i -> n -> w
instance NotPositive n => ReifyNotPositive Zero t i n w where
reifyNotPositive _ _ _ _ = error "Number to be reified exceeds maximum range."
instance (NotPositive n,ReifyNotPositive m t i (Pre n) w,Ctrl.Apply t n w)
=> ReifyNotPositive (Suc m) t i n w where
reifyNotPositive (Suc m) t i n
| i<0 = reifyNotPositive m t (i+1) (Pre n)
| otherwise = Ctrl.apply t n
(I appologise if the code is a little verbose, but to avoid mistakes I have
cut and pasted from a working project - but you can see the important
features)...
So by combining reification to a type level representation and functional
dependancies we arrive at dependant types...
Keean./
_______________________________________________
Haskell mailing list
[EMAIL PROTECTED]
http://www.haskell.org/mailman/listinfo/haskell
