
PureScript 0.13 Release - valb
https://github.com/purescript/purescript/releases/tag/v0.13.0
======
jjnoakes
I noticed a few languages removing support for octal and binary literals. I
wonder why. I find them useful and the parser overhead seems minimal to keep
them around.

~~~
natefaubion
We found no usages of it in the wild. If there is real-world need for them,
we'll consider adding them back.

~~~
scrollaway
FWIW I use binary literals a bunch in python, either when working with binary
file formats or with bitfields.

~~~
natefaubion
Yes, I'm not saying there aren't usages for them in general, but PureScript
currently occupies a niche that doesn't get down to the level of binary file
formats. This change is more about "only supporting what we need to right
now", rather than "we don't like binary literals". As noted elsewhere, it's
not difficult to add support for them when we need to.

------
dmitryminkovsky
Are there other languages that make an opinion on tabs/spaces? This seems
nice.

> The only whitespace now allowed in code is ASCII space and line endings.
> Since you must use indentation to format PureScript code (unlike Haskell),
> we felt it was best to be more restrictive in what you can write instead of
> allowing potentially confusing behavior (implicit tab-width, zero-width
> spaces, etc). You can still use unicode whitespace within string literals.

I’m also wondering about the removed literals.

~~~
nathanyukai
I think Elm have similar rules, the official code format tool is very
opinionated.

~~~
entropic
I can attest to that, elm-format is an excellent tool and it is great to have
a standard code formatter, one less thing to worry or argue over when writing
code!

------
truth_seeker
If PureScript is Haskell, TypeScript is ML

Lately, TypeScript has become more scalable across existing npm libraries and
also introduced new advanced types. It looks like Microsoft guys learned a lot
from C# and F# type system and feedback from their users

[https://www.typescriptlang.org/docs/handbook/advanced-
types....](https://www.typescriptlang.org/docs/handbook/advanced-types.html)

~~~
k__
I had the impression:

ClojureScript == Lisp

PureScript == Haskell

Reason == ML

TypeScript == C#

~~~
truth_seeker
Yes. I agree. It was started like this.

But now Typescript 3.5 is also influenced by F# which is close to ML.

Just look at those advance types and their allowed composition which
Typescript supports in its latest release and you will understand.

~~~
k__
Yes, feels kinda overloaded to me...

------
Scarbutt
What happened to the original author of PS?

[https://github.com/purescript/purescript/graphs/contributors](https://github.com/purescript/purescript/graphs/contributors)

~~~
kepano
I don't speak for Phil, but I do work with him at Lumi where we use PureScript
for almost all frontend. It's been really fun to show that PureScript can be
used successfully in production.

You can see some of our tutorials and open source projects here:
[https://www.lumi.dev](https://www.lumi.dev)

------
asplake
Syntax question, after looking at a couple of examples: Long wished more
languages had a ‘where’ clause (suspect it could be really nice to have in
Python), but why the ‘where’ at the end of the initial ‘module’ line? I guess
it’s doing something consistent, but it does look a bit odd

~~~
natefaubion
It's something that comes from Haskell. The `where` keyword always starts a
new layout/indentation context. It's not strictly necessary and there are ways
around it, so it's just a point of consistency.

------
jaequery
what is scary about all these TypeScript, PureScript, Elm, etc, is that for
variety of reasons, any one of these can just come and go. coffeescript
anyone?

i'd tread very carefully and wisely before choosing any one of these paths.

it only makes sense imo if you come from Haskell, Clojure, or some other ML
background to have an explicit interest in these languages.

~~~
iLemming
Coffeescript did not offer anything but different syntax. It hasn't improved
the semantics of the language. Some people liked it and some didn't.

Elm, PureScript, and Clojurescript are fundamentally different languages.
Javascript today has bloated, and it keeps growing. Experienced developers
tend to dislike it. Newbie developers struggle with it. It is no longer "a
small language with a low entry barrier". ECMAScript specification is already
bigger than Java's.

PLs of today and the next couple of decades will be striving for optimizing
for programmer's productivity, performance, or correctness of the program.
Javascript today does not fit in any of these categories. So it is only
natural - the trend of using alt-js langs will only grow.

