Hacker News Reader

Comment by SeanDav | Hacker News Reader

I will definitely be keeping an eye on Nim. That aside, does anyone else find the fact that Nim treats "-1" differently to "- 1" (quotes added for clarity) a bit disconcerting?

View on HN

In Lisps, this:

    (- 1)

and this:

    (-1)

Are completely different things (the latter is actually an error). Also in LiveScript

    ls> (- 2)
    [Function]
    ls> (-2)
    -2

Also in Smalltalk, this:

    -3. "=> -1"
    - 3. "=> Error!!!"

That's off the top of my head, I'm sure there are many other languages with this characteristic. Why would that be a problem? It's just a single (or a couple) parse rules to remember (but you get other benefits from it).

Perhaps most notably, Haskell has the same behavior as LiveScript.

EDIT: Derp, that's not true. (- 2) == (-2)

To be clear: (- 2) is not a section in Haskell, it's effectively a numeric literal because '-' is Haskell's only prefix operator. Haskell has a 'subtract' function that's defined in its Prelude that is used where a section for (-) would be useful.

It's a minor wart, and probably never going to be fixed.

EDIT: clarified

>Are completely different things (the latter is actually an error).

Why is the latter an error?

In Lisp, a parenthesized expression is a function call by default, if not explicitly transformed in some way (for example with `quote`). `(f 1 2 3)` would be written as `f(1, 2, 3)` in other languages, and `(f)` would be `f()`. So `(-1)` would translate to `(-1)()` which doesn't make sense. Well, not exactly, as for example in CL and Elisp you have a `1+` function[1], which... well, adds 1 to its argument. The difference is that `1+` is not a valid literal number, so it's read as a symbol, and if this symbol has a function attached to it, it is called.

In Common Lisp you can work around this by using a special syntax: `|-1|`, which forces reading the thing inside as a symbol. You can then define functions and call them this way:

    (defun |+1| (x) (1+ x))
    (|+1| 1) ;; => 2

[1] `1-` too, of course.

Thanks for the answer. I know very little Lisp, though I find it interesting.

> `|-1|`

Is there a name for that | operator - if it is one?

I didn't find any specific name for it. I think it's just a part of atom syntax, like " is part of string syntax. But it could also be a reader macro - in Common Lisp you can override parts of a parsing process. You can write similar macros yourself. For example, Common Lisp doesn't have a dict object literal ({} in json), but as you can see here: https://gist.github.com/chaitanyagupta/9324402 you can add it.

Comparing Nim to Lisps doesn't make much sense. Lists in Lisp are whitespace-separated, so `(- 1)` is different from `(-1)` for the same reason that `(a b)` is different from `(ab)`.

Negative literals/negation/subtraction sharing "-" leads to odd corner cases in the grammars of quite a few languages. I'm rather fond of the J approach: -1 is the application of the negation operator to the literal one. _1 is the literal negative one. This is a very important distinction in J since you can have whitespace-delimited lists of numbers. "-1 2 3" is equivalent to "_1 _2 _3".

This is also true of Standard ML, where unary minus is ~, and APL, where unary minus is ¯

To be most clear: The "high minus" in APL is not the unary negation function; it's part of the syntax for a negative numeric literal.

If X is 1, "-X" computes "¯1", and "¯X" is ill-formed.

That depends on how good the error messages are. I can't see it being a common problem, but if there was a typo, I can imagine it being quite hard to find without an error message clearly indicating.

A moment's thought failed to turn up examples—which is almost certainly my fault. What is a context in which both could appear? In that context, what other languages treat them identically?

EDIT: Ah, the documentation mentions:

> This also means that `-1 is always parsed as prefix operator so code like `0..kArraySize div 2 -1` needs to be changed to `0..kArraySize div 2 - 1`.

Reply on news.ycombinator.com