Expanding the Expansion prefix - Concept of protocol

This page is to complete the reflexion about a generalization of the braced-prefix syntax.

While existing before, but differently, in cloverfield project, this idea came through some references pages :

• Proposal of syntax, expressiveness and semantic improvements with annotations
• Expanding the Expansion Prefix
• Expanding the Expansion prefix - example 1

In these pages, we saw that this syntax could help in defining new possibilities at many levels.

• In the parser step, it could help, for instance, to define inline commentaries.
• For variables, it could help to define their type.
• For commands, it could help to « tag » the words they recieve, what can be usefull to modulate their algorithm.

Protocol analogy

Protocol come for the ancient greek word « πρωτόκολλον », protókollon, composed of πρῶτος, prỗtos (« first ») et de κόλλα, kólla (« glue »).

Think about how we send a letter : We put the message into an envelope, on which you can glue a label to indicate its correct destination, and eventually other informations (ask for aknowledgment,..etc)

Then we can make this analogy : If a Tcl_Obj is taken like the envelope of a message (which is its value), we can take any « braced-prefix », puts in front of it, like a label glued on top of the envelope : From this point of view, a braced-prefix appear to be, literally, a protocol.

For instance :

• The {*} expansion prefix is a protocol that indicate the Tcl-Parser to act in a certain manner with what follows it.
• The type of a variable is like a protocol which indicate how to use a variable : that justifies it could be interesting to use some braced-prefixes to indicate the type of a variable.
• A command may use its arguments in many ways : It could be convenient to use protocols as algorithm modulators.

Usage of the analogy

Protocol as type of variable

I have expansively explorated the braced-prefix concept seen as variable type in the above related pages.

Protocol as modulation of algorithm - example of the proc command

Now, let's discuss about the other usage of it, as modulation of handling command argument, with an important example.

The one that came into my mind concerns the « proc » command.

The proc command takes 3 arguments : Name, Argument, Body.

Modulating how proc handles its arguments

It exists some TIP to introduce distinct ways of interpreting proc arguments.

• TIP 572 : Implement a mechanism to specify the procedure/lambda/method argument call types (Evaluation strategy)
• TIP 479 : Add Named Procedures as a New Command in Tcl (dictargs::proc)
• TIP 457 : Add Support for Named Arguments

Some work has been done to adress these needs. Discussions and works on this subject can be found in these pages :

• Command option parsing
• parse_args
• argparse
• optproc

The problem is that the proc interface is expansively used. Any change in it could drive Tcl in big problems. Many strategies has been imagined. Either create new variants of proc command, either create a command to be called inside the proc. In fact, people just want to modulate the way proc can handle its arguments, but without changing too much its interface.

A very refine way to specify arguments has the drawback that it will complicate it too much for the basic case. Creating new variants of the proc command would increase the number of basic Tcl command to learn.

As the goal is only to modulate the arguments evaluation strategy, it is natural to introduce here the concept of protocol. What protocol should follow the proc command to evaluate its arguments ? As we saw, a braced-prefix, that is a syntax backward-compatible construct, can be thought like a protocol, it seems natural to me that some braced-prefixes could be usefull here. The proc interface could be set as following :

proc name_of_proc {argProtocol}args body

Of course, by default, if no argProtocol braced-prefix is present, the arguments of proc will have to be taken as positionnal, as usual. But if we could define at script-level some additional argProtocol, this could make the job. For example :

protocol config proc args named parse_args
proc MyProc {named}args body

Modulating how proc handle its body

Moreover, it exists on the wiki some variants of proc, whose goal is to change the way the body is compiled. For instance there is :

• vproc in vecTcl that expect a body written in a mathematical syntax.
• cproc in Critcl that expect a body written in C.

To say, many ways are possible in the interpretation of a proc body. That could justify the introduction of specific protocols, by braced-prefixes, on the body argument.

If this could be configured at the script level, for instance like :

protocol config proc body = vecTcl::vproc

proc mean array {=}{
   # a VecTcl procedure to compute the mean of a vector possibly having NaN elements
   isNumber = array == array
   length = shape(isNumber)
   j = 0
   for i=0:length-1 {
      if (isNumber[i] == 1) {j = j + array[i]}
   }
   if (j == 0) {
      j
   } else {
      j/sum(isNumber)
   }
}

mean {1 2 3 NaN 5 NaN}

This would allow a whole new kinds of opportunities, like import the body of any procedure or function from any language that Tcl is bridgeable to.

Enforcing the proc return type

Finally, I noticed some demands about getting the possibility to configure the return type of a procedure, to be able to make some optimisations on the fly in the compilation step of the code. This could be set by a braced-prefix put in front of the proc name, it will indicate the protocol to follow to check its return value.

A new proc interface, backward-compatible

At the end, it appears that every arguments of the proc command could be « brace-prefixed ». The interface of the proc command then would be changed like this :

proc {returnType}myProc {argProtocol}myArgs {bodyProtocol}myBody

Whereas this proc command would be backwards-compatible, we could introduced an infintiy of new ways to use it :

• We could enforced its return type.
• We could have many manners to configure its calling interface, by modulating its argument handling.
• We could have many manners to configure its compilation. « Mathematical syntax », « C », « Rust », « Python », « javascript » ... allmost any language where it exists a bridge with Tcl could be used.

Of course, a new chapter would have to be introduced in the documentation, concerning protocols.

Synthesis

Here is a table to summerize the usage of prefix protocols.

gold 01/19/2026. Added categories, so can find message in Wiki. Original author appears to be FM from history log.

protocol config proc args > {...}
protocol config proc args < {...}
proc MyProcLR {>}{} {}
proc MyProcRL {<}{} {}

proc MyProcLR {>}{
{#}My\ commentary
} {}

proc MyProcLR {>}{
{!}widget
{?}option
} {}

{{?}@(-optionName)}optionName

# optional named argument.
{{{?}@}-}optionName
# mandotary named argument.
{{{!}@}-}optionName
# optional boolean flag
{{?}-}optionName
# mandotary boolean flag.
{{!}-}optionName

{#}{4 option flags, 4 possible values for 1 variable}
{{?}-(ascii,dictionnary,integer,real)}compare_as

proc glob {>}{
{#}{optional -directory option : check the url validity and set its value to the directory varname}
{{{{?}@}-}url}directory
...
} $body

proc entry {>}{
....
{#}{optional "-state" option is to indicate the 3 states of the entry. The value must be either "normal", "disable" or "readonly"}
{{{{?}@}-}string(normal,disable,readonly)}state
...
} $body

proc entry {>}{
{#}{optional option -textvariable : introduce the name of a variable whose value is to be the image of the entry content}
{{{{?}@}-}&}textvariable
} $body

proc entry {>}{
{#}{optional -width option : width of the widget}
    {{{{?}@}-}int}width\ 0
}

proc lsort {>}{
    {#}modality\ of\ comparaison
    {?-(ascii,dictionnary,integer,real)}compare_as\ ascii
    {#}a\ command
    {?@-}command
    {#}order\ of\ sorting
    {?-(increasing,decreasing)}order\ increasing
    {?@-}indices
    {?@-}index
    {?@-}stride
    {?-}nocase\ 0
    {?-}unique\ 0
    {!}list
} $body

proc glob {>}{
    {{?@-}url}directory
    {?-}join
    {?-}nocomplain
    {{?@-}url}path
    {?-}tail
    {{?@-}list}types
    {?-}-\ 0
    {!}pattern
} $body

proc regexp {>}{
    {?-}about
    {?-}expanded
    {?-}indices
    {?-}line
    {?-}linestop
    {?-}nocase
    {?-}all
    {?-}inline
    {?-}start
    {?-}-\ 0
    {!}regexp
    {!}string
    {?}matchvar
    {args}submatchvar
} $body

proc using_parse_args {>}{
    {!@-}title
    {?@-}{category {}}
    {!@-}wiki
    {?@-}rating
} $body

proc entry {>}{
    {!}widget
    {?@-}disabledbackground\ {}
    {?@-}disabledforeground\ {}
    {?@-}invalidcommand\ {}
    {?@-}readonlybackground\ {}
    {{?@-}char}show
    {{?@-}string(normal,disable,readonly)}state\ normal
    {{?@-}string(focus,focusin, focusout, key, all)}validate\ none
    {?@-}validatecommand
    {{?@-}int}width\ 0
    {{?@-}&}textvariable
} $body