Hacker News Reader

Comment by wcarron | Hacker News Reader

I'm by no means a very experienced programmer, but what was the motivation behind choosing `nil` over `null`? Seems like, from my inexperienced perspective, it was just designed to add unneeded idiosyncratic syntax/semantics to distinguish it from Ruby and/or C.

Can't comment on anything more than that right now. Have yet to dive very deep into it.

View on HN

Generally, you see NULL when the concept of nothing is represented with the byte value of nothing or 0 (e.g. C).

Nil tends to be used in languages where the concept of nothing is represented by some sort of container. In lisp, it's simply the empty list (since all data lives in lists in lisp). In Ruby, it's a singleton object that inherits from the same base class as everything else. In both cases, the language is structured such that every container can easily be asked the question "Are you nil?" (as opposed to false or 0).

Thank you for that explanation! I had never thought about it in that way.

>since all data lives in lists in lisp

That's not true. Every modern Lisp implementation has many primitive data structures: vectors, hash tables, etc.

The Lisp 1.5 [1965] manual describes arrays in section 4.4.

So I didn't even need to say modern! Thanks!

There are probably as many languages using "nil" as there are ones that call it "null".

Nil: Ruby, Go, Oberon, Modula-2, Swift, various Pascal dialects, Lisp?.

Null: C/C++, Java, Rust, JavaScript, Ada.

Then, of course, there's Python with None.

put SQL on the "null" team as well

Depending on the sql variant, null could be more like nil.

If it varies from NULL then its not SQL compliant https://en.wikipedia.org/wiki/SQL_compliance

Also..

Nil: Lua

Null: PHP

For what it's worth, Rust has both Null (for unsafe null pointers) and None (wrapping a type that may or may not exist at any given point). None is used far, far more frequently in my experience than null in rust though.

Rust deliberately doesn't have anything in the language called "null" (there's `std::ptr::null()`, but that's for C interop). The only thing that fits the bill here is the unit type/empty tuple, `()`, which is sometimes called "nil".

I know, but it's "std::ptr::null", not "std::ptr::nil", which was the point of this discussion. (Clearly it has a concept of null pointers, even if they're used in a more limited manner than other languages.)

But you can't use `std::ptr::null()` in the same way that you use null in the other languages mentioned there. It's literally just there for C interop, and it's called that because that's the terminology that C uses.

For finding an analogue for the typical null use case in Rust, one would use the `None` variant of the `Option` enum.

Nitpick: `std::ptr::null()` is not just there for C interop. It's also useful when writing pure Rust unsafe code.

Can confirm, used null all the time in Rust. The raw pointers are important native Rust constructs, although they do skew to supporting C idioms as much as possible (e.g. `* const T` and `* mut T` is basically a worthless distinction within Rust itself).

So in other words, std::ptr::null is Rust's version of null for situations where you would actually use null in C, except in general Rust discourages trying to use it like it's C. Seems reasonable.

And perl with undef vs (). undef a special symbol such as null, and () the empty list as nil.

Neither nil, null, none or undef refer to (void*)NULL, they are usually a special symbol in the global symbol table. Only some languages use null/nil as NULL/0 internally.

Huh, didn't know it was split that way. I'd seen a couple examples in C/Java/Rust/JS/Java and assumed the vast majority of them used 'null'. Thanks for edifying!

Crystal started out as being more or less "compiled Ruby" (it's changed a bit since I first came across it). As such that means it uses "nil" just like Ruby does. And Ruby, being heavily inspired by Smalltalk, took "nil" from Smalltalk. You'd probably have to ask Alan Kay to get to the bottom of this.

Re: Smalltalk, Alan Kay borrowed nil from Lisp.

Matz (ruby) also borrowed nil from Lisp. (He was also inspired by Smalltalk.)

Ruby uses 'nil'.

Not a new terminology. Lisp uses "nil", which is '(), the empty list. Objective-C uses nil as a null pointer to which messages may be sent. Probably others too that I can't remember now.

Many languages use "null" in similar ways. I guess it's a matter of particular syntactic conventions.

The value, under conventional evaluation, of the expression '() is (), which is the empty list. This '() expression itself is the object (quote ()) which is anything but nil.

The nil-()-false correspondence is only specific to the Lisp dialects which are close to the original tree. In Scheme, an empty list is indeed (), and this object also the terminating atom of a list. However, the object isn't a symbol at all, let alone the symbol nil. Moreover, the object isn't a Boolean false; Scheme has #f for that.

Reply on news.ycombinator.com