On Sat, Aug 8, 2015 at 4:39 PM, Alexey Muranov <alexey.muranov@gmail.com> wrote:
Hello,

i would like to suggest an idea for modifying the basic data/newtype syntax in Haskell: replace the equality sign `=` with `::=`.

When i started learning Haskell, the most confusing part of the syntax for me was the equality sign in `data` definition.  I could not even guess what the `data` definition meant without reading a chapter or two about types in Haskell, and i think it was partially due to the equality sign.  I still find this notation inconsistent with other uses of the equality sign in Haskell and in general.

For example, in

    type Name = String
    data Date = Date Int Int Int
    data Anniversary = Birthday Name Date | Wedding Name Name Date

the second line is particularly disorienting IMO because on two sides of the equality, `Date` denotes different things.

As far as i understand, in all contexts except those of `data` and `newtype` definitions, the equality sign in Haskell denotes the actual equality for all purposes: if a line

    foo x y = bar y x

is present in a program, `foo a b` and `bar b a` can be used more or less interchangeably elsewhere in the program.  Similarly, if the line

    type Name = String

is present, `Name` can be used as `String`.  Clearly, the equality in

    data Date = Date Int Int Int

does not have such property.

I think that if `::=` was used instead of `=` in `data` and `newtype` definitions, this would suggest  to a newcomer that the syntax of the two sides might be different, and would helpfully remind of the Backus–Naur Form for syntax rules.  I think that a newcomer to Haskell, like myself, would have had a better chance of guessing the meaning of

    type Name = String
    data Date ::= Date Int Int Int
    data Anniversary ::= Birthday Name Date | Wedding Name Name Date

IMO this would make the program easier to read in general and the difference between `type` and `newtype` more clear.  Maybe the can even make the use of keywords redundant, by allowing to write simply

    Name = String
    Date ::= Date Int Int Int
    Anniversary ::= Birthday Name Date | Wedding Name Name Date

What do you think?


I taught functional programming (with gofer) some decades ago.
I found some of your points (and some more) slowed down students sufficiently that making small changes in gofer was worth the effort
The appendix at end summarises the changes.

Note that the ctype keyword (concrete-type) as replacement for 'data' predates GADT by about a decade though I came to it from a pedagogy not a generality angle


If someone wants to try it, this modified gofer is at https://github.com/rusimody/gofer

Note: I am really not entering the debate that Haskell should be changed

Regards
Rusi