Updated 2015-12-16 20:44:43 by pooryorick

dict lappend appends items to a list in a dictionary.

Synopsis  edit

dict lappend dictionaryName key ?value ...?

Description  edit

Each value is appended to the list named by key in the dictionary named by dictionaryName. If key does not exist, it is created. It is legal to provide no value arguments. The dictionary is modified in-place, and it is also returned.

dict lappend for deeper nested keys  edit

HaO 2015-12-15: I would love to have a native command which does an lappend to a subdict. E.g.:
% set d {key1 {key2 value1}}
% dictlappendsub d key1 key2 value2
key1 {key2 {value1 value2}}
% dictlappendsub d key1 key3 value3
key1 {key2 {value1 value2} key3 value3}

This might be achieved by:
# dictlappendsub dict key1 ... keyn value
proc dictlappendsub {dictName args} {
    upvar 1 $dictName d
    set keys [lrange $args 0 end-1]
    if {[dict exists $d {*}$keys]} {
        dict set d {*}$keys [linsert [dict get $d {*}$keys] end [lindex $args end]]
    } else {
        dict set d {*}$keys [lrange $args end end]

PYK 2015-12-15: dict update could be put to use here:
set d {key1 {key2 value1}}
dict update d key1 key1 {
    dict lappend key1 key2 value2
    dict lappend key1 key3 value3
} ;# -> key2 {value1 value2} key3 value3
set d ;# -> key1 {key2 {value1 value2} key3 value3}

dict with could have been used to similar effect, but then there would be a risk of variable name collision.

A corresponding dictlappendsub, AKA dictnlappend, could be implemented like this:
proc dictnlappend {name keys args} {
    upvar 1 $name d
    set keys [lassign $keys[set keys {}] key]
    if {[llength $keys]} {
        dict update d $key key [list dictnlappend key $keys {*}$args] 
    } else {
        dict lappend d $key $args
    return $d

And just for fun, below is a variant that employs code generation. For deeply-nested dictionaries, bump up interp recursionlimit:
proc dictnlappend {name keys args} {
    upvar 1 $name d0
    set i [expr {[llength $keys]} - 1]
    set keys [lassign [lreverse $keys[set keys {}]] keyn]
    set body "dict lappend d$i [list $keyn] {*}\$args"
    foreach key $keys {
        set body [lreverse [list $body d$i $key d[incr i -1] update dict]]
    if 1 $body
    return $d0

Thinking about a dict with approach again, substitution can be used to pass literal values into the body of dict with to avoid a collision with the name "args", and a local name that doesn't collide with a key in the opened dictionary can be chosen for the main dictionary variable. This variant avoids recursion, and passes a pure list as the body of dict with, which saves the interpreter the trouble of parsing the body as a string:
proc dictnlappend {dictname keys args} {
    upvar 1 $dictname d
    if {![llength $args]} return 
    if {![dict exists $d {*}$keys]} {
        dict set d {*}$keys {}
    set keys1 [lrange $keys 0 end-2] 
    while {[dict exists $d {*}$keys1 d[incr i]]} {}
    upvar 1 $dictname d$i
    dict with d$i [list dict lappend {*}[lrange $keys end-1 end] {*}$args]
    set d$i