duck typing

AMG: In Tcl, each value's data type is implicitly determined by the operations performed on the value. This is called "duck typing" [1 ].

set data {1 2 3 4}     ;# $data is a string
llength $data          ;# $data is a list
dict size $data        ;# $data is a dict
set data 42            ;# $data is a string
expr $data             ;# $data is an expression (beware of side-effects through nested commands)
expr {$data}           ;# $data is an integer
regexp $data 4242      ;# $data is a regexp
set data expr 99     ;# $data is an integer
string length $data    ;# $data is a string

and so on.

Beware of shimmering!

AMG (conversation moved from Wikipedia, 2014-05-28): Tcl pretty much wrote the book on duck typing.

PYK 2014-05-28: I sorta thought Python wrote the book on duck typing. I think expanding the presence of Tcl on Wikipedia is a very useful activity, and hope someone finds the time to expand the duck typing article there.

MSH 2015-11-27: It appears there are no references to TCL at all on the "duck typing" [2 ] page. AMG: That is a shame. But when I said the conversation was moved from Wikipedia, I meant it was moved from the Tcl Wiki page on Wikipedia, not from the Wikipedia page on Duck Typing.

AMG: Not at all. In Python, types are intrinsic in values, whereas in Tcl, types exist only within the program's interpretation of values.

Python sees "2", 2, and (2,) as distinct, and they cannot be +'ed (added or string/list concatenated) without the programmer explicitly begging that one be converted from str to int, or vice versa, plus don't forget about unpacking single-element tuples or lists.

Tcl sees no distinction between the three (though it renders the single-element tuple (2,) as simply 2). The determination between adding or string/list concatenation is made not by the inherent type (a concept foreign to Tcl), but rather by having adding and string/list concatenation being separate operations.

With Tcl, the type is inferred according to the operations being performed on the value, and the type can freely change from moment to moment with no need for explicit conversions. The interpreter figures out the type based on what the programmer is trying to do.

set operands {"2" 2 {2}}
tcl::mathop::+ {*}$operands   ;# 6
join $operands {}             ;# 222
list {*}$operands             ;# 2 2 2

With Python, the type is explicitly declared according to how the value was constructed. Surround it in quotes, and it's a string. Put it in brackets, and it's a mutable list. Put it in parentheses with commas, and it's an immutable tuple. Put it in braces, and it's a dict. And so forth. Conversions are not automatic, and the programmer has to explicitly ask for them.

operands = ("2", 2, (2,))
def collapse(x):
    while isinstance(x, (list, tuple)):
        x = x[0]
    return x

reduce(lambda x, y: x + y, operands)                                   # cannot concatenate 'str' and 'int' objects
reduce(lambda x, y: int(collapse(x)) + int(collapse(y)), operands, 0)  # 6
reduce(lambda x, y: str(collapse(x)) + str(collapse(y)), operands, "") # '222'
reduce(lambda x, y: x + (int(collapse(y)),), operands, ())             # (2, 2, 2)
reduce(lambda x, y: x + (str(collapse(y)),), operands, ())             # ('2', '2', '2')

PYK: OK, I see where you're coming from now , and how the concept of duck typing could be applied to Tcl values , but Tcl's EIAS wonderfulness isn't what Python programmers have in mind at all by "duck typing" . They are primarily thinking about the interfaces of the objects they pass around , and the fact that clients of those objects need not inspect the type of the object , but instead can inspect the interface (method) in order to decide whether or not to work with it . I still think it would be great for the Wikipedia article to have an section about Tcl , perhaps with the title "And now for something completely different ..." ;)

AMG: Yes, Python does have duck typing in the sense that object properties or methods or whatever are late-bound and can be added, modified, or removed throughout the object's lifetime. But that's a rather limited view because the types are still bound to the objects, even if the interfaces can be changed around. In Tcl, types are purely a notational thing, and the interfaces are wholly separate from the objects (values). The EIAS section of my Brush paper summarizes Tcl's relationship with types.