Implicit type conversion: Difference between revisions

Some programming languages have [[wp:Type conversion#Implicit type conversion|implicit type conversion]]. Type conversion is also known as ''coercion''.

The alternative would be to ''explicitly'' convert a value from one type to another, using a ''function'' or some other mechanism (e.g. an explicit cast).

The X and Y registers can be used as loop counters, or as an indexed offset into memory. It's very common for both to be true in the same procedure.

LDA ($00),y ;load from (the address stored at $0000) + y

STA ($02),y ;write to (the address stored at $0002) + y

iny

bne memcpy ;loop until y = 0

Any 16-bit value stored at a pair of consecutive zero-page memory addresses can be treated as a pointer to memory. The above example demonstrated this with the use of <code>($nn),y</code>.

For data registers, the operands are '''not''' sign-extended.

MOVE.W #$23,D1 ;MOVE.W #$0023,D1

The only exception to this is the <code>MOVEQ</code> instruction, which does sign-extend the value.

Address registers mostly work the same way, unless you use <code>MOVEA.W</code>, in which the address ''is sign-extended.''

MOVEA.W #$8000,A1 ;same result as MOVEA.L #$FFFF8000,A1

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.6 algol68g-2.6].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

# -*- coding: utf-8 -*- #

printf(($g$,"INT => UNION(VOID, INT) => UNION(VOID,INT,REAL,COMPL) - implicit uniting^3: ",(uuui|(INT i):i), $l$));

SKIP

{{out}}

<pre>

=={{header|Applesoft BASIC}}==

There are 7 types: reals, integers, strings, defined functions, floating point arrays, integer arrays, and arrays of strings. Implicitly there are only floating point (real) and strings.

110 PRINT M$"SIMPLE VARIABLES"M$

120 LET AB = 6728.0

320 PRINT "REAL TO STRING CONVERSION: ";AB$

330 LET AB = VAL("6728.0")

=={{header|AWK}}==

# syntax: GAWK -f IMPLICIT_TYPE_CONVERSION.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

=={{header|C}}==

main(){

/* a representative sample of builtin types */

printf("%LF was increasingly cast from %d from %d from %d from %d from %d bytes from '%c'\n",

llf=(lf=(i=(si=c))), sizeof llf, sizeof lf, sizeof i, sizeof si,sizeof c, c);

{{out}}

<pre>

=={{header|C sharp}}==

C# has built-in implicit conversions for primitive numerical types. Any value can be implicitly converted to a value of a larger type. Many non-primitive types also have implicit conversion operators defined, for instance the '''BigInteger''' and '''Complex''' types.

short aShort = aByte;

int anInt = aShort;

BigInteger b = 5;

Complex c = 2.5; // 2.5 + 0i

Users are able to define implicit (and also explicit) conversion operators. To define a conversion from A to B, the operator must be defined inside either type A or type B. Therefore, we cannot define a conversion from '''char''' to an array of '''char'''.

{

//Define an implicit conversion from string to Person

Console.WriteLine(p);

}

{{out}}

<pre>

C++ supports almost all of the same implicit conversions as the [[Implicit_type_conversion#C|C]] example above. However it does not allow implicit conversions to enums and is more strict with some pointer conversions. C++ allows implicit conversions on user defined

types. The example below shows implicit conversions between polar and Cartesian points.

#include <math.h>

std::cout << "rho=" << pp1.rho << ", theta=" << pp1.theta << "\n";

std::cout << "x=" << cp2.x << ", y=" << cp2.y << "\n";

{{out}}

<pre>

=={{header|D}}==

This covers a large sample of built-in types and few library-defined types.

import std.stdio, std.typetuple, std.variant, std.complex;

void function() f6 = &spam; // OK.

//void function() f7 = &foo; // Not allowed.

{{out}}

<pre>On a 32 bit system:

Delphi has in implicit conversions for primitive numerical types. Any value can be implicitly converted to a value of a larger type.

Upsize conversions:

ValueByte : Byte := 2; // (8 bits size)

ValueWord : Word := ValueByte; // 2 (16 bits size)

ValueDWord : DWord := ValueWord; // 2 (32 bits size)

ValueUint64 : Uint64 := ValueWord; // 2 (64 bits size)

Unsigend-signed conversions

ValueDWord := 4294967295; // 4294967295 (Max DWord value (unsigned))

ValueInteger : Integer := ValueDWord; // -1 (two complement conversion) (signed)

ValueDWord := ValueInteger; // 4294967295 (convert back, unsigned)

Unsigned variables will not convert literal negative values

ValueByte := -1; // this not work, and raise a error

ValueByte := byte(-1); // this work, and assign 255 (max byte value)

Float points can convert integers values, may lose precision for large integers

ValueDWord := 4294967295; // 4294967295 (Max DWord value (unsigned))

ValueDouble : Double := ValueDWord; // 4.29496729500000E+0009

Integers can not convert float values implicity

ValueDouble := 1.6;

ValueByte := ValueDouble; // this not work, and raise a error

ValueByte : Trunc(ValueDouble); // this work, and assign 1

ValueByte : Round(ValueDouble); // this work, and assign 2

Strings can convert chars, but not convert back

ValueChar: Char := #10;

ValuesString: String := ValueChar;

Boolean can not convert any type implicity, except it self

ValueBoolean: Boolean := True; // this work, and assign True

ValueBoolean: Boolean := 1; // this not work, and raise a error

ValueBoolean := Boolean(-1); // this work, and assign true

ValueBoolean := Boolean( 0); // this work, and assign false

Variant types can implicit convert allmost types, and convert back, if possible:

ValueVariant: Variant := -20;

ValueVariant := 3.1416;

ValueVariant := True;

...

Class and Record can implement implicit operator

program Implicit_type_conversion;

readln;

=={{header|Déjà Vu}}==

The only implicit conversion currently permitted is boolean to number:

<2:1> !. + 3 true #boolean true is equal to 1

4

<3:1> !. * 2 false #boolean false is equal to 0

All ZString expressions, including string literals and dereferenced ZString Ptrs, will be given the String variable type.

Var b = Cast(Short, 1)

Var c = Cast(Integer, 1)

Print

Print "Integer: "; ii

{{out}}

<pre>Byte: 1

Some simple examples may help to make this clearer.

import "fmt"

m := 0.3 + float64(l) + 0.7

fmt.Printf("m : type %-7T value %g\n", m, m)

{{out}}

Idris provides the "[http://docs.idris-lang.org/en/latest/tutorial/miscellany.html#implicit-conversions implicit]" keyword which enables the implicit conversion from one type to another.

boolToInt : Bool -> Int

boolToInt True = 1

two : Int

=={{header|J}}==

The rich j datatypes:

datatype NB. data type identification verb

3 : 0

2 2 │ 2

3 3 │ 2

J has verbs causing explicit conversion. Some appear in the above examples.

=={{header|Java}}==

The Java Language Specification includes several varieties of implicit type conversion. This code illustrates: <ul><li>widening conversions of primitives</li><li>boxing and unboxing conversions</li><li>string conversions (with the + operator)</li></ul>

public static void main(String...args){

System.out.println( "Primitive conversions" );

}

}

{{out}}

<pre>

However, if one were to define "is_integer" as follows:

then one would find:

For reference, jq's builtin types are "number", "boolean", "null", "object" and "array".

=={{header|Julia}}==

In general, Julia will promote a smaller sized datatype to a larger one when needed for a calculation involving mixed data types. Julia also accepts type annotations on variable declarations as shown below, though such type declarations are usually only allowed for variables that are declared within a function.

julia> function testme()

ui8::UInt8 = 1

julia> testme()

(0x01, 1, 0x0001, 2, 0x00000001, 4, 0x0000000000000001, 8, 1.0, 8)

=={{header|Kotlin}}==

If follows from this that there are no implicit conversions (even 'widening' conversions) between the numeric types because there is no inheritance relationship between them. However, there is one exception to this - integer literals, which would normally be regarded as of type Int (4 bytes) can be assigned to variables of the other integral types provided they are within the range of that type. This is allowed because it can be checked statically by the compiler.

open class C(val x: Int)

val n : Int? = c.x // OK because Int is a sub-class of its nullable type Int? (c.x is boxed on heap)

println(n)

{{out}}

For the most part, Lua is strongly typed, but there are a few cases where it will coerce if the result would be of a predictable type.

Coercions are never performed during comparisons or while indexing an object.

type(123 .. "123") --> string

type(123 + "123") --> number

-- As in many languages, all types can be automatically coerced into their boolean value if required. Only nil and false will coerce to false

The only two explicit conversion functions offered by Lua are <code>tonumber</code> and <code>tostring</code>.

=={{header|M2000 Interpreter}}==

Module Checkit {

Long a=12.5

}

Checkit

=={{header|Nim}}==

Here are some examples:

const A = 1 # "1" is considered as as int, so this is the type of "x".

const B: float = 1 # Implicit conversion from int to float done by the compiler.

echo 1 + true # Displays 2.

=={{header|Oforth}}==

Let's create a Complex class with 80 as priority (please note asComplex methods that will be used for conversions) :

Complex method: re @re ;

Complex new(@re n /, @im neg n / ) ;

Usage :

Complex new(2, 3) 1.2 + println

Complex new(2, 3) 1.2 * println

{{out}}

=={{header|Pascal}}==

var

i: integer;

i := 42;

r := i { integer → real }

{{works with|Extended Pascal}}

var

c: char;

r := 123.456;

x := r { real → complex }

All available implicit conversions are applicable when providing parameters to a routine call.

For instance the Extended Pascal function <tt>im</tt> intended to return the imaginary part of a <tt>complex</tt> number can be called with an <tt>integer</tt> value.

=={{header|Perl}}==

Perl is the original DWIM language, implicit type conversion is the default mode of operation. Perl does not have static types; the concept of distinct integers/strings/floats is not present. Instead, operators defines how the operands will behave. An operator that requires a string coerces its operand into a string, an operator that requires an integer coerces its operand into an integer, and so forth.

print '1' + '2'; # 3

print 1 . 1; # 11

# Even if you intentionally jumble the expected roles of numbers and strings, thing just work out

On the other hand, since Perl gives you a lot of rope, you have to be careful what you do with it. The expression

If a string character (or slice) is replaced with any value that will not fit in a byte, it is automatically

converted to a dword_sequence, eg

<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"this"</span>

<span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">3</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">PI</span> <span style="color: #000080;font-style:italic;">-- s is now {'t','h',3.1415926,'s'}</span>

Phix does not, or at least tries very hard not to "drop bits" or "clock round". 1/3 is 0.333333 not 0, 0-1 is

-1 not +#FFFFFFFF, in all cases, with a plain english fatal run-time error should a type check occur, as would occur above were s defined as a string instead of a sequence.

=={{header|Python}}==

Python does do some automatic conversions between different types but is still considered a strongly typed language. Allowed automatic conversions include between numeric types (where it makes sense), and the general rule that empty container types as well as zero are considered False in a boolean context.

from decimal import Decimal, getcontext

getcontext().prec = 60

except BaseException:

ans = 'EXCEPTION RAISED!'

{{out}} (Elided due to size)

=={{header|Racket}}==

The only automatic conversions are in the numeric tower. The common case is in some operations like <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, when one of the arguments is of a different type of the other argument. For example, in all the following cases the fixnum <code>1</code> is added to more general kinds of numbers.

(+ 1 .1) ; ==> 1.1

(+ 1 1/2) ; ==> 3/2

(+ 1 (expt 10 30)) ; ==> 1000000000000000000000000000001

=={{header|Raku}}==

The type of object contained in a scalar depends on how you assign it and how you use it.

$x = 1234; say $x.WHAT; # (Int) Integer

$x = {1, 2}; say $x.WHAT; # (Block)

$x = sub {1}; say $x.WHAT; # (Sub) Code Reference

Objects may be converted between various types many times during an operation. Consider the following line of code.

In English: Take the floor of the square root of the sum of the ordinals of the digits of the integer 1234, concatenate that number with the string 'beef', interpret the result as a hexadecimal number and print it.

Broken down step by step:

$x = 1234.ords; say $x, ' ', $x.WHAT; # 49 50 51 52 (List)

$x = [+] 1234.ords; say $x, ' ', $x.WHAT; # 202 (Int)

$x = ([+] 1234.ords).sqrt.floor; say $x, ' ', $x.WHAT; # 14 (Int)

$x = ([+] 1234.ords).sqrt.floor ~ "beef"; say $x, ' ', $x.WHAT; # 14beef (Str)

(A normal Rat number has a denominator that is limited to 64 bits, with underflow to floating point to prevent performance degradation; a FatRat, in contrast, has an unlimited denominator size, and can chew up all your memory if you're not careful.)

$x = (-1).sqrt; say $x, ' ', $x.WHAT; # NaN (Num)

$x = (-1).Complex.sqrt; say $x, ' ', $x.WHAT; # 6.12323399573677e-17+1i (Complex)

$x /= 10**10; say $x, ' ', $x.WHAT; # 0.000000000629 (FatRat)

$x /= 10**10; say $x, ' ', $x.WHAT; # 0.0000000000000000000629 (FatRat)

User defined types will support implicit casting if the object has Bridge method that tells it how to do so, or if the operators in question supply multiple dispatch variants that allow for coercions.

╚═══════════════════════════════════════════════════════════════════════════════════╝

</pre>

digs=digits() ; say digs /* 9, the default.*/

a=1e+003 ; b=0 ; x=a+b ; say x /* 1000 */

a=12345678912 ; say a /* 123456789012 */

'''output'''

<pre>

=={{header|Sidef}}==

Since version 3.00, all the number types (int, rat, float and complex) are unified in the ''Number'' class and all the needed conversions are done implicitly. Methods from other classes also make implicit conversions where possible.

> "1"+2 #=> 12

> sqrt(-4) #=> 2i

> ("a" + [1,2]) #=> a[1,2]

> ('ha' * '3') #=> hahaha

=={{header|Tcl}}==

The only true explicit type conversion operations are some of the functions in the expression sub-language (<code>int()</code>, <code>double()</code>, etc.).

incr someVar $value

expr {$value + 3.5}

string length $value

llength $value

dict size $value

There are many other value types (command names, variable names, subcommand index names, etc.) but user code would not normally seek to explicitly convert to those.

However, you can define implicit conversions for user defined types. For example, BigInts can be generated from integral Nums or Strings and, when doing operations on BigInts, values of these types are automatically converted to BigInts so the operations can succeed.

var b1 = BigInt.new(32)

var b3 = b1 + b2 + 2 + "2"

=={{header|Z80 Assembly}}==

When a constant or 16-bit register is used as an operand and is in parentheses, it is treated as a pointer to memory for that instruction only. The type of the data pointed to depends on the instruction.

LD A,(HL) ;load the byte stored at memory address 0x4000 into A.

'''Note:''' The Game Boy cannot use 16-bit constant pointers, with two exceptions:

The individual 8-bit registers that form a register pair can be operated on separately, or as a single 16-bit value.

INC B ;BC = $1334

INC C ;BC = $1335

=={{header|zkl}}==

Type conversions usually just happen (ie the object knows what it wants and attempts to convert) but sometimes the conversion needs to be explicit (ie the conversion is ambiguous, the object doesn't know about the other type or is too lazy to convert).

3

zkl: "1"+2

zkl: T("one",1,"two",2).toDictionary().toList().toDictionary()

D(two:2,one:1)

{{omit from|6502 Assembly}}