Next: TC-A Given Code, Up: TC-A [Contents][Index]
Overloaded functions are not supported in regular Tiger.
let
function null(i: int) : int = i = 0
function null(s: string) : int = s = ""
in
null("123") = null(123)
end
$ tc -Xb sizes.tig error→sizes.tig:3.3-41: redefinition: null error→sizes.tig:2.3-40: first definition ⇒4
Instead of regular binding, overloaded binding binds each function call to the set of active function definitions. Unfortunately displaying this set is not implemented, so we cannot see them in the following example:
$ tc -X --overfun-bindings-compute -BA sizes.tig
/* == Abstract Syntax Tree. == */
function _main /* 0x55940eca7890 */() =
(
let
function null /* 0x55940eca7c20 */(i /* 0x55940ecaa700 */ : int /* 0 */) : int /* 0 */ =
(i /* 0x55940ecaa700 */ = 0)
function null /* 0x55940eca8610 */(s /* 0x55940eca9ce0 */ : string /* 0 */) : int /* 0 */ =
(s /* 0x55940eca9ce0 */ = "")
in
(null /* 0 */("123") = null /* 0 */(123))
end;
()
)
The selection of the right binding cannot be done before type-checking, since precisely overloading relies on types to distinguish the actual function called. Therefore it is the type checker that “finishes” the binding.
$ tc -XOBA sizes.tig
/* == Abstract Syntax Tree. == */
function _main /* 0x55ce2d384890 */() =
(
let
function null /* 0x55ce2d386ed0 */(i /* 0x55ce2d385e00 */ : int /* 0 */) : int /* 0 */ =
(i /* 0x55ce2d385e00 */ = 0)
function null /* 0x55ce2d384b00 */(s /* 0x55ce2d3850a0 */ : string /* 0 */) : int /* 0 */ =
(s /* 0x55ce2d3850a0 */ = "")
in
(null /* 0x55ce2d384b00 */("123") = null /* 0x55ce2d386ed0 */(123))
end;
()
)
There can be ambiguous (overloaded) calls.
let
type foo = {}
function empty(f: foo) : int = f = nil
type bar = {}
function empty(b: bar) : int = b = nil
in
empty(foo {});
empty(bar {});
empty(nil)
end
$ tc -XO over-amb.tig
error→over-amb.tig:9.3-12: nil ambiguity calling `empty'
error→matching declarations:
error→ empty @
error→ {
error→ f : foo =
error→ {
error→ }
error→ }
error→ empty @
error→ {
error→ b : bar =
error→ {
error→ }
error→ }
⇒5
The spirit of plain Tiger is kept: a “chunk” is not allowed to redefine a function with the same signature:
let function foo(i: int) = () function foo(i: int) = () in foo(42) end
$ tc -XO over-duplicate.tig error→over-duplicate.tig:3.3-27: function complete redefinition: foo error→over-duplicate.tig:2.3-27: first definition ⇒5
but a signature can be defined twice in different blocks of function definitions, in which case the last defined function respecting the calling signature is used..
let
function foo(i: int) = ()
in
let
function foo(i: int) = ()
in
foo(51)
end
end
$ tc -XOBA over-scoped.tig
/* == Abstract Syntax Tree. == */
function _main /* 0x55818121a110 */() =
(
let
function foo /* 0x55818121bed0 */(i /* 0x55818121ae00 */ : int /* 0 */) =
()
in
let
function foo /* 0x55818121a230 */(i /* 0x55818121a0a0 */ : int /* 0 */) =
()
in
foo /* 0x55818121a230 */(51)
end
end;
()
)
Next: TC-A Given Code, Up: TC-A [Contents][Index]