From varosi at gmail.com  Sun Apr 16 12:37:38 2017
From: varosi at gmail.com (Vassil Ognyanov Keremidchiev)
Date: Sun, 16 Apr 2017 15:37:38 +0300
Subject: Haskell 2020: 'let' to be optional and with wider scope of
 visibility, like other Haskell functions
Message-ID: <CAGaP9kuE89hbrAdYD8-f6A9ei=NHfGRLP+Pub-sj=7BwiRutUg@mail.gmail.com>

Hello!

A small proposition for the next standard.
1) It is to lower verbosity with omitting 'let' keyword in do-notation and
use only (=) for describing let/pure blocks.
Example:

currently:

main = do
     let x = expression1...
     let y = expression2...
     z <- action1
     putStrLn (x ++ y ++ z)

It could be made less verbose currently with putting x and y in the same
'let' block:

main = do
     let x = expression1...
         y = expression2...
     z <- action1
     putStrLn (x ++ y ++ z)

But what if we use (=) for describing different expressions in do-block.

main = do
     x = expression1...
     y = expression2...
     z <- action1
     putStrLn (x ++ y ++ z)

So pure 'let' expressions to use (=) for assignment and monadic actions use
(<-) for execution/chaining. If 'let' is optional - this proposition will
be backward compatible.

2) Second proposition is every pure expression ('let') in do-block to have
visibility in whole block, just like top-level function is visible in whole
module. Currently there is difference in visibility depending on that if a
function is in do-block or is outside it.
Example:

main = do
     z <- action x
     x = expression1 y
     y = expression2

     putStrLn (x ++ y ++ z)

Best regards,
Vassil Keremidchiev
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-prime/attachments/20170416/21fcffa6/attachment.html>

From svenpanne at gmail.com  Sun Apr 16 15:10:22 2017
From: svenpanne at gmail.com (Sven Panne)
Date: Sun, 16 Apr 2017 17:10:22 +0200
Subject: Haskell 2020: 'let' to be optional and with wider scope of
 visibility, like other Haskell functions
In-Reply-To: <CAGaP9kuE89hbrAdYD8-f6A9ei=NHfGRLP+Pub-sj=7BwiRutUg@mail.gmail.com>
References: <CAGaP9kuE89hbrAdYD8-f6A9ei=NHfGRLP+Pub-sj=7BwiRutUg@mail.gmail.com>
Message-ID: <CANBN=muUBY-wi5GEUNZgkDx=Bdwnn1U2WuLDb1wsPLJpKioFvw@mail.gmail.com>

2017-04-16 14:37 GMT+02:00 Vassil Ognyanov Keremidchiev <varosi at gmail.com>:

> A small proposition for the next standard.
>

I think every proposal should clearly state the problem it is trying to
solve first, because only after there's some agreement that it is actually
a problem, further discussion is useful.


> 1) It is to lower verbosity with omitting 'let' keyword in do-notation and
> use only (=) for describing let/pure blocks. [...]
>

As has been discussed quite a few times on this and other Haskell-related
lists, "verbosity" is a very subjective measure, and the number of
characters to type is one of the worst metrics for evaluating the
usefulness of a feature.

In our example at hand, "let" is a very useful syntactic cue, and the
visual difference between "x = foo" and "x <- foo" is a bit low IMHO. One
can probably remove a lot of other syntactic stuff from Haskell and still
keep it parsable by machines, but I think that's a non-goal. Remember that
e.g. the entropy of English text is around 1 bit per character, but we
don't speak binary, for a good reason. :-)

2) Second proposition is every pure expression ('let') in do-block to have
> visibility in whole block, just like top-level function is visible in whole
> module. Currently there is difference in visibility depending on that if a
> function is in do-block or is outside it.
>

I think the difference is there for a good reason: The desugaring rules are
easy to comprehend. With your proposal things get complicated. Take e.g. a
slightly modified version of your example (which can easily be complicated
much more by alternating the different forms of bindings):


> main = do
>      z <- action x
>      x = expression1 y
>      y = expression2 z
>
>      putStrLn (x ++ y ++ z)
>

What is the meaning of this? And what problem exactly is this part of the
proposal trying to solve?
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-prime/attachments/20170416/dc65df7a/attachment.html>

From varosi at gmail.com  Sun Apr 16 15:21:39 2017
From: varosi at gmail.com (Vassil Ognyanov Keremidchiev)
Date: Sun, 16 Apr 2017 18:21:39 +0300
Subject: Haskell 2020: 'let' to be optional and with wider scope of
 visibility, like other Haskell functions
In-Reply-To: <CANBN=muUBY-wi5GEUNZgkDx=Bdwnn1U2WuLDb1wsPLJpKioFvw@mail.gmail.com>
References: <CAGaP9kuE89hbrAdYD8-f6A9ei=NHfGRLP+Pub-sj=7BwiRutUg@mail.gmail.com>
 <CANBN=muUBY-wi5GEUNZgkDx=Bdwnn1U2WuLDb1wsPLJpKioFvw@mail.gmail.com>
Message-ID: <CAGaP9ku2Nv2-66583gV4nKbS+70XZe=-bVNpR1XUEsRZbLFFcA@mail.gmail.com>

1) It's not a problem, it's a improvement in syntax with lowering
verbosity. It's similar with the difference between Pascal and C syntax.
One of the reasons we all love Haskell is because it's not so verbose. I
have asked often why do-block is so different, than non-do-block.
Exchanging "x = foo" with "x <- foo" will result in error, so there is no
problem that the difference is small.

2) you're right. May be lazyness could solve that? I'm not sure here.

2017-04-16 18:10 GMT+03:00 Sven Panne <svenpanne at gmail.com>:

> 2017-04-16 14:37 GMT+02:00 Vassil Ognyanov Keremidchiev <varosi at gmail.com>
> :
>
>> A small proposition for the next standard.
>>
>
> I think every proposal should clearly state the problem it is trying to
> solve first, because only after there's some agreement that it is actually
> a problem, further discussion is useful.
>
>
>> 1) It is to lower verbosity with omitting 'let' keyword in do-notation
>> and use only (=) for describing let/pure blocks. [...]
>>
>
> As has been discussed quite a few times on this and other Haskell-related
> lists, "verbosity" is a very subjective measure, and the number of
> characters to type is one of the worst metrics for evaluating the
> usefulness of a feature.
>
> In our example at hand, "let" is a very useful syntactic cue, and the
> visual difference between "x = foo" and "x <- foo" is a bit low IMHO. One
> can probably remove a lot of other syntactic stuff from Haskell and still
> keep it parsable by machines, but I think that's a non-goal. Remember that
> e.g. the entropy of English text is around 1 bit per character, but we
> don't speak binary, for a good reason. :-)
>
> 2) Second proposition is every pure expression ('let') in do-block to have
>> visibility in whole block, just like top-level function is visible in whole
>> module. Currently there is difference in visibility depending on that if a
>> function is in do-block or is outside it.
>>
>
> I think the difference is there for a good reason: The desugaring rules
> are easy to comprehend. With your proposal things get complicated. Take
> e.g. a slightly modified version of your example (which can easily be
> complicated much more by alternating the different forms of bindings):
>
>
>> main = do
>>      z <- action x
>>      x = expression1 y
>>      y = expression2 z
>>
>>      putStrLn (x ++ y ++ z)
>>
>
> What is the meaning of this? And what problem exactly is this part of the
> proposal trying to solve?
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-prime/attachments/20170416/931bc9bd/attachment.html>

From finn at gundersen.net  Sun Apr 16 16:23:34 2017
From: finn at gundersen.net (Finn Espen Gundersen)
Date: Sun, 16 Apr 2017 18:23:34 +0200
Subject: SV: Re: Haskell 2020: 'let' to be optional and with wider scope of
 visibility, like other Haskell functions
In-Reply-To: <CANBN=muUBY-wi5GEUNZgkDx=Bdwnn1U2WuLDb1wsPLJpKioFvw@mail.gmail.com>
References: <CAGaP9kuE89hbrAdYD8-f6A9ei=NHfGRLP+Pub-sj=7BwiRutUg@mail.gmail.com>
 <CANBN=muUBY-wi5GEUNZgkDx=Bdwnn1U2WuLDb1wsPLJpKioFvw@mail.gmail.com>
Message-ID: <vu4cr3phert6ip6ct9o4llnp.1492359814543@email.android.com>

I like this proposition. I am not sure how to argue in favour as the measure is almost purely adressing an issue of esthetics. But I do like it, and I also find the comparison between C and Pascal relevant. I guess a patch or pull request will be the best way to move forward and shake some relevant problems out of the woodwork. Be known as the guy who removed let, go for it.

:: Finn Espen Gundersen (fra mobil)

---- Sven Panne skrev ----

>2017-04-16 14:37 GMT+02:00 Vassil Ognyanov Keremidchiev <varosi at gmail.com>:
>
>> A small proposition for the next standard.
>>
>
>I think every proposal should clearly state the problem it is trying to
>solve first, because only after there's some agreement that it is actually
>a problem, further discussion is useful.
>
>
>> 1) It is to lower verbosity with omitting 'let' keyword in do-notation and
>> use only (=) for describing let/pure blocks. [...]
>>
>
>As has been discussed quite a few times on this and other Haskell-related
>lists, "verbosity" is a very subjective measure, and the number of
>characters to type is one of the worst metrics for evaluating the
>usefulness of a feature.
>
>In our example at hand, "let" is a very useful syntactic cue, and the
>visual difference between "x = foo" and "x <- foo" is a bit low IMHO. One
>can probably remove a lot of other syntactic stuff from Haskell and still
>keep it parsable by machines, but I think that's a non-goal. Remember that
>e.g. the entropy of English text is around 1 bit per character, but we
>don't speak binary, for a good reason. :-)
>
>2) Second proposition is every pure expression ('let') in do-block to have
>> visibility in whole block, just like top-level function is visible in whole
>> module. Currently there is difference in visibility depending on that if a
>> function is in do-block or is outside it.
>>
>
>I think the difference is there for a good reason: The desugaring rules are
>easy to comprehend. With your proposal things get complicated. Take e.g. a
>slightly modified version of your example (which can easily be complicated
>much more by alternating the different forms of bindings):
>
>
>> main = do
>>      z <- action x
>>      x = expression1 y
>>      y = expression2 z
>>
>>      putStrLn (x ++ y ++ z)
>>
>
>What is the meaning of this? And what problem exactly is this part of the
>proposal trying to solve?
>
>_______________________________________________
>Haskell-prime mailing list
>Haskell-prime at haskell.org
>http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-prime
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-prime/attachments/20170416/8e1415b9/attachment-0001.html>

From svenpanne at gmail.com  Sun Apr 16 17:04:17 2017
From: svenpanne at gmail.com (Sven Panne)
Date: Sun, 16 Apr 2017 19:04:17 +0200
Subject: Haskell 2020: 'let' to be optional and with wider scope of
 visibility, like other Haskell functions
In-Reply-To: <CAGaP9ku2Nv2-66583gV4nKbS+70XZe=-bVNpR1XUEsRZbLFFcA@mail.gmail.com>
References: <CAGaP9kuE89hbrAdYD8-f6A9ei=NHfGRLP+Pub-sj=7BwiRutUg@mail.gmail.com>
 <CANBN=muUBY-wi5GEUNZgkDx=Bdwnn1U2WuLDb1wsPLJpKioFvw@mail.gmail.com>
 <CAGaP9ku2Nv2-66583gV4nKbS+70XZe=-bVNpR1XUEsRZbLFFcA@mail.gmail.com>
Message-ID: <CANBN=mu5Ea7b8fXZDoMB+m-LLBMmYOh+ps14nC1JLEuiW6JM4Q@mail.gmail.com>

2017-04-16 17:21 GMT+02:00 Vassil Ognyanov Keremidchiev <varosi at gmail.com>:

> 1) It's not a problem, it's a improvement in syntax with lowering
> verbosity.
>

If it's not a real problem, it probably shouldn't be done: Every tiny
change in the syntax, even if it's somehow backwards compatible, has a high
cost in the whole ecosystem: The compiler has to be changed (probably by
far the easiest part), libraries for parsing/pretty-printing Haskell have
to be adapted, Editors/syntax highlighting rules have to be changed,
books/tutorials have to be rewritten and people have to be retrained (yes,
even if they don't use the new syntax: others might use it). To outweigh
this pain, there should be be a real gain, saving just 4 keystrokes isn't
worth it. And for me, and probably others, it's not an improvement in
syntax, it actually makes things worse by removing a syntactic cue.


> It's similar with the difference between Pascal and C syntax. One of the
> reasons we all love Haskell is because it's not so verbose.
>

I think it's actually not the non-verbosity which makes Haskell attractive,
it's its expressiveness. These are two quite different things.


> I have asked often why do-block is so different, than non-do-block.
>

Because it is fundamentally different from the rest, having a sequential
nature (for some meaning of "sequential" given by the underlying monad).


> Exchanging "x = foo" with "x <- foo" will result in error, so there is no
> problem that the difference is small.
>

Of course a machine will see the difference easily and immediately, the
question is: Will people do so, too?


> 2) you're right. May be lazyness could solve that? I'm not sure here.
>

So what are the desugaring rules for your proposal? I have the gut feeling
that they will be quite a bit more complicated and non-local than the
current ones. Remember the famous quote:

   "If you can't explain it to a six year old, you don't understand it
yourself."

;-)
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-prime/attachments/20170416/1fedd15c/attachment.html>

From varosi at gmail.com  Sun Apr 16 17:21:43 2017
From: varosi at gmail.com (Vassil Ognyanov Keremidchiev)
Date: Sun, 16 Apr 2017 20:21:43 +0300
Subject: Haskell 2020: 'let' to be optional and with wider scope of
 visibility, like other Haskell functions
In-Reply-To: <CANBN=mu5Ea7b8fXZDoMB+m-LLBMmYOh+ps14nC1JLEuiW6JM4Q@mail.gmail.com>
References: <CAGaP9kuE89hbrAdYD8-f6A9ei=NHfGRLP+Pub-sj=7BwiRutUg@mail.gmail.com>
 <CANBN=muUBY-wi5GEUNZgkDx=Bdwnn1U2WuLDb1wsPLJpKioFvw@mail.gmail.com>
 <CAGaP9ku2Nv2-66583gV4nKbS+70XZe=-bVNpR1XUEsRZbLFFcA@mail.gmail.com>
 <CANBN=mu5Ea7b8fXZDoMB+m-LLBMmYOh+ps14nC1JLEuiW6JM4Q@mail.gmail.com>
Message-ID: <CAGaP9ktUGyfLZNgvJO8t00wrC+S7ZJd8=eBLAAisMEx_TNAiiQ@mail.gmail.com>

Okay, sorry for taking your time about those propositions. I'm just
thinking of ways for improving future Haskell. My feedback is mostly from
talking with people and trying to teach them in Haskell.

2017-04-16 20:04 GMT+03:00 Sven Panne <svenpanne at gmail.com>:

> 2017-04-16 17:21 GMT+02:00 Vassil Ognyanov Keremidchiev <varosi at gmail.com>
> :
>
>> 1) It's not a problem, it's a improvement in syntax with lowering
>> verbosity.
>>
>
> If it's not a real problem, it probably shouldn't be done: Every tiny
> change in the syntax, even if it's somehow backwards compatible, has a high
> cost in the whole ecosystem: The compiler has to be changed (probably by
> far the easiest part), libraries for parsing/pretty-printing Haskell have
> to be adapted, Editors/syntax highlighting rules have to be changed,
> books/tutorials have to be rewritten and people have to be retrained (yes,
> even if they don't use the new syntax: others might use it). To outweigh
> this pain, there should be be a real gain, saving just 4 keystrokes isn't
> worth it. And for me, and probably others, it's not an improvement in
> syntax, it actually makes things worse by removing a syntactic cue.
>
>
>> It's similar with the difference between Pascal and C syntax. One of the
>> reasons we all love Haskell is because it's not so verbose.
>>
>
> I think it's actually not the non-verbosity which makes Haskell
> attractive, it's its expressiveness. These are two quite different things.
>
>
>> I have asked often why do-block is so different, than non-do-block.
>>
>
> Because it is fundamentally different from the rest, having a sequential
> nature (for some meaning of "sequential" given by the underlying monad).
>
>
>> Exchanging "x = foo" with "x <- foo" will result in error, so there is no
>> problem that the difference is small.
>>
>
> Of course a machine will see the difference easily and immediately, the
> question is: Will people do so, too?
>
>
>> 2) you're right. May be lazyness could solve that? I'm not sure here.
>>
>
> So what are the desugaring rules for your proposal? I have the gut feeling
> that they will be quite a bit more complicated and non-local than the
> current ones. Remember the famous quote:
>
>    "If you can't explain it to a six year old, you don't understand it
> yourself."
>
> ;-)
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-prime/attachments/20170416/fc7c150e/attachment.html>

From fa-ml at ariis.it  Sun Apr 16 18:15:28 2017
From: fa-ml at ariis.it (Francesco Ariis)
Date: Sun, 16 Apr 2017 20:15:28 +0200
Subject: Haskell 2020: 'let' to be optional and with wider scope of
 visibility, like other Haskell functions
In-Reply-To: <CAGaP9ktUGyfLZNgvJO8t00wrC+S7ZJd8=eBLAAisMEx_TNAiiQ@mail.gmail.com>
References: <CAGaP9kuE89hbrAdYD8-f6A9ei=NHfGRLP+Pub-sj=7BwiRutUg@mail.gmail.com>
 <CANBN=muUBY-wi5GEUNZgkDx=Bdwnn1U2WuLDb1wsPLJpKioFvw@mail.gmail.com>
 <CAGaP9ku2Nv2-66583gV4nKbS+70XZe=-bVNpR1XUEsRZbLFFcA@mail.gmail.com>
 <CANBN=mu5Ea7b8fXZDoMB+m-LLBMmYOh+ps14nC1JLEuiW6JM4Q@mail.gmail.com>
 <CAGaP9ktUGyfLZNgvJO8t00wrC+S7ZJd8=eBLAAisMEx_TNAiiQ@mail.gmail.com>
Message-ID: <20170416181528.GA5277@casa.casa>

On Sun, Apr 16, 2017 at 08:21:43PM +0300, Vassil Ognyanov Keremidchiev wrote:
> Okay, sorry for taking your time about those propositions. I'm just
> thinking of ways for improving future Haskell. My feedback is mostly from
> talking with people and trying to teach them in Haskell.

As others, I am not convinced with the proposal (given the amount of
boxes marked "Translation" in the Haskell report, I wish we had a
standard way to handling syntactic rewrites; it could come handy in
yours and many more cases).

But I am interested in newcomers and their introduction to the language:
did they get confused by `let` or just pointed it out as superfluous?


From varosi at gmail.com  Sun Apr 16 20:32:55 2017
From: varosi at gmail.com (Vassil Ognyanov Keremidchiev)
Date: Sun, 16 Apr 2017 23:32:55 +0300
Subject: Haskell 2020: 'let' to be optional and with wider scope of
 visibility, like other Haskell functions
In-Reply-To: <20170416181528.GA5277@casa.casa>
References: <CAGaP9kuE89hbrAdYD8-f6A9ei=NHfGRLP+Pub-sj=7BwiRutUg@mail.gmail.com>
 <CANBN=muUBY-wi5GEUNZgkDx=Bdwnn1U2WuLDb1wsPLJpKioFvw@mail.gmail.com>
 <CAGaP9ku2Nv2-66583gV4nKbS+70XZe=-bVNpR1XUEsRZbLFFcA@mail.gmail.com>
 <CANBN=mu5Ea7b8fXZDoMB+m-LLBMmYOh+ps14nC1JLEuiW6JM4Q@mail.gmail.com>
 <CAGaP9ktUGyfLZNgvJO8t00wrC+S7ZJd8=eBLAAisMEx_TNAiiQ@mail.gmail.com>
 <20170416181528.GA5277@casa.casa>
Message-ID: <CAGaP9kuGKDtf6BqhiW6EHT19o9FQu4etKDWvZYmDvHMGb2ShLQ@mail.gmail.com>

They are confused about when one should put "let x = ..." or "x <- ..."
mostly before they learn what is monad.

2017-04-16 21:15 GMT+03:00 Francesco Ariis <fa-ml at ariis.it>:

> On Sun, Apr 16, 2017 at 08:21:43PM +0300, Vassil Ognyanov Keremidchiev
> wrote:
> > Okay, sorry for taking your time about those propositions. I'm just
> > thinking of ways for improving future Haskell. My feedback is mostly from
> > talking with people and trying to teach them in Haskell.
>
> As others, I am not convinced with the proposal (given the amount of
> boxes marked "Translation" in the Haskell report, I wish we had a
> standard way to handling syntactic rewrites; it could come handy in
> yours and many more cases).
>
> But I am interested in newcomers and their introduction to the language:
> did they get confused by `let` or just pointed it out as superfluous?
>
> _______________________________________________
> Haskell-prime mailing list
> Haskell-prime at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-prime
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-prime/attachments/20170416/1432fea4/attachment.html>

From mike at barrucadu.co.uk  Sun Apr 16 22:56:24 2017
From: mike at barrucadu.co.uk (Michael Walker)
Date: Sun, 16 Apr 2017 23:56:24 +0100
Subject: Haskell 2020: 'let' to be optional and with wider scope of
 visibility, like other Haskell functions
In-Reply-To: <CAGaP9kuGKDtf6BqhiW6EHT19o9FQu4etKDWvZYmDvHMGb2ShLQ@mail.gmail.com>
References: <CAGaP9kuE89hbrAdYD8-f6A9ei=NHfGRLP+Pub-sj=7BwiRutUg@mail.gmail.com>
 <CANBN=muUBY-wi5GEUNZgkDx=Bdwnn1U2WuLDb1wsPLJpKioFvw@mail.gmail.com>
 <CAGaP9ku2Nv2-66583gV4nKbS+70XZe=-bVNpR1XUEsRZbLFFcA@mail.gmail.com>
 <CANBN=mu5Ea7b8fXZDoMB+m-LLBMmYOh+ps14nC1JLEuiW6JM4Q@mail.gmail.com>
 <CAGaP9ktUGyfLZNgvJO8t00wrC+S7ZJd8=eBLAAisMEx_TNAiiQ@mail.gmail.com>
 <20170416181528.GA5277@casa.casa>
 <CAGaP9kuGKDtf6BqhiW6EHT19o9FQu4etKDWvZYmDvHMGb2ShLQ@mail.gmail.com>
Message-ID: <CAOOzCW67Ym3c8z_uXPOM58UDzg8AJfByW0nys9TDGz-f8cTBfA@mail.gmail.com>

I feel that if people are confused about whether to use "let x = ..."
or "x <- ...", changing the syntax to remove the "let" won't help.

On 16 April 2017 at 21:32, Vassil Ognyanov Keremidchiev
<varosi at gmail.com> wrote:
> They are confused about when one should put "let x = ..." or "x <- ..."
> mostly before they learn what is monad.
>
> 2017-04-16 21:15 GMT+03:00 Francesco Ariis <fa-ml at ariis.it>:
>>
>> On Sun, Apr 16, 2017 at 08:21:43PM +0300, Vassil Ognyanov Keremidchiev
>> wrote:
>> > Okay, sorry for taking your time about those propositions. I'm just
>> > thinking of ways for improving future Haskell. My feedback is mostly
>> > from
>> > talking with people and trying to teach them in Haskell.
>>
>> As others, I am not convinced with the proposal (given the amount of
>> boxes marked "Translation" in the Haskell report, I wish we had a
>> standard way to handling syntactic rewrites; it could come handy in
>> yours and many more cases).
>>
>> But I am interested in newcomers and their introduction to the language:
>> did they get confused by `let` or just pointed it out as superfluous?
>>
>> _______________________________________________
>> Haskell-prime mailing list
>> Haskell-prime at haskell.org
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-prime
>
>
>
> _______________________________________________
> Haskell-prime mailing list
> Haskell-prime at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-prime
>



-- 
Michael Walker (http://www.barrucadu.co.uk)

From adam at bergmark.nl  Mon Apr 17 12:19:30 2017
From: adam at bergmark.nl (Adam Bergmark)
Date: Mon, 17 Apr 2017 12:19:30 +0000
Subject: Haskell 2020: 'let' to be optional and with wider scope of
 visibility, like other Haskell functions
In-Reply-To: <CAOOzCW67Ym3c8z_uXPOM58UDzg8AJfByW0nys9TDGz-f8cTBfA@mail.gmail.com>
References: <CAGaP9kuE89hbrAdYD8-f6A9ei=NHfGRLP+Pub-sj=7BwiRutUg@mail.gmail.com>
 <CANBN=muUBY-wi5GEUNZgkDx=Bdwnn1U2WuLDb1wsPLJpKioFvw@mail.gmail.com>
 <CAGaP9ku2Nv2-66583gV4nKbS+70XZe=-bVNpR1XUEsRZbLFFcA@mail.gmail.com>
 <CANBN=mu5Ea7b8fXZDoMB+m-LLBMmYOh+ps14nC1JLEuiW6JM4Q@mail.gmail.com>
 <CAGaP9ktUGyfLZNgvJO8t00wrC+S7ZJd8=eBLAAisMEx_TNAiiQ@mail.gmail.com>
 <20170416181528.GA5277@casa.casa>
 <CAGaP9kuGKDtf6BqhiW6EHT19o9FQu4etKDWvZYmDvHMGb2ShLQ@mail.gmail.com>
 <CAOOzCW67Ym3c8z_uXPOM58UDzg8AJfByW0nys9TDGz-f8cTBfA@mail.gmail.com>
Message-ID: <CACnqJZYeSfxFWbybWFF7NY8TGKt_BRumoZckcbxkiCGOSezKzw@mail.gmail.com>

Hi Vassil,

I just wanted to say that there is no need to apologize for making a
proposal!

Cheers,
Adam


On Mon, 17 Apr 2017 at 00:57 Michael Walker <mike at barrucadu.co.uk> wrote:

> I feel that if people are confused about whether to use "let x = ..."
> or "x <- ...", changing the syntax to remove the "let" won't help.
>
> On 16 April 2017 at 21:32, Vassil Ognyanov Keremidchiev
> <varosi at gmail.com> wrote:
> > They are confused about when one should put "let x = ..." or "x <- ..."
> > mostly before they learn what is monad.
> >
> > 2017-04-16 21:15 GMT+03:00 Francesco Ariis <fa-ml at ariis.it>:
> >>
> >> On Sun, Apr 16, 2017 at 08:21:43PM +0300, Vassil Ognyanov Keremidchiev
> >> wrote:
> >> > Okay, sorry for taking your time about those propositions. I'm just
> >> > thinking of ways for improving future Haskell. My feedback is mostly
> >> > from
> >> > talking with people and trying to teach them in Haskell.
> >>
> >> As others, I am not convinced with the proposal (given the amount of
> >> boxes marked "Translation" in the Haskell report, I wish we had a
> >> standard way to handling syntactic rewrites; it could come handy in
> >> yours and many more cases).
> >>
> >> But I am interested in newcomers and their introduction to the language:
> >> did they get confused by `let` or just pointed it out as superfluous?
> >>
> >> _______________________________________________
> >> Haskell-prime mailing list
> >> Haskell-prime at haskell.org
> >> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-prime
> >
> >
> >
> > _______________________________________________
> > Haskell-prime mailing list
> > Haskell-prime at haskell.org
> > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-prime
> >
>
>
>
> --
> Michael Walker (http://www.barrucadu.co.uk)
> _______________________________________________
> Haskell-prime mailing list
> Haskell-prime at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-prime
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-prime/attachments/20170417/611dedf2/attachment.html>

From svenpanne at gmail.com  Mon Apr 17 14:03:35 2017
From: svenpanne at gmail.com (Sven Panne)
Date: Mon, 17 Apr 2017 16:03:35 +0200
Subject: Haskell 2020: 'let' to be optional and with wider scope of
 visibility, like other Haskell functions
In-Reply-To: <CACnqJZYeSfxFWbybWFF7NY8TGKt_BRumoZckcbxkiCGOSezKzw@mail.gmail.com>
References: <CAGaP9kuE89hbrAdYD8-f6A9ei=NHfGRLP+Pub-sj=7BwiRutUg@mail.gmail.com>
 <CANBN=muUBY-wi5GEUNZgkDx=Bdwnn1U2WuLDb1wsPLJpKioFvw@mail.gmail.com>
 <CAGaP9ku2Nv2-66583gV4nKbS+70XZe=-bVNpR1XUEsRZbLFFcA@mail.gmail.com>
 <CANBN=mu5Ea7b8fXZDoMB+m-LLBMmYOh+ps14nC1JLEuiW6JM4Q@mail.gmail.com>
 <CAGaP9ktUGyfLZNgvJO8t00wrC+S7ZJd8=eBLAAisMEx_TNAiiQ@mail.gmail.com>
 <20170416181528.GA5277@casa.casa>
 <CAGaP9kuGKDtf6BqhiW6EHT19o9FQu4etKDWvZYmDvHMGb2ShLQ@mail.gmail.com>
 <CAOOzCW67Ym3c8z_uXPOM58UDzg8AJfByW0nys9TDGz-f8cTBfA@mail.gmail.com>
 <CACnqJZYeSfxFWbybWFF7NY8TGKt_BRumoZckcbxkiCGOSezKzw@mail.gmail.com>
Message-ID: <CANBN=mu2x3XC9z48_v-WkSMYg5AUL3mkXp1uGno+J1V2ej_jTg@mail.gmail.com>

2017-04-17 14:19 GMT+02:00 Adam Bergmark <adam at bergmark.nl>:

> I just wanted to say that there is no need to apologize for making a
> proposal!
>

+1 for that, and sorry if I sounded harsh, that wasn't my intention.
Proposals are important (we need more of them, not less), and so are
discussions about them. Nothing would be worse than a dead language nobody
cares about...
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-prime/attachments/20170417/314b65fb/attachment.html>

From varosi at gmail.com  Tue Apr 18 19:07:36 2017
From: varosi at gmail.com (Vassil Ognyanov Keremidchiev)
Date: Tue, 18 Apr 2017 22:07:36 +0300
Subject: Haskell 2020: 'let' to be optional and with wider scope of
 visibility, like other Haskell functions
In-Reply-To: <CANBN=mu2x3XC9z48_v-WkSMYg5AUL3mkXp1uGno+J1V2ej_jTg@mail.gmail.com>
References: <CAGaP9kuE89hbrAdYD8-f6A9ei=NHfGRLP+Pub-sj=7BwiRutUg@mail.gmail.com>
 <CANBN=muUBY-wi5GEUNZgkDx=Bdwnn1U2WuLDb1wsPLJpKioFvw@mail.gmail.com>
 <CAGaP9ku2Nv2-66583gV4nKbS+70XZe=-bVNpR1XUEsRZbLFFcA@mail.gmail.com>
 <CANBN=mu5Ea7b8fXZDoMB+m-LLBMmYOh+ps14nC1JLEuiW6JM4Q@mail.gmail.com>
 <CAGaP9ktUGyfLZNgvJO8t00wrC+S7ZJd8=eBLAAisMEx_TNAiiQ@mail.gmail.com>
 <20170416181528.GA5277@casa.casa>
 <CAGaP9kuGKDtf6BqhiW6EHT19o9FQu4etKDWvZYmDvHMGb2ShLQ@mail.gmail.com>
 <CAOOzCW67Ym3c8z_uXPOM58UDzg8AJfByW0nys9TDGz-f8cTBfA@mail.gmail.com>
 <CACnqJZYeSfxFWbybWFF7NY8TGKt_BRumoZckcbxkiCGOSezKzw@mail.gmail.com>
 <CANBN=mu2x3XC9z48_v-WkSMYg5AUL3mkXp1uGno+J1V2ej_jTg@mail.gmail.com>
Message-ID: <CAGaP9kuFJu2=iej1PO1dmpdt_am9xosOnHhv0A+UnFkvZ_a=dw@mail.gmail.com>

It's just helping clean up a bit words that doesn't have much meaning.
Currently GHCi in GHC 8 is supporting this, so you could write both:

x = 10
x <- return 10

Which is great!

2017-04-17 17:03 GMT+03:00 Sven Panne <svenpanne at gmail.com>:

> 2017-04-17 14:19 GMT+02:00 Adam Bergmark <adam at bergmark.nl>:
>
>> I just wanted to say that there is no need to apologize for making a
>> proposal!
>>
>
> +1 for that, and sorry if I sounded harsh, that wasn't my intention.
> Proposals are important (we need more of them, not less), and so are
> discussions about them. Nothing would be worse than a dead language nobody
> cares about...
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-prime/attachments/20170418/b4b01775/attachment.html>