Why isn't exception handling built into the "dict get" command? - tcl

Question

When dictionaries were first implemented and added to Tcl, why was the dict get command implemented in a way that allows an error to occur if an attempt is made to retrieve a value for a key that is not present in the dictionary?
This requires you to wrap the command in a catch statement every time you use it if you want to ensure that it is completely safe. It always seemed to me that a frequently used command like this would have some sort of exception handling built in.

Answer 1

It's a common design choice in Tcl (as well as some other languages). When a command like dict get (or, more commonly, open) fails, the program has to deal with it, which means it has to be alerted to the failure in some way.
The most common options is to have the failing command either
Return an out-of-domain value (such as null in languages that have it), or
Raise an exception.
(E.g. the lsearch command either returns an index value if successful and -1 if it fails (the first option). The dict get command either returns a value if successful and raises an exception if it fails (the second option).)
The first option isn't really practicable for dict get command, since there is no out-of-domain value. Any Tcl value could possibly be stored in a dictionary, so you can't look at the result of dict get and know that it has failed to find a value. The empty string is often used as a pseudo-null value in Tcl, but it's quite likely that empty strings are actual values in a dictionary.
So dict get raises an exception when it fails. It's not so bad. Exceptions have a lot of neat properties, such as taking control directly to the nearest enclosing handler regardless of how many stack levels it has to unwind.
(It's not really possible to handle all exceptions inside the command: a handler must know how to deal with the error, and dict get can't know that.)
Either way, a command that can fail needs to be wrapped in some kind of check. If the foo command is used to get a resource that might not be available and there is no sensible default, the code calling it must look either like this:
if {[set x [foo]] ne {BAD_RETURN_VALUE}} {
# use the resource
} else {
# deal with failure
}
or like this:
try {
foo
} on ok x {
# use the resource
} on error {} {
# deal with failure
}
or like this (if a predicate function predicting if foo will succeed exists):
if {[foo-will-succeed]} {
set x [foo]
# use the resource
} else {
# deal with failure
}
Which is about as much bother in each of the cases. Since out-of-domain values are rare in Tcl and error handling is so versatile, the predicate or exception strategies are usually favored.
patthoyts has already showed one way to add a error-suppressing getter function to the dict ensemble. Another relatively lightweight invocation is
set foo [try {dict get $bar xyzzy} on error {} {}]
which returns the result of the dict get call if successful and the empty string if not, and squashes any errors raised.
set foo [try {dict get $bar xyzzy} on error {} {return 42}]
This invocation sets a default return value to use on failure.
If the invocation is still bothersome, it can be made into a command:
proc dictget args {
set default {}
if {[lindex $args 0] eq {-default}} {
set args [lassign $args - default]
}
try {
dict get {*}$args
} on error {} {
set default
}
}
The synopsis for this is
dictget ?-default value? ?dictionaryValue? ?key ...?
Documentation: dict, if, proc, return, set, try

Answer 2

The dict command is implemented as an ensemble. This means you can very easily extend it yourself to achieve this. I like to call this dict get? and have it return an empty value if the key does not exist. We can add this new subcommand as follows:
proc ::tcl::dict::get? {dict key} {
if {[dict exists $dict $key]} {
return [dict get $dict $key]
}
return
}
namespace ensemble configure dict \
-map [linsert [namespace ensemble configure dict -map] end get? ::tcl::dict::get?]
As you can see this trivially wraps up the dict exists call with the dict get call but presents it as a builtin part of the dict command due to the ensemble update. In use it looks like this:
if {[dict get? $meta x-check-query] eq "yes"} {
... do stuff ...
}
(This can be seen in action in the Tcl test suite httpd test server code.)

Answer 3

I guess that is why we are provided with the dict exists command.
You might be expecting dict get to return empty string of that key element doesn't exists. But, having implementation like them will cause problem if the actual value of any key itself is an empty string.
% set demo {id {} name Dinesh}
id {} name Dinesh
% dict get $demo id
% dict get $demo age
key "age" not known in dictionary
%
Use dict exists if you want to skip catch.