Question: I have the following code:

```
proc list_backslash {} {

    array unset options
    array set options {
        -inputs {vdd}
        -outputs {vss}
    }

    set inputs { vdd2 vdd dvdd }
    set outputs { vss2 vss dvss }

    set updateOptions [ list \
        -inputs       $inputs \
        -outputs      $outputs ]

    array set options $updateOptions

    foreach {k v} [array get options] {
        puts "$k => $v"
    }
}

```

Since I have a lot of key-value pairs in `updateOptions`, there is a severe backslashitis! Is there a better way to do code `updateOptions`? I tried `subst` + braces `{}` and realized it does not preserve the list structure thus dooming it.

Answer: 
Generally speaking, if you need to continue a line you have to use a quoting mechanism of some kind with Tcl. Otherwise, the command call ends when the line ends. The `[`brackets`]` can include multiple statements too; it's legal, but *really not recommended*.

But that does mean that sometimes you've got awkward alternatives. Perhaps you'll be best off with doing this:

```
set updateOptions {
    -inputs       $inputs
    -outputs      $outputs
}
foreach {key value} $updateOptions {
    set options($key) [subst $value]
}

```

The `array set` command isn't especially efficient until you get to huge numbers of options (many thousands) when the code is inside a procedure.

---

Or if you've got Tcl 8.6, `dict map` is perhaps better:

```
array set options [dict map {key value} $updateOptions {subst $value}]

```

Be aware that `subst` is not a particularly efficient command in Tcl 8.6 except when used with a literal argument. That's because with variable arguments, it compiles them to bytecode at runtime.
option a) Put it all on one line.

option b) Structure the code as:

```
 set options(-inputs) $inputs
 set options(-outputs) $outputs

```

option c) Learn to like backslashes.