[AMG]: [Everything is a string] is nice and all, but for many applications it's important to have a special value that's outside the allowable domain. If the domain of values is numbers, any non-numeric string (e.g., "") will do, so "" can be used to signify that the user didn't specify a number. [C] strings can't contain '''NUL''' and therefore are free to reserve '''NUL''' as a terminator or field separator. [Unix] filenames reserve '''/''' and '''NUL''', so '''/''' is available to separate path components and NUL can be used with '''find -print0''', '''xargs -0''', and '''cpio -0''' to separate filenames in a list. (The more common practice of separating filenames with whitespace breaks whenever whitespace is used in filenames.) But if the allowable domain of values is any string at all, no string can be reserved for a special purpose. Since [Tcl] has nothing that is not a string, the only remaining solution is to have a separate, out-of-band way of tracking the special case. Returning to the C example, if a program needs to support having '''NUL''' in the middle of a string, it must either encode the string using a possibly fragile quoting scheme, or it can use a separate variable to track its length. As for the Unix filename example, if a filename needs to contain a '''/''', it absolutely must be encoded, for instance as '''%2F''', but then the quote character must also be encoded ('''%25'''). This is because Unix filenames have no room for an out-of-band channel. (By the way, [KDE] uses this encoding scheme to support '''/''' in filenames.) In Tcl, a separate variable can be used, such as a variable that's false when the user didn't specify a string. This can be very cumbersome and isn't always viable (again, when the domain is all strings). Two examples are default arguments and SQL nulls. Foolproof tracking of the former requires the [proc] to accept [args] and do its own defaulting (you can use the trick from [ML]); '''[[[llength] $args]]''' serves as the out-of-band channel. Tracking the latter may require asking the database to prepend a special character to all non-null string results; basically the first character is the out-of-band communication channel identifying the nullity of the result. A more straightforward option is to '''SELECT''' the '''NOTNULL''' of the string columns whose values could be null. ---- [jhh] proposes a possible solution in [TIP] 185 [http://tip.tcl.tk/185]. Basically, '''{null}!''' is recognized by the parser as a null, which is ''not'' a string; it is distinct from all possible strings. '''"{null}!"''' is, of course, a seven-character-long string, and it's also a one-element list whose sole element is a null. I ([AMG]) have several strong comments regarding the TIP: * I prefer to say "null" instead of "null string" because I feel that a null is not a string at all. It's the one thing that isn't a string! I guess we'll need to change our motto. :^) * Likewise, I'd rather not tack the null management functionality onto the [[[string]]] command. * I think I'd prefer a '''[[null]]''' command for generating nulls and testing for nullity. It's best not to use the '''==''' and '''!=''' [expr] operators for this purpose; null isn't equal to anything, not even null. * We can ditch the '''{null}!''' syntax in favor of using the '''[[null]]''' command to generate nulls, but then '''[[null]]''' cannot be implemented in pure script. This might be an important concern for [safe interps]. * Automatic compatibility with "null-dumb" commands is a mistake; it's the responsibility of the script to perform this interfacing. * When passed a null, the '''Tcl_GetType()''' and '''Tcl_GetTypeFromObj()''' functions should return '''TCL_ERROR''' or '''NULL''' (in the case of '''Tcl_GetString()''' and '''Tcl_GetStringFromObj()'''). * Most commands should be "null-dumb". Only make a command handle nulls when it is clear how they should be interpreted. * The non-object Tcl commands can probably represent nulls as null pointers ('''(void*)0''' or '''NULL'''). If for some reason that can't work, reserve a special address for nulls by creating a global variable. Feel free to argue. :^) ---- [AMG]: Here's a silly and inefficient proc to help me play around with the ideas presented above: proc foobar {varname {value {null}!}} { upvar 1 $varname var if {![null $value]} { set var $value } return $var } This proc should behave the same as [[[set]]]. You will notice that I used '''{null}!''' even though in my above comments I suggested removing it in favor of always using '''[[null]]''' to obtain nulls. But it turns out that's not feasible in the above code; it would only result in '''$value''' defaulting to the string '''"[[null]]"'''. To get the desired behavior, I'd have to write '''[[[list] varname [[list value [[null]]]]]]''', which is far from readable. (With [Tcl 9.0 Wishlist] #67, it becomes '''(varname (value [[null]]))''', which I can live with.) That's one black mark against my idea... A more worrying problem is that '''[[foobar]]''' can't be used to set a variable to null! Why? Because the domain of '''$value''' ''includes'' all strings ''and'' null, there is (once again) no possible value outside the domain that can be used to indicate that a special condition occurred and cannot be "forged" by the caller. So what are nulls good for again? I'm up to two black marks now. It's not looking good. It seems nulls aren't as useful as originally hoped. (Notice the use of the passive voice.) But are they still good for something? The reason '''[[foobar]]''' doesn't work in the above case is that it is being driven by the script, and the script is capable of producing nulls. If its input instead came from a file or socket, it would be just fine because reading from a channel will never result in a null. Of course, at this point I'm reminded of [taint]ing, which might be a better solution. ---- [wdb] When switching from Lisp to Tcl, the lack of some special value such as ''NULL'' was one of the drawbacks with which I decided that I can live. It is the price of the simplicity I am willing to pay. There are more than one cases where something similar is resolved by some trade-off: * In the [switch] statement, the word [default] impacts the '''value''' "default". * In [proc]'s arg list, the word [args] impacts the choice of argument names. * In [Snit] and [Itcl], the argument #auto or %AUTO% impacts the choice of instance name. * And so on. Extending the value range of type string leads to the consequence of leaving the principle [eias]. It is possible, and sometimes even desirable, to extend it. If so, ask yourself, if Tcl is your right choice anymore. If you ask me: I prefer the ''state as is''. The drawbacks are known, and as mentioned above, I can live with them. [AMG]: [switch] can select on the value "default" if "default" is not the last option given. [proc] can accept an argument named "args" if it's not the last one in the list (although see [Tcl 9.0 Wishlist] #77). I'm just pointing out that these "keywords" only have special meaning when in combination with some other out-of-band data, which in these cases is list position. One more example is the use of '''-''' to signify an option. To disambiguate, we have '''--''' to partition the argument list into options and non-options (see ['--' in Tcl]). Yes, it's totally true we can live without nulls. The real problem comes when interfacing with systems that ''do'' have nulls. Tcl has no easy and safe way to represent them. Reserving a string will work most of the time, but the Tcl script becomes confused when the reserved string collides with valid data. This may happen by accident or as part of a malicious attack, which means even nonsense strings like "ßÿÑâRI'" aren't safe. All the other stuff I said about nulls is just cute, sugary things we can do with them if they were added. ---- [wdb] (again) but if really necessary, it is possible to introduce typed data to tcl. Just put them in a list the first of which contains the type, and the second the data as follows: set typed_value1 {allowed {hello world}} set typed_value2 {disallowed {bye bye}} This example shows the use of two data types ''allowed'' and ''disallowed''. It allows easily to construct a null value by choice of type ''disallowed''. [AMG]: This is like [jhh]'s method of prepending a special character to all non-null SQL results, except of course it's cleaner. [NEM]: Tagged data is also how [functional programming] languages like [ML] and [Haskell] handle optional data/NULLs: # data Maybe a = Just a | Nothing proc Just data { return [list Just $data] } proc Nothing {} { return [list Nothing] } set val1 [Just "some data including Just and Nothing"] set val2 [Nothing] Then you can test for missing data (NULL/Nothing) using a switch: switch -exact [lindex $data 0] { Just { do stuff with [lindex $data 1] } Nothing { handling missing data } } Alternatively, in many cases you can use the (non-)existence of a variable or dictionary/array element to test for nullity. e.g. in a database-like interface: $db query $query row { if {![info exists row(name)]} { # name is NULL } } [Lars H]: In the original discussion of TIP#185, the following methods were proposed for interfacing Tcl with systems that have NULL values: 1. If the external function returns a value or NULL, then have the corresponding Tcl command return a list of one element for non-NULL values or an empty list for a NULL value. In Tcl 8.5, [{*}] greatly simplifies using such commands. 2. If the external function returns a "record" where some of the entries may be NULLs, then have the corresponding Tcl command return a dictionary which only has entries for the fields with non-NULL values. Type-tagging values using lists as shown above may also be necessary when interacting with other systems, as some indeed take different actions for data of different types (even if the values are the same). [tcom] apparently has some troubles in this area, as it does not provide for specifying the type of data to pass on. In [TclAE], the types are instead explicitly specified. What NULL proponents should take note of is that Tcl values, as a consequence of the [dodekalogue], constitute a monoid [http://en.wikipedia.org/wiki/Monoid] with the empty string as identity element and string concatenation ([cconcat], for those who require a command name) as operation. The [Everything is a string] principle says that the monoid of Tcl values is in fact a free monoid (currently the free monoid of words in the alphabet of all BMP [Unicode] code-points), and I think it is an '''extremely good''' principle, but the dodekalogue does not explicitly proclaim it. Hence one could imagine a Tcl where there in addition to the strings exists a NULL value, but then it would have to be sorted out how this NULL should act under concatenation. What is passed on to A in the following commands? A [null][null] A [null]somestring A somestring[null] Another problem with introducing special values like NULL is that there's no reason to believe that ''one'' special value is always going to be sufficient: once in widespread use, someone will come up with a situation where NULLs should be handled as an ordinary value, but at the same time needs a SUPERNULL that isn't! On the whole, it is much simpler to avoid introducing any special values. [AMG]: Existence checking can work. Maybe [sqlite] eval's two- and three-argument forms can unset the variable or array element to signify that its value is null. The script already knows all the variable names, so it shouldn't need to be explicitly told what's null. But on the other hand, maybe the array, dictionary, or whatever can be accompanied by a list of all fields whose values turned up null. Encoding the data as a list seems clever. If [[[llength]]] is zero, the data is null. If [[[llength]]] is one, the data is stored in [[[lindex] 0]]. Use [{*}] to get at it most easily. I imagine it's possible to recursively apply this encoding to dictionaries and nested lists. Regarding the combination of nulls and non-nulls, [jhh]'s TIP suggested that concatenating a null with a string resulted in a null. "Nulls propagate. A null combined with any nonnull is null. Appending a null to a string, or substituting a null into a string nulls the entire string." By this rule, '''A''' will receive null in all three cases. My [[foobar]] example shows a case where SUPERNULL would at first glance appear to help, but of course it's a ridiculous thing to ask for, especially since it would still not allow setting a variable to SUPERNULL. What's asked for is a value outside the input domain, but no such value can exist because a variable can be set to anything (string or otherwise). Therefore the only solution is the out-of-band channel, as in [[[llength] $[args]]] indicating how many arguments were passed. With some sugar it might be possible to add a command to check if an argument was explicitly passed or if it was left at its default; this seems like a halfway point because [[[llength] $[args]]] is being used internally but to the programmer it's no different than checking for null. I don't propose such a thing; I'm just giving examples. Lars, as you say, null would only be useful for this purpose so long as the command is intended only to interface with stuff that cannot generate its own nulls. But this is a funky reason to advocate null--- the original impetus was the desire to interface with stuff that ''does'' generate nulls. ---- [jhh]: Let me try to clarify what I was proposing in TIP 185 [http://tip.tcl.tk/185]. (I see more comments have come in since I looked 2007-01-06 14:42GMT, so this is not up to date on the discussion.) Forgive me if I screw up this funky wiki markup language. I agree, every thing is, and should, be a string, but I regret Tcl has no way of representing a null string, unlike most other languages, even Java and lowly Visual Basic. There are really two proposals here, and I probably confused people them by lumping them together in one TIP. The reason I did was that the two together are synergistic and compelling (at least to me). They are: 1. Extend the meaning of a string to include a null string. I will call this TIP 185a. 1. Extend the meaning of list and dicts to allow the representation of unknown elements. I will call this TIP 185b. TIP 185a might be helpful on its own. For example, SQLite's loop construct (e.g., "'''db eval {select * from accts} {} {''' ...'''}'''") can return null information without using a contrived query statement and similarly contrived decoder code, thus opening the door to the creation of ''general purpose'' packages to integrate databases. Either proposal could exist alone, but together they allow Tcl, the preeminent system glue language, to transparently manipulate system communications without kludging them as they enter and leave. A lot of my coding time is spent on this silly matter; if the system involved two or more database engines, as is common, the time is thus multiplied. And ''every'' programmer is doing the same thing, over and over. Aside from that, those of us who think Tcl is the best medium for exploring ideas and algorithms would be grateful at having this gap filled, and those unfamiliar with nulls would soon find nulls quite useful in their own right. TIP 185 was not well received, perhaps partly due to my poor presentation of the idea -- I would do it differently now, having seen the response. My recent thinking is to wait for Tcl 9, or perhaps submit TIP 185a separately. I think the most difficult issues are implementation and performance, and the handling of legacy, null-dumb commands: should they see an empty string and proceed, or should they fail? Currently I am leaning toward the latter, more conservative direction. Most voices against the idea have argued from misunderstanding, or have been vague, so I am not yet convinced the idea has no merit. Little else has been presented that would really help the matter, aside from endless accounts of the workarounds that we all have to invent in the absence of true null handling. These are invariably presented as reasons for why we don't need the feature. The sheer number and variety seems to argue just the opposite. I think if we can recognize the lack of null handling as a real shortcoming and get people working on the problem, we can come up with a fine solution. Imagine if, back at Tcl 6, people had said "speed isn't an issue, just use C for that, then wrap it in Tcl," and did not pursue the performance issue. At the recent conference in Naperville Illinois, there ''were'' two papers on relational algebra packages that might be helpful, though neither package currently supports nulls. I approached Andrew Mangogna, author of ''TclRAL: A Relational Algebra for Tcl'' [http://tclral.sourceforge.net/], about adding the feature, and he explained that he is a follower of C.J.Date, who opposed the use of nulls. I explained my pragmatic argument: perhaps the largest use for Tcl is interfacing with databases, nearly all of which, including SQLite, routinely represent null data. The relational algebra packages presented might provide an interface that could help compensate for Tcl's weakness in this area. He was not interested. Theoretical orthodoxy seemed to be important than practical programming. Later I talked to Jean-Claude Wippler [jcw], author of ''Vlerq + Ratcl = Easy Data Management'' [http://www.t-ide.com/tcl2005e/4_ratcl.pdf.gz], and a very practical programmer, and he found the pragmatic argument more compelling, and promised to look into it. I hope he was in earnest. While such a package is not a full answer to the problem, could provide * A common interface for relational databases, so database APIs could be more uniform. * Providing null handling -- a sort of "standard workaround." * A more complete implementation of relational algebra than can be offered by most database engines, optimized for large databases and high query volumes. A few miscellaneous points : '''1.''' If I revise TIP 185, I will change the nomenclature to "unknown" ('''{unk}!''') instead of "null," because the word is more accurate, and because the English meaning of "null" as "nothing," instead of "unknown," was such a stumbling block for so many people. I originally chose "null" because it is used in SQL. C.J.Date (1995, ''An Introduction to Database Systems,'' 6th ed) uses "UNK" for unknown values in relational algebra, but it wasn't adopted in SQL. I have used the "null" nomenclature here, for consistency with the present discussion. '''2.''' A null concatenated with a string is a null. Again, the "null" nomenclature is confusing. One envisions something like "The quick \000 fox", but that thing in the middle might be "brown" or "" or the full contents of the 1957 ''Encyclopedia Britannica'', we just don't know, thus making the ''whole string'' unknown, or null. This example seems to suggest the programmer might have been better off modeling the phrase as a list of words: set phrase [list The quick {null}! fox] or set color [null] set phrase [list The quick $color fox] Note that if he then '''join'''s the list, it will collapse into a null, like a black hole. '''3.''' A '''[null]''' command can generate a null (TIP 185a), but can not replace the '''{null}!''' syntax. Its purpose is to implement TIP 185b. Sticking '''[null]''' in the middle of a list serialization string turns it into a null (by point 2, above), instead of a serialization of a list with a null element. '''4.''' Three valued logic is widely used and well standardized, particularly in relational databases. Yes, a null is not equal or unequal to anything, including null: the result is never true or false, it is ''null''. However, '''null && false''' is false, etc. There is a whole set of tautologies, I think I included most of them in the TIP write-up. These will propagate sensibly through expressions, just as IEEE floating point NANs do. I mentioned above that C.J.Date argues against the use of nulls. This is ''not'' because of problems with three valued logic, but because of unavoidable paradoxical result sets in formal relational algebra. I reiterate my pragmatic argument to Andrew Mangogna, above. '''5.''' One of the most common misunderstandings in previous discussions is that nulls can not be serialized. This is an example of the synergism of TIP 185a and b: 185b enables this -- merely encapsulate a transmission in a list. Now you can send ''any'' data structure representable by a string or list, containing nulls in whole or embedded in any part. It can be handled on the other end by general purpose code, without any need for a special protocol or understanding of the transmitted data structure. This data format might well be appreciated, like Tk, by a broader audience than just the Tcl community. We would be leading, instead of lagging behind, in the area of data management. Sorry for the long exposition. Hope some of you look it over and find it useful. [NEM]: From the discussion above, it appears that your main point ''for'' including a special null non-value into Tcl is that NULLs are widespread in the world of SQL databases (your pragmatic argument). Can you describe how the alternatives outlined by others, which do not require such a radical alteration of Tcl's [EIAS] philosophy, fail to address this issue? In particular, I see at least three separate means of encoding the concept of missing data into a run-of-the-mill string: 1. Using a list encoding: ''llength $data == 0'' for NULL, otherwise ''lindex $data 0'' is the real data. 2. Using a tagged list encoding: Nothing vs {Just $data} (a variant of the above). 3. Using a dict or array encoding where missing data is represented by a missing key, so that ''dict exists'' can be used to check for null/missing data. To me, these are all much nicer options than introducing a special non-string non-value. ---- [slebetman] I'd just like to point out that Tcl is not the only language that doesn't have a NULL data. Neither C nor C++ has NULL data. NULL pointers yes, nul byte yes, but not NULL data. This is not just pedantic but fundamental in C. C is like Tcl (or should it be that Tcl is modeled like C?): "everything is a number". C, freestanding in itself, doesn't recognise the nul terminator in strings as anything other than ordinary data. It is the standard library that cares, not C itself (though it is part of the C standard). Even for a NULL pointer which C does fuss about, it is only special when used as a pointer. The NULL pointer if used as data will be treated by C as a regular integer. In C NULL data is just a convention, nothing more. NULL data is useful for determining the difference between the user entering an empty string and the user not entering anything though. But in this case I don't see why we can't steal the C convention and signify NULL data with \0. I don't know much about SQL, am I missing something? This is all very confusing because it starts out with a misleading C example (A nul in the middle of a "standard" C string is by definition the end of the string hence is not in the middle) then goes on to talk about a completely different concept of NULL data in SQL. Note that when sending data to an external program, Tcl already support C nul. There is absolutely no problem in this department so I have no idea what the C compatibility complaint is about in this discussion: # Saves a file which C can read as containing 3 strings: set f [open test.dat w] puts -nonewline $f "this\0is a\0test" close $f # It's also easy to parse C strings: set f [open test.dat r] set strlist [split [read $f] \0] close $f Indeed for me, Tcl has one mechanism not found in C/C++ (at least not usable in runtime code): the nonexistent variable! For true NULL values I normally simply don't set the variable at all unless needed. Then use [info exists] to check the difference between an empty (possibly binary) string and a nonexistent string. Though you need to be careful to always unset the variable at the end of the block lest you accidentally use the previously set value. There are already commands in Tcl that use this convention. [regexp] is one example which simply doesn't set the match variables if the values don't exist. [AMG]: I wasn't trying to be misleading when I wrote about NULs, but I see that it worked out that way despite my best intentions. Let me reiterate my very first point at the top of this page. I said that it's often useful to have a value outside the acceptable domain to signify an exceptional circumstance. My second example of this is that C strings are arrays of bytes in the range 1 through 255, so 0 (NUL) is available for this purpose, and it is defined to be a terminator (standard C string), but some systems (find/xargs/cpio) use it as a separator. (If you think about it, these are really the same use.) SQL was merely another example of this general concept. What concept? The concept is sending control data in the same stream as regular data. This can be implemented in one of three ways: 1. Have a separate, parallel data stream. [[llength $args]], [[info exists]], and the "contrived" SQL queries are examples. 2. Encode with some kind of quoting. The backslash character is an example. Note how the backslash must itself be quoted; null would not have the same problem since it's outside the domain. 3. Signal special data with a value that cannot appear in the normal data stream. '''{null}!''' can be used when the normal data stream can be any string. When the data stream is numbers, any non-numbers will do. There's some overlap between the three. But since I probably haven't succeeded in clearing anything up, I'll try to make this all really simple by saying that it's dumb to use null for this purpose and that I'm sorry I brought it up. Instead let's focus on interfacing with other systems that use nulls. Also consider why other systems use nulls (to represent unknowns); maybe Tcl can benefit from using that same feature internally. Yes, it's true that [C] doesn't really have null either, but it does have the NULL pointer because it reserves one memory address for that purpose. More memory addresses can be reserved simply by creating globals or defining functions. The meaning of the NULL pointer (or any other reserved pointer) is application-defined, and it's often used to signal something exceptional, such as "data not available", "cached string representation invalid", "error", or "SQL query returned null". By the way, I use several distinct terms that are all pronounced the same way. They mean different things. Let me clarify: * null: A non-string, non-value object. As [jhh] says, it is used to indicate an unknown. * NULL: (void*)0, the value assumed by a C pointer when it doesn't point to anything in particular. * NUL: (char)0, an ASCII value used by C to terminate a string. None of this discussion is about interfacing with NUL or NULL, only with null. (Man, that sounds stupid when you say it out loud! I can see why this got confusing.) [slebetman]: Again you're using C as an example and again I must point out that C does not have a feature to signify a non-entity when working with binary data, only when working with text strings. So again I'm asking what's wrong with using \0? This does not fall into either 1. or 2. but fits perfectly for 3. which is what you want. If you're only working with strings, simply return the nul character like C if you find C's behavior acceptable. Like C, if you decide to work with binary data then the null representation is unavailable. Regarding the other meaning of null, that is something similar to C's NULL, where C has the convention of using the NULL pointer as a signal, Tcl have traditionally used the empty string as the same signal. Some people find this unacceptable* since they don't consider the empty string as being outside the domain of valid data. I think this is the real issue. Not the "interfacing" with other systems part because Tcl can do that already since it can handle binary data transparently. * Note: That includes me. I do personally wish that Tcl differentiates between an empty string and '''"null"''' (or "undef" in Perl). But this kind of '''null''' is different from what is described by TIP 185. It's more like the half-way point in the existence of a variable: the variable exists but the value doesn't. [AMG]: Pointers can be used for more than just text strings. An SQL query result can be formatted as an array of pointers to values, for example '''{int* user_id, char* account_name, char* nickname, int* tel_exchange, int* tel_extension}'''. If any of these values is null for a particular row, the pointer can be NULL. A C string consisting only of \0 (NUL, as I call it) is not a null; it's an empty string. Since I've been a really poor communicator, I think I must say again that I too think the real issue is that using the empty string (or any other string) is not an acceptable method of representing nulls. This is because no matter what string is chosen, that string might possibly show up in valid, non-null data. I then spewed some gobbledegook about how this method works just fine when using limited domains like numbers or arrays of bytes 1 through 255 instead of all strings, but that was just me trying to be complete. Interfacing with other systems still remains an issue because some systems really do try to send nulls in addition to strings*. On the Tcl side, methods 1 and 2 (above) must be used to do this safely, but usually method 3 is used even though the possibility of ambiguity exists. (*any array of binary data is a string, which can include any number of NULs) "The variable exists but the value doesn't." Yes, this pretty much sums up what I'd like to see in a true null implementation. The variable definitely does exist, but its value isn't known. [slebetman]: This is where you've lost me. It is impossible to send/transmit null nor is it possible to save nulls to file. Unless you're talking about a file that doesn't exist representing null or a zero length TCP packet representing null. Once data is sent or saved it has to have a physical representation. What represents non-data in such cases is application specific. For example, Tcl code represents such "nulls" as any string which begins with "#" until the end of line (in other words, a comment). Lots of text files represents such "nulls" using a single byte "0x0c". Another common representation of "null" in binary is 0xffffffff which when interpreted as 2's complement integer is -1. Of course 0 (zero) is also a very common representation of "null". In C, a NULL pointer only exists at the source code level. In running code, a NULL pointer can never be portably transmitted or saved into a file without explicitly first converting it to 0 (zero). Yes you can do that as a hack. And yes the C standard does specify that: int *a = 0; int *b = NULL; both point to NULL. But only at the source code level. Once compiled, NULL is not guaranteed to be equal to 0. Indeed there exist platforms in the real world where a NULL pointer is represented in binary as not "all bits zero". This is why I equate the null concept to a variable state. Null data is application specific. What happens when you try to save/send a null variable depends on the language. The C standard decided to let you do it but they have a ''"we don't define the result and don't call us if anything goes wrong"'' attitude. Perl on the other hand does it the same on all platforms by decaying undef into an empty string or the number 0 depending on context if treated as data. [AMG]: It is not impossible to send/save null. Every SQL database in the world manages to do exactly this. It has to use methods 1 or 2 to do it, though. All the null encodings you mention are examples of method 3, but method 3 only works when the domain is limited. For general-purpose data, method 3 can't work. Perhaps a concrete example might help to explain how to safely send/save null. Here's a database record structure that supports nulls: struct record { enum record_type type; /* Type selector code. */ union { int integer; /* Signed integer. */ struct { char* address; /* Address of first byte. */ int length; /* String length in bytes. */ } string; /* UTF-8 or binary string. */ double real; /* Floating-point. */ } data; /* Record data. */ int null; /* Nonzero if null. */ }; With a little bit of work, this can be serialized. (1) Write a byte indicating the type. (2) Write a byte indicating null or non-null. (3) If integer or real and not null, write the value out in a standard format. (4) If string and not null, write the length in a standard integer format, then write ''length'' bytes at the address pointed to by ''address''. This structure is an example of method 1. The data and the nullity are interleaved in the bitstream. A nonexistent file might be able to represent null, but it goes too far. It's like representing a null in Tcl by [unset]ting the variable. Neither the variable nor the value exist, which isn't a fair way to describe what null really means. By the same token, [Perl]'s implementation seems wrong: neither 0 nor "" are null. Null is ''not'' a number, and it is ''not'' a string. ---- [LV] There's lots of theoretical discussion regarding null vs empty strings above. The best place to look in terms of practical application, is interfacing with true SQL. How do extensions like [oratcl] and others, currently, provide the tcl developer with the ability to distinguish a row/column entry which has an empty string as a value vs having no value set (i.e. the NULL situation)? [AMG]: [sqlite] has a '''nullvalue''' subcommand on database connection objects which is used to set the string representation for nulls. It defaults to the empty string. [http://www.sqlite.org/tclsqlite.html#nullvalue] [slebetman]: Ah, so this discussion is ''really'' about SQL then? Not the general idea of null data? Because, as I've mentioned above, the binary representation of "null" in a data stream is application defined and I have a feeling it's even different between different database systems (or indeed different versions of SQL). [LV] I certainly wouldn't say that [SQL] is what everyone's concerned about. However, it is probably the most common practical example of what is being discussed. A lot of the above discussion, as well as discussion elsewhere, has tried, in the past, to avoid mentioning a specific extension because people get side tracked into solving the problem in one specific extension, while the advocates are trying to discuss the base problem. Think of it as the kinds of discussions that went on before ZERO became a part of the number system... [AMG]: Yes, the binary representation of null is up to the application. We're not trying to standardize this. If TIP 185 or a descendant is accepted, Tcl scripts will still have to implement their own serialization of null because it is (or should be) an error to call [puts] with a null argument. Most scripts will never need to serialize null; it's primarily useful for communicating with systems that do have null. It also may be good for communicating between different parts of the application, as is the case when null is used to signal that nothing was specified. But writing a null into a file or over the network requires that it be encoded as bytes, same as a string or number or anything else, and that takes methods 1, 2, or (when possible) 3. [NEM]: This flags up one of the biggest problems with null: not just [puts], but ''every'' Tcl command would need to be adapted to handle being passed a null. If a null is allowed everywhere that a string is, then all commands need to be able to deal with it (either throwing an error or performing some other default handling). Given that there already exist various ways of encoding "missing data" in Tcl (see my previous response some way up this page), it seems unnecessary to introduce such a special mechanism that mostly just causes trouble. The lack of nulls in Tcl is a great ''feature'', leading to much more principled ways of dealing with missing data. Can you describe a single concrete example (preferably with sketch code) of where a special null value would provide any advantage over one of the existing approaches that have been described on this page? [RS] Isn't the non-number ''NaN'' somehow comparable to the more general ''null''? [LV] RS, it seems functionally comparable to me, though literally means something different. As for the request for concrete examples where special null values would provide advantage... I don't understand NEM's "tagged" option, but I certainly see where the array/dict alternative, if actually used by extension writers, probably would be sufficient if done correctly. I don't know how the llength option would work - the results of a SELECT * from my_table, where a specific row/column can take on either: 1. a string value 1. an empty string 1. a null seems like would have problems with llength - would the second and third option be able to be distinguished in that technique? However, if the extension was set up so that only columns that had non-nulls were returned, then one could code to see if the column existed and take appropriate action in that case. As for the argument that this approach means that special code has to be written for each column that within the database can be NULL, well, you'd frequently have to do something special for them if the variables took on a special Tcl NULL object as well. On the other hand, one _could_ have the Tcl code treat NULLs as some unique string as was suggested above, when dealing with said object. It would, however, require a "type" to be maintained along with the string value, so that one could, via perhaps a "string is NULL" ensemble, code special action when needed... [NEM]: I don't know much about ''NaN'', so can't really comment, except to say that it seems to be used as a sort of exception to indicate that the result is outside of the range of what can be represented (e.g. taking the square root of a negative number in a system which cannot represent complex numbers). The purpose of NULL in SQL, and in this discussion (from what I gather), is to representing missing or unknown data. These seem to be somewhat different notions. The tagged list representation is simply borrowed from functional languages like [ML] and [Haskell], which also have no notion of NULL. The idea is that instead of introducing a special "null" value, which is a member of every type (and thus can appear anywhere), you instead introduce a special "option" type (called ''Maybe'' in Haskell, and ''option'' in ML). There are two cases to consider with this type: either the data is present, or it is absent, and this is what the two ''constructors'' directly represent: set val1 [Just 12] set val2 [Nothing] proc maybeDouble x { switch [lindex $x 0] { Just { expr {[lindex $x 1] * 2} } Nothing { error "No value!" } } } maybeDouble $val1 maybeDouble $val2 You can think of it as a little wrapper which adds some information about whether the value is present or not. You can use a list for this too, where Nothing == the empty list, and Just == a list of length 1. Thus, if we consider a database API that returns result rows as lists, and we want to return the following three rows (Larry's three alternatives, above): Command Name | Arguments =============================== "proc" | "name args body" "pwd" | "" (empty string) "someCmd" | (we don't know the arguments accepted) We can encode this by making the second element of each row list use the Just/Nothing constructors: {proc {Just "name args body"}} {pwd {Just ""}} {someCmd Nothing} The equivalent list encoding would be: {proc {"name args body"}} {pwd {""}} {someCmd {}} And the dictionary encoding would be: {name proc args "name args body"} {name pwd args ""} {name someCmd} ;# args entry simply doesn't exist These are all good and natural ways of encoding possibly missing data. As [LV] points out, a NULL from the database has to be converted to something when passed to Tcl, so a built-in notion of NULL doesn't have any particular advantage over any other approach, and several disadvantages. [AMG]: Wow, I had an edit conflict with [NEM]! I'm happy that I was able to spark such a lively discussion. I apologize if my comments below seem a bit repetitive; I'm stitching multiple replies together into some unholy Franken-reply. NEM, if I read you correctly, the disadvantages against built-in null are: (1) inability to serialize, and (2) difficulty interfacing with existing code. I see (1) as a fundamental property of null--- it doesn't have a string representation, so when written out as bytes or characters it must be somehow encoded. We don't aim to standardize this encoding since we know it's an application-specific thing. Python standardizes its encoding of None: it just prints None. But it's able to do this because it surrounds strings with quote characters to signify that they're strings, so None is null and 'None' is a string. That's an example of an encoding. We shouldn't trouble ourselves too much with (2) because the point of null isn't interfacing with (the majority of) existing code. Null is for interfacing for systems that internally have null. Cramming a null down the throat of code that wasn't set up to handle it should result in an error raised by Tcl itself. Simply make the Tcl_GetType() and Tcl_GetTypeFromObj() functions generate an error when passed a null object (or NULL when using the old string-based API). I feel this is the right way to handle it. Relatively few commands can actually do anything meaningful with a null; they should handle these cases by explicitly checking for nullity. My example of a true null being a helpful is interfacing with any SQL system. Take [sqlite]: sqlite3 db filename.db db nullvalue [null] db eval {select id, name from users} { if {[null $name]} { puts "user \"$id\" has no name!" } else { puts "user \"$id\" is named \"$name\"" } } This should be robust even in the face of users having names like "", "null", or "NULL". If this code is part of a Web forum, the probability that someone will call himself "NULL" is pretty much 100%. Here's a version of the above that works without any null support in Tcl: sqlite3 db filename.db db eval {select id, name, isnull(name) as name_is_null from users} { if {$name_is_null} { puts "user \"$id\" has no name!" } else { puts "user \"$id\" is named \"$name\"" } } It works (I think; I can't test right now), but I think it's burdensome. Now for [RS]'s question. According to [jhh], NaN and null are not all that different; it's possible to use both in (numeric, logical, string, list) algebra. If null means "unknown", then [[expr {[[null]] || true}]] should evaluate to true because nothing to the left of the || can make it false, and [[expr {[[null]] && true}]] should evaluate to null because it's unknown whether it's true or false. Nullity propagates. Concatenating a string or list with null should result in null. Numerically adding to null should also result in null. Multiplying null by zero yields zero, but I'm not totally sure on this point. [jhh] says a standard exists for the propagation of NaN; I'm just going to have to trust him on this point since I don't know the standard myself. He says that by the same coin there is a well-defined three-valued logic system that supports the concept of unknown. See his exposition for more. I think it's a mistake for nulls to automatically decay to any predefined string or number. Null isn't "", and it's not 0. If it's not clear how a null should be handled in a given situation, an error should be raised. Scripts and extensions shouldn't depend on nulls turning into "" when looked at from the right angle. If the code isn't written to support nulls, its caller shouldn't be trying to pass nulls to it. If the code is written to support nulls, it won't need to rely on any such compatibility mechanism. [NEM]: Item (2) above is a lot more serious than you seem to think. Not all code calls Tcl_GetFromObj, particularly older code, and some code implements its own string parsing functions and internal reps. All of this code would have to be able to detect and handle a possible NULL. I don't see how you could make this work. What happens when I try to take the string rep of a NULL? An error? This is the problem with NULLs -- they introduce lots of new error conditions and edge cases that simply aren't present in the other solutions. As you say, NULLs propagate, which means they tend to turn up where you least expect (e.g. in places you didn't think a NULL was possible). Your SQLite example is a good one. However, any of the other techniques given work fine for this. In particular, SQLite's usual ''eval'' interface could simply not set array keys for NULL columns: interp alias {} null? {} info exists sqlite3 db filename.db db eval {select id, name from users} row { if {[null? row(name)]} { puts "user \"$row(id)\" has no name!" } else { puts "user \"$row(id)\" is named \"$row(name)\"" } } So, my arguments against NULL are that (1) it is unnecessary, and (2) it is unworkable! :) [DKF]: Moreover, with a database you can let the sql engine take the strain anyway: db eval {select id, name, name isnull as noname from users} { if {$noname} { puts "user \"$id\" has no name!" } else { puts "user \"$id\" is named \"$name\"" } } [AMG]: DKF, that was my example. :^) NEM, indeed code may exist which assumes it will never be passed (void*)NULL. To handle that, Tcl itself can raise an error when a script attempts to pass a null to a string-based function. I know this sounds like a horrible incompatibility, but consider that older, non-object code isn't set up to handle null anyway, and even if it did properly check for NULL arguments, it would only respond by panicking or raising an error. Here's another possibility: /* Special, reserved address for null string objects. Not to be confused with NULL! * This variable is in BSS so it will be initialized to 0. */ static char tcl_null; /* Return a Tcl null string object. */ static char* Tcl_get_null_pointer(void) {return &tcl_null;} /* Check to see if a string object is null. */ int Tcl_is_pointer_null(char* pointer) {return pointer == &tcl_null;} This way the pointer will not be NULL and dereferencing it will only yield an empty string, preventing segfaults. But null-savvy string-based Tcl extensions can call Tcl_is_pointer_null() to check if passed a null argument. Which approach we go with (if we take any action) depends on how committed we are to making new features available through the old, string-based API. Code never has to "take the string rep" of NULL, because the only way code can be passed a NULL is through a char* argument, meaning that the code is expecting to receive the string representation ''directly.'' "Taking the string rep" of null, on the other hand, is a matter worth discussion. Null doesn't have any valid representation since it's not a value, so I say that all Tcl_GetTypeFromObj() functions should generate errors when passed null objects. Code that is designed to handle nulls should always check the nullity of an object it knows might be null; only after it is known to be non-null should it attempt to look at the object's value (string or otherwise). Also scripts should not be trying to pass null to other code that isn't designed for it. Hiding the error by supplying a default value would be negative help in debugging this situation. [slebetman]: I think this is where it really rubs Tclers the wrong way. When we say "everything is a string" we really mean that everything is "ordinary" and can easily be manipulated. A very fundamental part of that "ordinariness" comes from the fact that everything has a string representation (which is the natural way of saying binary representation in Tcl). The array is the first and only thing so far that is opaque in Tcl and even this very uncontroversial addition have since become very controversial for it. But people have learned to cope with arrays because string rep can be faked using [array get]/[array set]. Your (or rather, TIP 185's) null would be an abomination even worse than arrays since it's semantics completely disallows a string representation. This is in direct conflict with the fundamental transparency of data in Tcl. I would now like to note that the more you describe your null (with the NaN like behavior of not decaying at all) the more it seems like it already exists in Tcl: the non-existent variable. It seems to me that the real problem is that all implementation of database API in tcl so far is flawed the same way [foreach] is flawed: it assigns to the variable even though the value doesn't exist! Think about it, Tcl already treats non-existent variables mostly the way you want null to behave. Wouldn't a more natural API be something like: db eval {select id, name from users} { if {[info exists name]} { puts "user \"$id\" is named \"$name\"" } else { puts "user \"$id\" has no name!" } } Or if the slightly less controversial Perl-undef-like null gets implemented: db eval {select id, name from users} { if {[info isnull name]} { puts "user \"$id\" has no name!" } else { puts "user \"$id\" is named \"$name\"" } } The difference here is that "existence" never decays. Trying to use a non-existing variable always results in an error. On the other hand "nullness"/"undefness" decays silently and would not generate errors when used as data. [NEM]: [AMG], let's leave aside implementation options. The greater point is that NULL is unnecessary. [AMG]: slebetman, I find your comparison between arrays and null to be very apt, and I appreciate it. It brings some much needed perspective to this discussion. % array set a {1 2 3 4} % puts $a can't read "a": variable is array This is very similar to what I had in mind for null-valued variables. Trying to read them directly will cause the script to 'splode, so they need to be handled with care. Treat them like nitroglycerin. Sounds awful, doesn't it? That's the nature of null; if it's known that a value can possibly be null (i.e. unknown), never assume it's always non-null. This is as much a mistake in [SQL] as it is in Tcl+null. Or C, for that matter, when it comes to dereferencing pointers. I consider C's behavior concerning NULL pointers to be exactly right--- crash immediately upon dereferencing. % set b [null] % puts $b can't convert null value to a string But don't think this landmine behavior is the ultimate goal; it's just the only sensible way to handle a script's attempt to query the value of something whose value isn't known. It's like how Tcl raises an error when a nonexistent variable is read, whereas [FORTRAN] (at least some versions of it) will silently create the variable on the spot and report garbage for its contents. Also don't think that introducing null would be like introducing barbed wire to the open prairie, signaling the end of freedom and turning Tcl into the same minefield that C becomes when pointers are overused. Because of Tcl's excellent behind-the-scenes memory management, Tcl null would be needed in far fewer places than C NULL. Its prime use would be interfacing with systems that do use null, but it's also good for representing unknowns within a script. Using a variable's existence to represent its nullity is a very good approximation, one that I think would work just fine if added to the several Tcl↔SQL interfaces we have. It works great when the response data is communicated back to the script via variables, [array]s, or [dict]s, and I'd like to see this implemented. However, it does not work when the data is stored in a list indexed by position, which is the default mode of operation for [sqlite]'s eval subcommand [http://www.sqlite.org/tclsqlite.html#eval]. This is one advantage of true null over variable existence; nulls can be stored in lists. Here's a non-SQL example of using existence to track whether or not a value is specified. I have written many scripts that work like this. foreach filename $filenames { set chan [open $filename] unset -nocomplain password while {[gets $chan line] != -1} { if {[regexp {^password=(.*)} $line _ password]} { break } } if {[info exists password]} { puts "file \"$filename\" contains password \"$password\"" } else { puts "file \"$filename\" does not contain a password" } close $chan } A null-ized version of the above would replace '''unset -nocomplain password''' with '''set password [[null]]''' and '''[[info exists password]]''' with '''![[null $password]]'''. What's the difference? In the null version, the variable's existence isn't being questioned; instead the question is about whether or not its value is known. This is a fine point, perhaps a point too fine to worth worrying about. But it is the primary difference. NEM, slebetman has pointed out that we already have null in the form of [[info exists]], and there are many places where this idiom is used (at least in my code, heh). This shows that null (the concept) is not unnecessary. Whether explicit support for null needs to be added to Tcl is a separate matter. At this point the only advantages I see that explicit null support has over variable existence are list storage, null propagation (e.g. tri-state logic), and keeping variable's existence orthogonal to its value. All three are (of course!) highly debatable. The first can be dodged by using dicts instead. The second may be a mistake and might better be implemented in pure script. The third is just a quibble for purists. [NEM]: You seem to have moved the goalposts. Are we discussing being able to represent the ''concept'' of missing/unknown data, or are we specifically discussing adding a special NULL value-which-isn't-a-string to Tcl? If you are merely concerned with the former, then yes that is an important concept, but one which is amply provided for by Tcl. (I mentioned [[info exists]] right back at the top of this page!) My point is that a NULL ''value'' is entirely unnecessary, precisely because Tcl can already deal with all of these situations. As you say, list storage can be achieved by using dicts, but also by using either the Maybe monad that I showed, or one of several other encodings (search up for my Command Name/Arguments example, showing three separate safe encodings of NULL). To try one final time to convince you that NULL (the value) isn't a good idea, what would you expect the following to print in your scheme? set a [null] set b [list foo $a bar] puts "b(2) = [lindex $b 2]" catch { puts "b = $b" } puts "b(2) = [lindex $b 2]" You have said that NULL can be stored in a list. However, you have also said that NULLs propagate: a string that contains a NULL is itself considered NULL. These two views are incompatible -- in Tcl a list is a string. So either a NULL cannot be put into a list (without the entire list becoming NULL), or NULLs do not propagate. [slebetman]: Indeed, according to [AMG]'s own definition, a list containing a null would necessarily erase all other data in the list since he defines concatenating a null with data (a string) results in null. The goalposts haven't really been moved since what is being asked is exactly what TIP185 proposes. What we're seeing here is that people are starting to realise that there are two different semantics for null which are probably incompatible with each other. Especially since [AMG] wants ''data'' null to behave like NaN and not decay to a string rep. Like I said before, the more we discuss this the more it seems to me that the various database APIs in Tcl are flawed and people want to modify Tcl instead to handle this flaw. People tried their best to frame it in general terms and avoid mentioning SQL but in the end it turns out that what is really being asked is compatibility with existing SQL API. I do think it is useful to distinguish a variable that doesn't exist and a variable that has no value. I just can't get my head around ''data'' that has no value. [DKF]: It's been said before, but here it is again. Tcl has exactly two natural representations of a NULL value. One is a variable that is ''unset'' (or [list] item that is not present, or [dict] mapping that is not present; the key concept here is of absence), and the other is the empty string. ---- [[[Category Database]|[Category Language]]]