Type promotion when matching arguments for overloaded functions – PB Docs 2019

When you have overloaded a function so that one version handles
numeric values and another version handles strings, it is clear to the
programmer what arguments to provide to call each version of the
function. Overloading with unrelated datatypes is a good idea and can
provide needed functionality for your application.

Problematic overloading

If different versions of a function have arguments of related
datatypes (different numeric types or strings and chars), you must
consider how PowerBuilder promotes datatypes in determining which
function is called. This kind of overloading is undesirable because of
potential confusion in determining which function is called.

When you call a function with an expression as an argument, the
datatype of the expression might not be obvious. However, the datatype
is important in determining what version of an overloaded function is
called.

Because of the intricacies of type promotion for numeric
datatypes, you might decide that you should not define overloaded
functions with different numeric datatypes. Changes someone makes
later can affect the application more drastically than expected if the
change causes a different function to be called.

How type promotion works

When PowerBuilder evaluates an expression, it converts the
datatypes of constants and variables so that it can process or combine
them correctly.

Numbers

When PowerBuilder evaluates numeric expressions, it promotes the
datatypes of values according to the operators and the datatypes of
the other operands. For example, the datatype of the expression n/2 is
double because it involves division — the datatype of n does not
matter.

Strings

When evaluating an expression that involves chars and strings,
PowerBuilder promotes chars to strings.

For more information on type promotion, see Datatype of PowerBuilder
expressions.

Using conversion
functions

You can take control over the datatypes of expressions by
calling a conversion function. The conversion function ensures that
the datatype of the expression matches the function prototype you want
to call.

For example, because the expression n/2 involves division, the
datatype is double. However, if the function you want to call expects
a long, you can use the Long function to ensure that the function call
matches the prototype: