Call TCL proc with named arguments

Question

Given this proc:

proc foo {{aa "a"} {bb "b"} cc} {
  echo $cc
}

Is it possible to call proc foo and only pass a value for cc? Also, is it possible to pass a value to cc explicitly by name?

Everything I see suggests that all arguments must be passed by position.

Oolite

Similar to this question: https://mcmap.net/q/1601937/-how-can-i-safely-deal-with-optional-parameters/7552 – Joyous

Answer 1

I would do something like Tk does:

proc foo {cc args} {
    # following will error if $args is an odd-length list
    array set optional [list -aa "default a" -bb "default b" {*}$args]
    set aa $optional(-aa)
    set bb $optional(-bb)

    puts "aa: $aa"
    puts "bb: $bb"
    puts "cc: $cc"
}

then

% foo
wrong # args: should be "foo cc ..."
% foo bar
aa: default a
bb: default b
cc: bar
% foo bar -bb hello -aa world
aa: world
bb: hello
cc: bar

Joyous

I'd use two array sets like this: array set optional {-aa "default a" -bb "default b"}; array set optional $args – Calie

Answer 2

You can use type shimmering to avoid constructing the dict..and this gives an interestingly simple and intuitive call. Pass the list representation of the dict to the proc e.g.:

  proc foo {a} {
      if {[dict exists $a cc]} {
          puts [dict get $a cc]
      }
  }

  foo {cc "this is the cc argument value" dd "this is the value of dd}

Acidophil

Answer 3

Arguments to procedures are passed by position. The use of two element lists as a component of the argument list, e.g. {aa a}, is to supply a default value. However as the manual says:

Arguments with default values that are followed by non-defaulted arguments become required arguments. In 8.6 this will be considered an error.

So, most people design their procedure interfaces to place the arguments that supply a default value at the end of the argument list.

One way to simulate named arguments is to design the procedure to take a single argument that is a dictionary value where the keys of the dictionary are the names of the parameters. For example,

proc foo {a} {
    if {[dict exists $a cc]} {
        puts [dict get $a cc]
    }
}

foo [dict create cc "this is the cc argument value"]

If you don't mind the tedium of determining which optional parameters are supplied and the tedium of building a dictionary to invoke the procedure, then you can simulate named arguments this way and achieve some flexibility in supplying arguments to procedures. I don't use this technique very often myself. I find it easier to design the procedure interfaces more carefully. But sometimes the circumstances warrant all sorts of things.

Benitez