[Haskell-cafe] an idea for modifiyng data/newtype syntax: use `::=` instead of `=`

[Rustom Mody]

On Sat, Aug 8, 2015 at 4:39 PM, Alexey Muranov <alexey.muranov at 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
My changes are described here
http://www.the-magus.in/Publications/notation.pdf
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

-- 
http://www.the-magus.in
http://blog.languager.org
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20150821/62883a96/attachment.html>