Procedures in Tcl

Analogy categoryAnalogies

Defining Procedures with proc

The proc command defines a new command: proc name {arglist} {body} creates name as a callable procedure, where arglist is a list of parameter names and body is the script executed when the procedure is called. Once defined, a procedure behaves exactly like any built-in Tcl command -- it can be invoked with name arg1 arg2 ..., and Tcl checks that the number of supplied arguments matches the parameter list unless defaults or args are used. Procedures give Tcl its primary mechanism for code reuse and abstraction, similar to functions in other languages, but with Tcl's usual pass-by-value string semantics for every argument.

🏏

Cricket analogy: Defining proc runRate {overs runs} {...} is like a franchise establishing a standard net-run-rate calculation used by every analyst on the team -- once written, anyone can call it the same way a commentator invokes a known formula, without re-deriving the math each time.

Arguments, Default Values, and args

Parameters can have default values by listing them as two-element sublists in the arglist: proc greet {name {greeting "Hello"}} {puts "$greeting, $name!"} lets you call greet Bob (using the default) or greet Bob "Hi" (overriding it). Any parameter with a default must come after all required parameters. For a variable number of arguments, name the last parameter args: proc sum {args} {...} collects every remaining argument into a single Tcl list named args, which you can then process with foreach or llength/lindex.

🏏

Cricket analogy: proc greet {name {greeting "Hello"}} is like a commentator who defaults to calling every player 'the batsman' unless told their actual role, while args mirrors a scorecard command that accepts any number of trailing stats, fours, sixes, strike rate, without a fixed count.

Return Values and Variable Scope

A procedure's body runs in its own local variable scope by default: variables set inside the body, including the parameters themselves, disappear when the procedure returns and do not affect variables of the same name outside it. The return command exits the procedure immediately and supplies the value the call expression evaluates to; without an explicit return, a procedure returns the value of the last command executed in its body. To read or modify a variable from an outer scope, you must explicitly bridge scopes with global varname (for global variables) or upvar (for a variable in a specific calling frame, commonly used to implement pass-by-reference).

🏏

Cricket analogy: A procedure's local scope is like a player's individual net session -- what they practice in the nets stays there and doesn't change the actual match scoreboard, unless the coach explicitly links the drill results to the team's official stats sheet, like global.

Recursion and Building Reusable Procedures

Because Tcl procedures can call themselves, recursion works naturally: a factorial procedure like proc fact {n} {if {$n <= 1} {return 1}; return [expr {$n * [fact [expr {$n - 1}]]}]} calls fact with a smaller argument each time until it hits the base case. Each recursive call gets its own fresh local scope, so the n in one call frame is completely separate from n in another -- Tcl manages this with an internal call stack just like most languages. Combined with args for flexible arity, procedures let you build small, composable building blocks that mirror how you'd structure functions in any general-purpose language.

🏏

Cricket analogy: A recursive fact procedure calling itself with a smaller n each time is like a DRS review process that keeps zooming into smaller time windows of ball-tracking data until it hits the base case of the exact impact frame -- each level of zoom is its own independent 'call'.

tcl

proc greet {name {greeting "Hello"}} {
    return "$greeting, $name!"
}
puts [greet "Maya"]
puts [greet "Maya" "Welcome"]

proc sum {args} {
    set total 0
    foreach n $args {
        set total [expr {$total + $n}]
    }
    return $total
}
puts [sum 1 2 3 4 5]

proc fact {n} {
    if {$n <= 1} {
        return 1
    }
    return [expr {$n * [fact [expr {$n - 1}]]}]
}
puts [fact 6]

Every proc body runs in its own local variable scope, separate from the caller's and separate from every other invocation -- even for recursive calls, each active call frame has its own private copy of n (or any other local variable), which is how fact can safely call itself without one call's variables clobbering another's.

Forgetting global varname (or upvar) inside a proc is a classic beginner mistake: proc setCounter {} {set counter 0} creates and modifies a purely local counter that vanishes when the proc returns, leaving any same-named variable in the caller's scope completely untouched. If you intend to modify an outer variable, you must explicitly declare it with global or bridge to it with upvar.

proc name {arglist} {body} defines a new command that behaves like any built-in Tcl command once created.
Parameters can have default values as two-element {name default} sublists, and must be listed after all required parameters.
Naming the last parameter args collects any remaining call arguments into a single list for variable-arity procedures.
Each call to a procedure gets its own local variable scope; local variables vanish when the procedure returns.
return exits a procedure immediately with a value; without it, the value of the last executed command is returned.
global links a local name to a global variable; upvar links a local name to a variable in a specific caller's stack frame.
Procedures can call themselves recursively, with each call frame keeping independent copies of its local variables.