Are there languages without "null"?

Tcl has no concept of null whatsoever. Everything is a value and all values have a string representation (typically summarized as "Everything is a String").

The closest thing to null is the empty string.

To convey the concept of "no value" requires some creativity.

Of course, as mentioned above, some people use the empty string to signify no value. For this to work, empty strings cannot be valid in the data set you're processing. Surprisingly, a lot of real world data falls into this category.

Another way to indicate absence of value is to simply throw an error. In some cases this is exactly what should have been done instead of returning some null or error value (an anti-pattern learned from C and a habit that's hard to get rid of).

Yet another way is to return an empty list (a list is Tcl's equivalent of arrays in other languages). The string representation of an empty list is the empty string. But fortunately the string representation of a list containing an empty string is two double quotes: "\"\"". This difference allows one to differentiate between a list that contains "nothing" and a list that contains a string that has no characters in it.

Finally some people simply indicate the absence of values by simply not declaring the variable (or undeclaring it, which is a thing in tcl). This may sound odd because variables seem to be a compile-time construct (while values are run-time construct) but in tcl everything is run-time. Thus it's possible for code to use non existence of the variable as a signal. Trying to read an undeclared variable results in an error which you can catch. In addition, Tcl also allows you to use introspection to check the state of the interpreter. So you can use [info exist x] to check if a variable called x exists.

Here's an incomplete list of languages that are null-safe in the sense that they don't have any non-nonnullable types:

• Dart (2021): Has optional types with ? syntax.
• C# 8 (2019): Has opt-in "nullable reference types".
• Kotlin (2015): Has optional types with ? syntax.
• Pony (2015). Uses union type where one of the types is None.
• Swift (2014): Has optional types with ? syntax.
• Crystal (2014): Does have nil, but prevents all null pointer exceptions at compile-time.
• Hack (2014): Has optional types with ? syntax.
• TypeScript (2012): Has union types that can have undefined or null as a variant.
• Elm (2012): Has union type Maybe.
• Ceylon (2011): Has optional types with ? syntax.
• Rust (2010): Has optional type Option.
• Fantom (2005): Has optional types with ? syntax.
• F# (2005): Has union type Option.
• Nice (2003): Has optional types with ? syntax.
• Netlogo (1999) has no type null
• OCaml (1996): Has union type option.
• Haskell (1990): Has union type Maybe.
• Standard ML (1990): Has union type option.
• Tcl (1988)
• Erlang (1986)
• Prolog (1972): A logical variable stands for "anything at all". There is no concept of "null" or "undefined".

Feel free to complement the list. The years represent the first public release.