Bulat Ziganshin bulat.ziganshin at gmail.com
Wed Sep 6 17:35:19 EDT 2006

Hello Manuel,

Wednesday, September 6, 2006, 9:17:46 PM, you wrote:

> So, both features are truly orthogonal and, in fact, they are
> synergetic!  More precisely, an alternative syntax for Löh/Hinze open
> types are overlapping type families.  So, we might define S
> alternatively as

>         data family S :: *
>         data instance S = S1
>         data instance S = S2

to be exact, it's alternative syntax for GADT "data S = S1 | S2"
while open types just allows to split GADT definition into several
chunks. It seems that you skipped this point - they also propose to
use open technique for GADT-style definitions. as a result, while open
data types are truly orthogonal to GADT, together they implement
something very close to type families. the only difference between
GADT+OT vs TF remains:

> GADTS+open types:
>       * Local type-refinement in case alternatives

> Data families:
>       * Type constraints due to indexes is propagated globally

can you please explain that this means?

> In fact, there is nothing essential preventing us from having
> indexed families of GADTs

for why? the only difference is that TF define a one-to-one
relationship (each type index defines just one data constructor) while
GADT define one-to-many relationship (one type index may be mapped to
several data constructors). are we really need this difference and
especially different syntax for such close things?

just for curiosity, i was also interested in ideas of type-level
programming and invented my own syntax that is more like yours.
but really my syntax just based on the syntax of ordinary functions:

type BaseType [a]       = BaseType a
     BaseType (Set a)   = BaseType a
     BaseType (Map a b) = BaseType a
     BaseType a         = a

is a recursive definition which may be evaluated with first-fit or
best-fit strategy

data Expr a    = If (Expr Bool) (Expr a) (Expr a)
     Expr Int  = Zero
     Expr Int  = Succ (Expr Int)
     Expr Bool = TRUE
     Expr Bool = Not (Expr Bool)

is alternative syntax for GADT. we may consider it as multi-value
function, and 'data' defines functions that maps types into data
constructors while 'type' defines functions that maps types into
types. going further, why not allow 'type' to define multi-value
functions? and vice versa, why not use 'data' to define one-to-one
relation by best-fit or first-fit strategy?

going further, why not define type of relation in "function" head? so
that we can both use 'data' and 'type' to define one-to-one
(non-overlapped) type families or one-to-many (overlapped, GADT-style)
ones and even select matching strategy here? for example:

data nonOverlapped T TTrue  = CTrue
                   T TFalse = CFalse

data bestFit Eq a b = CFalse
             Eq a a = CTrue

type firstFit Eq a a = TTrue
              Eq a b = TFalse
Best regards,
 Bulat                            mailto:Bulat.Ziganshin at gmail.com

More information about the Haskell-prime mailing list