Name
SPVM::Document::Language::Types - Types in the SPVM Language
Description
This document describes types in the SPVM language.
Data
This section describes some typical data.
Numeric Value
String
SPVM has the string type. A string is created by "String Literal" "String Creating Operator" or "Type Convertion" to the string type.
# Create a string using a string literal
my $string = "Hello";
# Create a string using a string creation operator
my $string = new_string_len 3;
# Create a string using the type cast to the string type
my $bytes = [(byte)93, 94, 95];
my $string = (string)$bytes;
The each charcter can be get using ->[]
.
# String
my $string = "Hello";
my $char0 = $string->[0];
my $char1 = $string->[1];
my $char2 = $string->[2];
By default, each character cannnot be set.
# a compilation error.
$string_const->[0] = 'd';
If you use mutable type qualifier|/"mutable Type Qualifier"
, each character can be set.
my $string_mut = (mutable string)$string;
$string_mut->[0] = 'd';
The created string is one more last byte that value is \0
on the internal memory. Although this has no meaning from SPVM language, this has meaning from Native APIs.
The length of the string can be got using a string length operator
# Getting the length of the string
my $message = "Hello"+
my $length = length $message;
At the native level, the character just after the last character of the string is set to \0
, so the characters in the string can be used as a C language string.
# The characters in the string can be used as a C language string
void* obj_string = stack[0].oval;
const char* chars = env->get_chars(env, stack, obj_string);
if (strcmp(chars, "Hello") == 0) {
}
Array
The array is the data structure for multiple values.
There are the following types of array.
- Numeric Array
- Object Array
- Multi-Numeric Array
The numeric array is the array that the type of the element is the numeric type.
The object array is the array that the type of the element is the object type.
The multi-numeric array is the array that the type of the element is the multi-numeric type.
See "Creating Array" to create Array.
Array Access
Array Access is an operator to access the element of Array to get or set the value.
ARRAY->[INDEX]
See "Getting Array Element" to get the element value of Array.
See "Setting Array Element" to set the element value of Array.
Multi-Numeric Value
A multi-numeric value is a value that represents continuous multiple numeric values in memory.
Multi-Numeric Array
The multi-numeric values can be the elements of the array.
my $zs = new Complex_2d[3];
The elements of the multi-numeric array is continuous multi-numeric values.
| Complex_2d | Complex_2d | Complex_2d |
| re | im | re | im | re | im |
Multi-Numeric Array Access
The multi-numeric array access is a syntax to access the element of the multi-numeric array.
ARRAY->[INDEX]
See "Getting Array Element" to get the element of the array.
See "Setting Array Element" to set the element of the array.
Object
A object is created by the new operator.
Undefined Value
An undefined value is created by the undef operator.
undef
The type of an undefined value is the undef type.
An undefined value is able to be assigned to an object type.
In native classes, an undefined value is equal to 0, normally a null pointer NULL
defined in stddef.h
.
NULL
Examples:
# Examples of undefined values
my $string : string = undef;
if (undef) {
}
my $message = "Hello";
if ($message == undef) {
}
Reference
The reference is the address of a local variable on the memory.
Creating Reference
The reference operator creates the reference of a local variable.
A reference is assigned to the "Reference Type" in reference type.
The operand of a reference operator must be the variable of a numeric type or a multi-numeric type.
# The reference of numeric type
my $num : int;
my $num_ref : int* = \$num;
# The reference of multi-numeric type
my $z : Complex_2d;
my $z_ref : Complex_2d* = \$z;
The reference type can be used as the types of the arguments of a method.
# Method Definition
static method sum : void ($result_ref : int*, $num1 : int, $num2 : int) {
$$result_ref = $num1 + $num2;
}
# Method Call
my $num1 = 1;
my $num2 = 2;
my $result_ref = \$result;
sum($result_ref, $num1, $num2);
Dereference
The dereference is the operation to get the value from a reference.
A dereference operator perform a dereference.
# Get the value using a dereference
my $num2 = $$num_ref;
# Set the value using a dereference
$$num_ref = 3;
# Get the value of a multi-numeric type using a dereference
my $z2 = $$z_ref;
# Set the value of a multi-numeric type using a dereference
$$z_ref = $z2;
In the referencec of multi-numeric types, the deference can be performed using the arrow operator ->
.
# Get a field of a multi-numeric type using a dereference
my $x = $z_ref->{re};
# Set a field of a multi-numeric type using a dereference
$z_ref->{re} = 1;
Types
The SPVM language is a programming language with static types.
Numeric Types
The numeric type are an integer type and "Floating Point Types".
Numeric Types Order
a numeric type has the type order. The order is "byte", "short", "int", "long", "float", "double" from the smallest.
Integer Types
Integral types are the following four types.
Type | Description | Size |
---|---|---|
byte | signed 8-bit integer type | 1 byte |
short | signed 16-bit integer type | 2 bytes |
int | signed 32-bit integer type | 4 bytes |
long | signed 64-bit integer type | 8 bytes |
Note that SPVM has only singed integer types, and doesn't have unsigned integer types.
byte Type
byte
type is an integer type that represents a signed 8-bit integer. This is the same type as int8_t
type of the C language.
short Type
short
type is an integer type that represents a signed 16-bit integer. This is the same type as int16_t
type of the C language.
int Type
int
type is is an integer type that represents signed 32-bit integer. This is the same as int32_t
type of the C language.
long Type
long
type is an integer type that represents a signed 64-bit integer. This is the same type as int64_t
type of the C language.
Integer Types within int
The integer type within int
is an integer type within the int type.
In other words, the integer types within int
are the byte type, the short type, and the int type.
Floating Point Types
Floating Point Types are the following two.
Type | Description | Size |
---|---|---|
float | Single precision (32bit) floating point type | 4 bytes |
double | Double precision (64bit) floating point type | 8 bytes |
float Type
The float
type is a floating point type that represents a single precision(32bit) floating point. This is the same type as float
type of the C language.
double Type
The double
type is a floating point type that represents a double precision(64bit) floating point. This is the same type as double
type of the C language.
Object Types
Object types are class types, interface types, the string type, the any object type and array types.
string Type
The string
type is a type for the "String".
string
string
type can be qualified by "mutable Type Qualifier".
mutable string
Examples:
# string type
my $message : string = "Hello";
my $message : mutable string = new_string_len 256;
Class Type
The class type is the type that can create the object using a new operator.
new ClassType;
Numeric Object Types
A numeric object type is the object type that is corresponding to the numeric type.
The list of numeric object types:
Numeric Object Types | Corresponding Numeric Types |
---|---|
Byte | byte |
Short | short |
Int | int |
Long | long |
Float | float |
Double | double |
See also the boxing conversion and "Unboxing Conversion".
Interface Type
The interface type is a type that is defined using a class
keyword and a class attribute interface_t
.
class Stringable : interface_t {
method to_string : string ();
}
See also "Interface".
Note that interface types are not class types although they are defined by class
keyword.
Any Object Type
Any object type is represented by "object". Designed to represent the "void *" type in C.
my $object: object;
You can methodstitute the value of "Object Types" for Any Object Type.
my $object: object = new Foo;
my $object: object = "abc";
my $object: object = new Foo [3];
Basic Types
A basic type is a type whose type dimension is 0 and which can be an element of an array.
Basic types are numeric types, multi-numeric types, class types, the any object type, and the string type.
undef Type
The undef type is the type of an undefined value.
void Type
void Type is a special type that can only be used in the return type of the method definition and indicates the method has no return value.
void
Array Types
The array type is the type for the array. The array type is composed of the basic type and the dimension such as []
, [][]
.
# Numeric array
int[]
double[]
# String array
string []
# Class array
Point[]
# Any object array
object[]
# 2 dimensional array
int[][]
# 3 dimensional array
int[][][]
The array type is an object type.
Compilation Errors:
The maximam value of dimesions is 255. Otherwise a compilation error occurs.
Numeric Array Type
The numeric array type is an array type for the array of the numeric type.
The list of the numeric array.
byte[]
short[]
int[]
long[]
float[]
double[]
Each element are initialized by the "Type Initial Value" in initial value when the creating array is performed.
byte[] Type
The byte[]
type is an array type that the element type is byte
.
byte[]
Object Array Type
Object array types are the array type that the type of the element is an object type.
Examples:
# Object array types
my $points : Point[];
my $points_2dim : Point[][];
my $stringables : Stringable[];
my $strings : string[];
my $objects : object[];
String Array Type
String array types are the array type that the type of the element is the string type.
Examples:
# String array types
my $strings : string[];
Class Array Type
Class array types are the array type that the type of the element is the class type.
Examples:
# Class array types
my $points : Point[];
Interface Array Type
Interface array types are the array type that the type of the element is the interface type.
Examples:
# Interface array types
my $stringables : Stringable[];
Multi-Dimensional Array Type
The multi-dimensional array type is the array type that the type of the element is an array type.
Examples:
# Multi-dimensional array types
my $nums_2dim : Int[][];
Multi-Numeric Array Type
A multi-numeric array type is an array type that the basic type is a multi-numeric type.
- Complex_2d[]
- Complex_2f[]
The byte size of the element is the total byte size of the fields of the multi-numeric type.
For example, The byte size of the element of Complex_2d is 16 bytes (2 * 8 bytes).
The object of the multi-numeric array type can be created by the new operator.
my $complex_nums = new Complex_2d[10];
Any Object Array Type
The any object array type object[]
is the type that any object array type can be assigned.
# Any object array Type
my $array : object[] = new Point[3];
my $array : object[] = new object[3];
my $array : object[] = new Point[][3];
Any object array type is an array type.
You can get the array length using the array length operator.
my $array : object[] = new Int[3];
# Getting the length of the element of Any Object Array Type
my $length = @$array;
You can get and set the element using the get array element syntax and the set array element.
# Getting the element of any object array
my $num = (Int)$array->[0];
# Setting the element of any object array
$array->[0] = Int->new(5);
When setting the element of any object array, the element type is checked. If the dimension of the element is not the dimension of the array - 1, an exception is thrown.
Compilation Errors:
If a invalid type is assigned, a compilation error occurs.
Multi-Numeric Types
The multi-numeric type is the type to represent a multi-numeric value.
The multi-numeric type can be used as the type of the local variable declaration.
my $z : Complex_2d;
The value is initialized by the "Type Initial Value" in initial value.
The multi-numeric type can be used as an argument the type in the method definition.
The multi-numeric type can be used as the return type of the method definition.
static method add_double_complex : Complex_2d ($z1 : Complex_2d, $z2 : Complex_2d) { ... }
The multi-numeric type can be used as a basic type of the array type .
my $points = new Complex_2d[5];
The reference can be created for the value of the multi-numeric type.
my $z : Complex_2d;
my $z_ref = \$z;
undef cannot be assigned to the multi-numeric type.
Multi-Numeric Types Suffix
The list of the multi-numeric type suffix.
Numeric Types | Type Suffix |
---|---|
byte | b |
short | s |
int | i |
long | l |
float | f |
double | d |
Multi-Numeric Types Field Access
The multi-numeric type field access is an syntax to access the field of the multi-numeric value.
MULTI_NUMERIC_VALUE->{FIELD_NAME}
See "Getting Multi-Numeric Field" to get the field of the multi-numeric value.
See "Setting Multi-Numeric Field" to set the field of the multi-numeric value.
Reference Type
Reference type is a type that can store the address of a variable. Add *
after a numeric type or the multi-numeric type You can define it.
my $num : int;
my $num_ref : int* = \$num;
my $z : Complex_2d;
my $z_ref : Complex_2d* = \$z;
Only the address of the Local Variable acquired by "Reference Operator" can be assigned to the value of Reference Type.
Reference type can be used as type of argument in the method definition.
Reference type cannot be used as return value type in the method definition.
Reference type cannot be used as the field type in the class definition.
Reference type cannot be used as the type of Class Variable in the class definition.
See "Reference" for a detailed explanation of Reference.
Compilation Errors:
If only Local Variable Declaration of Reference type is performed, a compilation error occurs
Reference type can be used as type of the local variable declaration. The address of the Local Variable must be stored by the Reference Operator. In case of only Local Variable Declaration, a compilation error occurs
If the Reference type is used at an Invalid location, a compilation error occurs
Numeric Reference Type
Numeric Reference type means a numeric type for a reference type. Says.
Multi-Numeric Reference Type
Multi-Numeric Reference type means a reference type for the multi-numeric type variables. > Means.
Type Qualifiers
A type qualifier qualify a type.
QUALIFIER TYPE
The QUALIFIER qualified the type TYPE.
mutable Type Qualifier
The mutable
type qualifier allows characters of a string to be changed.
# The mutable type qualifier
my $string : mutable string;
Examples:
# The mutable type qualifier
my $message = (mutable string)copy "abc";
$message->[0] = 'd';
Type Initial Value
The list of initial values.
Type Name | Initial Value |
---|---|
byte | 0 |
short | 0 |
int | 0 |
long | 0 |
float |
0 (All bits are 0 )
|
double |
0 (All bits are 0 )
|
Object Type | undef |
Multi-Numeric Types |
All fields are set to 0 (All bits are 0 )
|
Type Width
The type width is the required length of the runtime stack for the type.
If the type is a multi-numeric type, it is the length of the fields, owhterwise it is 1.
Type Inference
Omitting the type when the local variable declaration by type Inference can. Type Inference is always performed by the type on the Right side of Assignment Operator.
# int
my $num = 1;
# double
my $num = 1.0;
# Foo
my $foo = new Foo;
Assignment Requirement
The assignment requirement at compile-time is explained.
Compilation Errors:
The assignment requirement is false, a compilation error occurs.
Assignment Requirement to Numeric
Explains the assignment requirement to the numeric types.
Assignment Requirement from Numeric to Numeric
If the nemric type order of LEFT_OPERAND is greater than or equal to the nemric type order of RIGHT_OPERAND, the assignment requirement is true.
If the nemric type order of LEFT_OPERAND is greater than the nemric type order of RIGHT_OPERAND, the numeric widening conversion is performed.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | byte | byte | None |
True | short | short | None |
True | int | int | None |
True | long | long | None |
True | float | float | None |
True | double | double | None |
True | short | byte | Numeric Widening Conversion |
True | int | byte | Numeric Widening Conversion |
True | long | byte | Numeric Widening Conversion |
True | float | byte | Numeric Widening Conversion |
True | double | byte | Numeric Widening Conversion |
True | int | short | Numeric Widening Conversion |
True | long | short | Numeric Widening Conversion |
True | float | short | Numeric Widening Conversion |
True | double | short | Numeric Widening Conversion |
True | long | int | Numeric Widening Conversion |
True | float | int | Numeric Widening Conversion |
True | double | int | Numeric Widening Conversion |
True | float | long | Numeric Widening Conversion |
True | double | long | Numeric Widening Conversion |
True | double | float | Numeric Widening Conversion |
Examples:
# int to int
my $num : int = 3;
# byte to int
my $num : int = (byte)5;
# double to double
my $num : double = 4.5;
# float to double
my $num : double = 4.5f;
If the nemric type order of LEFT_OPERAND is less than the nemric type order of RIGHT_OPERAND, the assignment requirement is conditional true.
The condition is that RIGHT_OPERAND is a interger literal and the value is between the max and minimal value of the type of LEFT_OPERAND.
If the condition is ture, the numeric narrowing conversion is performed.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
Conditional True | byte | short | Numeric Narrowing Conversion |
Conditional True | byte | int | Numeric Narrowing Conversion |
Conditional True | byte | long | Numeric Narrowing Conversion |
False | byte | float | None |
False | byte | double | None |
Conditional True | short | int | Numeric Narrowing Conversion |
Conditional True | short | long | Numeric Narrowing Conversion |
False | short | float | None |
False | short | double | None |
Conditional True | int | long | Numeric Narrowing Conversion |
False | int | float | None |
False | int | double | None |
False | long | float | None |
False | long | double | None |
False | float | double | None |
Examples:
# int to byte
my $num : byte = 127;
Assignment Requirement from NumericObject to Numeric
If the type of LEFT_OPERAND is a numeric type corresponding to the numeric object type of RIGHT_OPERAND and the type of RIGHT_OPERAND is a numeric object type, the assignment requirement is true.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | byte | Byte | Unboxing Conversion |
True | short | Short | Unboxing Conversion |
True | int | Int | Unboxing Conversion |
True | long | Long | Unboxing Conversion |
True | float | Float | Unboxing Conversion |
True | double | Double | Unboxing Conversion |
Examples:
my $int : int = Int->new(3);
my $double : double = Double->new(3.5);
Assignment Requirement from Any Object to Numeric
If the type of LEFT_OPERAND is a numeric type and the type of RIGHT_OPERAND is a any object type object
, the assignment requirement is true.
The unboxing conversion corresponding to the numeric type is performed.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | NUMERIC_X | object | Unboxing Conversion |
Examples:
my $int : int = (object)Int->new(3);
my $double : double = (object)Double->new(3.5);
Assignment Requirement from Others to Numeric
If the type of LEFT_OPERAND is a numeric type and the type of RIGHT_OPERAND is other than the types described above, the assignment requirement is false.
Assignment Requirement to Multi-Numeric
If the type of LEFT_OPERAND is a multi-numeric type and the type of RIGHT_OPERAND is the same type of LEFT_OPERAND, the assignment requirement is true.
Otherwise, the assignment requirement is false.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | MULNUM_X | MULNUM_X | None |
False | MULNUM_X | OTHER | None |
Examples:
my $z1 : Complex_2d;
my $z2 : Complex_2d = $z1;
Assignment Requirement to Referenece
If the type of LEFT_OPERAND is a reference type and the type of RIGHT_OPERAND is the same type of LEFT_OPERAND, the assignment requirement is true.
Otherwise, the assignment requirement is false.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | REF_X | REF_X | None |
False | REF_X | OTHER | None |
Examples:
my $num : int = 5;
my $num_ref : int* = \num;
Assignment Requirement to String
If the type of LEFT_OPERAND is the string type without the mutable type qualifier and the type of RIGHT_OPERAND is the string type, the assignment requirement is true.
If the type of LEFT_OPERAND is the string type with the mutable type qualifier and the type of RIGHT_OPERAND is the string type with the mutable type qualifier, the assignment requirement is true.
If the type of LEFT_OPERAND is the string type with the mutable type qualifier and the type of RIGHT_OPERAND is the string type without the mutable type qualifier, the assignment requirement is false.
If the type of LEFT_OPERAND is the string type and the type of RIGHT_OPERAND is a numeric type or the undef type, the assignment requirement is true.
If the type of RIGHT_OPERAND is a numeric type, the numeric-to-string conversion is performed.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | string | string | None |
True | string | mutable string | None |
True | mutable string | mutable string | None |
False | mutable string | string | None |
True | string | string | None |
True | string | NUMERIC_X | numeric-to-string conversion |
True | string | undef | None |
False | string | OTHER | None |
Examples:
my $string : string = "abc";
my $num_string : string = 3;
my $string : string = undef;
Assignment Requirement to NumericObject
If the type of LEFT_OPERAND is a numeric object type and the type of RIGHT_OPERAND is the same type of LEFT_OPERAND, a numeric type that is corresponding to the numeric object type, or the undef type, the assignment requirement is true.
Otherwise, the assignment requirement is false.
If the type of RIGHT_OPERAND is a numeric type, the boxing conversion is performed.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | NUMERIC_OBJECT_X | NUMERIC_OBJECT_X | None |
True | NUMERIC_OBJECT_X | NUMERIC_X | Boxing Conversion |
True | NUMERIC_OBJECT | undef | None |
False | NUMERIC_OBJECT | OTHER | None |
Examples:
my $num_object : Int = Int->new(3);
my $num_object : Int = 3;
my $num_object : Int = undef;
Assignment Requirement to Class
If the type of LEFT_OPERAND is a class type and the type of RIGHT_OPERAND is the same type, or the undef type, the assignment requirement is true.
If the type of LEFT_OPERAND is a super class of the type of RIGHT_OPERAND, the assignment requirement is true.
Otherwise, the assignment requirement is false.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | CLASS_X | CLASS_X | None |
True | CLASS | undef | None |
True | SUPER_CLASS_X | CLASS_Y | None |
False | CLASS | OTHER | None |
Examples:
my $point : Point = Point->new;
my $point : Point = undef;
Assignment Requirement to Interface
If the type of LEFT_OPERAND is an interface type and the type of RIGHT_OPERAND is the same type, or the undef type, the assignment requirement is true.
If the type of LEFT_OPERAND is an interface type and the type of RIGHT_OPERAND is a class type and the class has the same interface of LEFT_OPERAND, the assignment requirement is true.
Otherwise, the assignment requirement is false.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | INTERFACE_X | INTERFACE_X | None |
True | INTERFACE_X | INTERFACE_HAVING_Y | None |
True | INTERFACE | undef | None |
False | INTERFACE | OTHER | None |
Examples:
# Point has Stringable interface
my $stringable : Stringable = Point->new(1, 2);
my $stringable : Stringable = undef;
Assignment Requirement to Any Object
If the type of LEFT_OPERAND is the any object type and the type of RIGHT_OPERAND is an object type, a numeric type or the undef type, the assignment requirement is true.
Otherwise, the assignment requirement is false.
If the type of RIGHT_OPERAND is a numeric type, the boxing conversion is performed.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | object | OBJECT_Y | None |
True | object | NUMERIC_X | Boxing Conversion |
True | object | undef | None |
False | object | OTHER | None |
Examples:
my $object : object = Point->new;
my $num_object : object = 3;
my $object : object = undef;
Assignment Requirement to Undefined
If the type of LEFT_OPERAND is the undef type, the assignment requirement is false.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
False | undef Type | OTHER | None |
Examples:
# The assignment requirement is false
undef = Point->new;
Assignment Requirement to Numeric Array
If the type of LEFT_OPERAND is a numeric array type and the type of RIGHT_OPERAND is the same type of LEFT_OPERAND or the undef type, the assignment requirement is true.
Otherwise, the assignment requirement is false.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | byte[] | byte[] | None |
True | short[] | short[] | None |
True | int[] | int[] | None |
True | long[] | long[] | None |
True | float[] | float[] | None |
True | double[] | double[] | None |
True | NUMERIC[] | undef | None |
False | NUMERIC[] | OTHER | None |
Examples:
my $nums : int[] = new int[3];
my $nums : int[] = undef;
Assignment Requirement to Multi-Numeric Array
If the type of LEFT_OPERAND is a multi-numeric array type and the type of RIGHT_OPERAND is the same type of LEFT_OPERAND or the undef type, the assignment requirement is true.
Otherwise, the assignment requirement is false.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | MULNUM_X[] | MULNUM_X[] | None |
True | MULNUM_X[] | undef | None |
False | MULNUM_X[] | OTHER | None |
Examples:
my $nums : Complex_2d[] = new Complex_2d[3];
my $nums : Complex_2d[] = undef;
Assignment Requirement to String Array
If the type of LEFT_OPERAND is a string array type and the type of RIGHT_OPERAND is the same type of LEFT_OPERAND or the undef type, the assignment requirement is true.
Otherwise, the assignment requirement is false.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | string[] | string[] | None |
True | string[] | undef | None |
False | string[] | OTHER | None |
Examples:
my $strings : string[] = ["abc", "def"];
my $strings : string[] = undef;
Assignment Requirement to Class Array
If the type of LEFT_OPERAND is a class array type and the type of RIGHT_OPERAND is the same type of LEFT_OPERAND or the undef type, the assignment requirement is true.
If the basic type of LEFT_OPERAND is an super class of the type of RIGHT_OPERAND, the assignment requirement is true.
Otherwise, the assignment requirement is false.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | CLASS_X[] | CLASS_X[] | None |
True | SUPER_CLASS_X[] | CLASS_Y[] | None |
True | CLASS_X[] | undef | None |
False | CLASS_X[] | OTHER | None |
Examples:
my $points : Point[] = new Point[3];
my $points : Point[] = undef;
Assignment Requirement to Interface Array
If the type of LEFT_OPERAND is an interface array type and the type of RIGHT_OPERAND is the same type of LEFT_OPERAND or the undef type, the assignment requirement is true.
If the type of LEFT_OPERAND is an interface array type and the type of RIGHT_OPERAND is a class array type and its basic type can assign to the basic type of LEFT_OPERAND, the assignment requirement is true.
Otherwise, the assignment requirement is false.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | INTERFACE_X[] | INTERFACE_X[] | None |
True | INTERFACE_X[] | undef | None |
True | INTERFACE_X[] | INTERFACE_HAVING_Y[] | None |
False | INTERFACE_X[] | OTHER | None |
Examples:
my $stringables : Stringable[] = new Stringable[3];
my $stringables : Stringable[] = new Point[3];
my $stringables : Stringable[] = undef;
Assignment Requirement to Any Object Array
If the type of LEFT_OPERAND is the any object array type object[]
and the type of RIGHT_OPERAND is an object array type or the undef type, the assignment requirement is true.
Otherwise, the assignment requirement is false.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | object[] | OBJECT_ARRAY_Y | None |
True | object[] | undef | None |
False | object[] | OTHER | None |
Examples:
my $any_objects0 : object[];
my $any_objects : object[] = $any_objects0;
my $points : Point[];
my $any_object : object[] = $points;
my $any_object : object[] = undef;
my $points_2dim : Point[][];
my $any_object : object[] = $points_2dim;
my $stringables : Stringable[];
my $any_object : object[] = $stringables;
my $strings : string[];
my $any_object : object[] = $strings;
Assignment Requirement to Multi-Dimensional Array
If the type of LEFT_OPERAND is a multi-dimensional array type and the type of RIGHT_OPERAND is the same type of LEFT_OPERAND or the undef type, the assignment requirement is true.
If the type dimesion of LEFT_OPERAND is equal to the type dimension of RIGHT_OPERAND, and the basic type of LEFT_OPERAND is a super class of the basic type of RIGHT_OPERAND, the assignment requirement is true.
If the type dimesion of LEFT_OPERAND is equal to the type dimension of RIGHT_OPERAND, and the basic type of RIGHT_OPERAND has the basic type of LEFT_OPERAND, the assignment requirement is true.
Otherwise, the assignment requirement is false.
Assignment Requirement | To | From | Implicite Type Conversion |
---|---|---|---|
True | X[].. | X[].. | None |
True | object[] | undef | None |
True | SUPER_CLASS_X[].. | CLASS_Y[].. | None |
True | INTERFACE_X[].. | INTERFACE_HAVING_Y[].. | None |
False | object[] | OTHER | None |
([]..
means one or more []
)
Examples:
my $points_2dim : Point[][];
my $muldim_array : Point[][] = $points_2dim;
my $muldim_array : Point[][] = undef;
my $strings_2dim : String[][];
my $muldim_array : Stringable[][] = $strings_2dim;
{
my $cb = method : string ($object : object) {
my $point = (Point)$object;
return $point->to_string;
};
my $muldim_array : Stringer[][] = [[$cb]];
}
Cast Requirement
The cast requirement at compile-time is explained.
Compilation Errors:
The cast requirement is false, a compilation error occurs.
Cast Requirement to Numeric
The cast requirement to the numeric types is explained.
Cast Requirement from Numeric to Numeric
If the type of LEFT_OPERAND is a numeric type and the type of RIGHT_OPERAND is a numeric type, the cast requirement is true.
If the nemric type order of LEFT_OPERAND is greater than the nemric type order of RIGHT_OPERAND, the numeric widening conversion is performed.
If the nemric type order of LEFT_OPERAND is less than the nemric type order of RIGHT_OPERAND, the numeric narrowing conversion is performed.
If the nemric type order of LEFT_OPERAND is equal to the nemric type order of RIGHT_OPERAND, copying is performed.
Examples:
# int to int
my $num = (int)3;
# byte to int
my $num_byte : byte = 5;
my $num = (int)5;
# double to double
my $num = (double)4.5;
# float to double
my $num = (double)4.5f;
# int to byte
my $num = (byte)127;
# double to int
my $num = (int)2.5;
Cast Requirement from NumericObject to Numeric
If the type of LEFT_OPERAND is a numeric type corresponding to the numeric object type of RIGHT_OPERAND and the type of RIGHT_OPERAND is a numeric object type, the cast requirement is true.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | byte | Byte | Unboxing Conversion |
True | short | Short | Unboxing Conversion |
True | int | Int | Unboxing Conversion |
True | long | Long | Unboxing Conversion |
True | float | Float | Unboxing Conversion |
True | double | Double | Unboxing Conversion |
Examples:
my $int = (int)Int->new(3);
my $double = (double)Double->new(3.5);
Cast Requirement from Any Object to Numeric
If the type of LEFT_OPERAND is a numeric type and the type of RIGHT_OPERAND is a any object type object
, the cast requirement is true.
The unboxing conversion corresponding to the numeric type is performed.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | NUMERIC_X | object | Unboxing Conversion |
Examples:
my $object : object = Int->new(3);
my $int = (int)$object;
my $object : object = Double->new(3.5);
my $double = (double)$object;
Cast Requirement from Others to Numeric
If the type of LEFT_OPERAND is a numeric type and the type of RIGHT_OPERAND is other than the types described above, the cast requirement is false.
Cast Requirement to Multi-Numeric
If the type of LEFT_OPERAND is a multi-numeric type and the type of RIGHT_OPERAND is the same type of LEFT_OPERAND, the cast requirement is true.
Otherwise, the cast requirement is false.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | MULNUM_X | MULNUM_X | None |
False | MULNUM_X | OTHER | None |
Examples:
my $z1 : Complex_2d;
my $z2 = (Complex_2d)$z1;
Cast Requirement to Referenece
If the type of LEFT_OPERAND is a reference type and the type of RIGHT_OPERAND is the same type of LEFT_OPERAND, the cast requirement is true.
Otherwise, the cast requirement is false.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | REF_X | REF_X | None |
False | REF_X | OTHER | None |
Examples:
my $num : int = 5;
my $num_ref = (int*)\num;
Cast Requirement to String
If the type of LEFT_OPERAND is the string type and the type of RIGHT_OPERAND is the string type, the cast requirement is true.
If the type of LEFT_OPERAND is the string type with the mutable type qualifier and the type of RIGHT_OPERAND is the string type without the mutable type qualifier, the runtime type checking is performed.
If the type of RIGHT_OPERAND is a numeric type, the numeric-to-string conversion is performed.
If the type of LEFT_OPERAND is the string type and the type of RIGHT_OPERAND is a numeric type, the undef type, or the any object type object
, the cast requirement is true.
If the type of RIGHT_OPERAND is a numeric type, the numeric-to-string conversion is performed.
If the type of LEFT_OPERAND is the string type and the type of RIGHT_OPERAND is the any object type object
, the cast requirement is true and the runtime type checking is performed.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | string | string | None |
True | string | mutable string | None |
True | mutable string | mutable string | None |
True | mutable string | string | Runtime type checking |
True | string | string | None |
True | string | NUMERIC_X | Numeric-to-String Conversion |
True | string | object | Runtime type checking |
True | string | undef | None |
False | string | OTHER | None |
Examples:
my $string = (string)"abc";
my $num_string = (string)3;
my $string : string = undef;
Cast Requirement to NumericObject
If the type of LEFT_OPERAND is a numeric object type and the types of RIGHT_OPERANDs are the following cases:
If the type of RIGHT_OPERAND is the same type of LEFT_OPERAND, a numeric type that is corresponding to the numeric object type, the any object type object
, or the undef type, the cast requirement is true.
The type of RIGHT_OPERAND is other than above, the cast requirement is false.
If the type of RIGHT_OPERAND is a numeric type, the boxing conversion is performed.
If the type of LEFT_OPERAND is the type of RIGHT_OPERAND is the any object type object
, the runtime type checking is performed.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | NUMERIC_OBJECT_X | NUMERIC_OBJECT_X | None |
True | NUMERIC_OBJECT_X | NUMERIC_X | Boxing Conversion |
True | NUMERIC_OBJECT | object | Runtime type checking |
True | NUMERIC_OBJECT | undef | None |
False | NUMERIC_OBJECT | OTHER | None |
Examples:
my $num_object = (Int)Int->new(3);
my $num_object = (Int)3;
my $num_object = (Int)undef;
my $object : object = Int->new(3);
my $num_object = (Int)$object;
Cast Requirement to Class
If the type of LEFT_OPERAND is a class type and the types of RIGHT_OPERANDs are the following cases:
If the type of RIGHT_OPERAND is the same type, the any object type object
, an interface type or the undef type, the cast requirement is true.
If the type of LEFT_OPERAND is a super class of the type of right operand, the cast requirement is true.
If the type of RIGHT_OPERAND is a super class of the type of left operand, the cast requirement is true.
Otherwise, the cast requirement is false.
If the type of RIGHT_OPERAND is the any object type object
or an interface type, the runtime type checking is performed.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | CLASS_X | CLASS_X | None |
True | SUPER_CLASS_X | CLASS_Y | None |
True | CLASS_X | SUPER_CLASS_Y | Runtime type checking |
True | CLASS_X | INTERFACE_Y | Runtime type checking |
True | CLASS_X | object | Runtime type checking |
True | CLASS | undef | None |
False | CLASS | OTHER | None |
Examples:
my $point : Point = Point->new;
my $stringable : Stringable;
my $point = (Point)$stringable;
my $stringer : Stringer;
my $point = (Point)$stringer
my $point = (Point)undef;
Cast Requirement to Interface
If the type of LEFT_OPERAND is an interface type, and the types of RIGHT_OPERANDs are the following cases:
If the type of RIGHT_OPERAND is the same type, the any object type object
, an interface type or the undef type, the cast requirement is true.
If the type of RIGHT_OPERAND is a class type and the class has the interface of LEFT_OPERAND, the cast requirement is true.
Otherwise, the cast requirement is false.
If the type of RIGHT_OPERAND is the any object type object
, an interface type, the runtime type checking is performed.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | INTERFACE_X | INTERFACE_X | None |
True | INTERFACE_X | INTERFACE_HAVING_Y | None |
True | INTERFACE_X | INTERFACE_Y | Runtime type checking |
True | INTERFACE_X | object | Runtime type checking |
True | INTERFACE | undef | None |
False | INTERFACE | OTHER | None |
Examples:
my $stringable1 : Stringable;
my $stringable2 = (Stringable)$stringable1;
my $cloneable : Cloneable;
my $stringable = (Stringable)$cloneable;
my $stringable = (Stringable)Point->new(1, 2);
my $object : object = Point->new(1, 2);
my $stringable = (Stringable)Point->new(1, 2);
my $stringable : Stringable = undef;
Cast Requirement to Any Object
If the type of LEFT_OPERAND is the any object type and the types of RIGHT_OPERANDs are the following cases:
If the type of RIGHT_OPERAND is an object type, a numeric type or the undef type, the cast requirement is true.
Otherwise, the cast requirement is false.
If the type of RIGHT_OPERAND is a numeric type, the boxing conversion is performed.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | object | OBJECT_Y | None |
True | object | NUMERIC_X | Boxing Conversion |
True | object | undef | None |
False | object | OTHER | None |
Examples:
my $object : object = Point->new;
my $num_object : object = 3;
my $object : object = undef;
Cast Requirement to Numeric Array
If the type of LEFT_OPERAND is the byte[] type and the type of RIGHT_OPERAND is the string type, the cast requirement is true.
If the type of LEFT_OPERAND is a numeric array type and the types of RIGHT_OPERANDs are the following cases:
If the type of RIGHT_OPERAND is the same type of LEFT_OPERAND, the any object type obejct
or the undef type, the cast requirement is true.
Otherwise, the cast requirement is false.
If the type of LEFT_OPERAND is the byte[] type and the type of RIGHT_OPERAND is the string type, "String-to-byte[] Conversion" is performed.
If the type of RIGHT_OPERAND is the any object type obejct
, the runtime type checking is performed.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | byte[] | string | String-to-byte[] Conversion |
True | NUMERIC_X[] | NUMERIC_X[] | None |
True | NUMERIC[] | object | Runtime type checking |
True | NUMERIC[] | undef | None |
False | NUMERIC[] | OTHER | None |
Examples:
my $bytes = (byte[])"abc";
my $nums = (int[])new int[3];
my $object : object = new int[3];
my $nums = (int[])$object;
my $nums = (int[])undef;
Cast Requirement to Multi-Numeric Array
If the type of LEFT_OPERAND is a multi-numeric array type and the types of RIGHT_OPERANDs are the following cases:
If the type of RIGHT_OPERAND is the same type of LEFT_OPERAND, the any object type obejct
or the undef type, the cast requirement is true.
Otherwise, the cast requirement is false.
If the type of RIGHT_OPERAND is the any object type obejct
, the runtime type checking is performed.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | MULNUM_X[] | MULNUM_X[] | None |
True | MULNUM_X[] | object | Runtime type checking |
True | MULNUM_X[] | undef | None |
False | MULNUM_X[] | OTHER | None |
Examples:
my $nums = (Complex_2d[])new Complex_2d[3];
my $object : object = new Complex_2d[3];
my $nums = (Complex_2d[])$object;
my $nums = (Complex_2d[])undef;
Cast Requirement to String Array
If the type of LEFT_OPERAND is a string array type and the types of RIGHT_OPERANDs are the following cases:
If the type of RIGHT_OPERAND is the same type of LEFT_OPERAND, the any object type obejct
, the any object array type obejct[]
or the undef type, the cast requirement is true.
Otherwise, the cast requirement is false.
If the type of RIGHT_OPERAND is the any object type obejct
, or the any object array type obejct[]
, the runtime type checking is performed.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | string[] | string[] | None |
True | string[] | object | Runtime type checking |
True | string[] | object[] | Runtime type checking |
True | string[] | undef | None |
False | string[] | OTHER | None |
Examples:
my $strings = (string[])["abc", "def"];
my $object : object = ["abc", "def"];
my $strings = (string[])$object;
my $objects : object[] = ["abc", "def"];
my $strings = (string[])$object;
my $strings = (string[])undef;
Cast Requirement to Class Array
If the type of LEFT_OPERAND is a class array type and the types of RIGHT_OPERANDs are the following cases:
If the basic type of LEFT_OPERAND is a super class of the basic type of RIGHT_OPERAND, the cast requirement is true.
If the basic type of RIGHT_OPERAND is a super class of the basic type of LEFT_OPERAND, the cast requirement is true.
If the type of RIGHT_OPERAND is the same type of LEFT_OPERAND, the any object type obejct
, the any object array type obejct[]
or the undef type, the cast requirement is true.
Otherwise, the cast requirement is false.
If the type of RIGHT_OPERAND is the any object type obejct
, or the any object array type obejct[]
, the runtime type checking is performed.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | CLASS_X[] | CLASS_X[] | None |
True | SUPER_CLASS_X[] | CLASS_Y[] | None |
True | CLASS_X[] | SUPER_CLASS_Y[] | Runtime type checking |
True | CLASS_X[] | object | Runtime type checking |
True | CLASS_X[] | object[] | Runtime type checking |
True | CLASS_X[] | undef | None |
False | CLASS_X[] | OTHER | None |
Examples:
my $points = (Point[])new Point[3];
my $object : object = new Point[3];
my $points = (Point[])$object;
my $objects : object[] = new Point[3];
my $points = (Point[])$object;
my $points = (Point[])undef;
Cast Requirement to Interface Array
If the type of LEFT_OPERAND is an interface array type and the types of RIGHT_OPERANDs are the following cases:
If the type of RIGHT_OPERAND is a class array type and its basic type has the interface of the basic type of LEFT_OPERAND, the cast requirement is true.
If the type of RIGHT_OPERAND is the same type of LEFT_OPERAND, the cast requirement is true.
If the type of RIGHT_OPERAND is an differnt type of interface array type, the cast requirement is also true.
If the type of RIGHT_OPERAND is the any object type obejct
, the any object array type obejct[]
or the undef type, the cast requirement is true.
Otherwise, the cast requirement is false.
If the type of RIGHT_OPERAND is an differnt type of interface array type, the runtime type checking is performed.
If the type of RIGHT_OPERAND is the any object type obejct
, or the any object array type obejct[]
, the runtime type checking is performed.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | INTERFACE_X[] | INTERFAECE_HAVING_Y[] | None |
True | INTERFACE_X[] | INTERFACE_X[] | None |
True | INTERFACE_X[] | INTERFACE_Y[] | Runtime type checking |
True | INTERFACE_X[] | object | Runtime type checking |
True | INTERFACE_X[] | object[] | Runtime type checking |
True | INTERFACE_X[] | undef | None |
False | INTERFACE_X[] | OTHER | None |
Examples:
my $stringables = (Stringable[])new Stringable[3];
my $stringables = (Stringable[])new Point[3];
my $stringables = (Stringable[])undef;
Cast Requirement to Any Object Array
If the type of LEFT_OPERAND is the any object array type object[]
and the types of RIGHT_OPERANDs are the following cases:
If the type of RIGHT_OPERAND is an object array type or the undef type, the cast requirement is true.
If the type of RIGHT_OPERAND is an any object type, the cast requirement is true.
Otherwise, the cast requirement is false.
If the type of RIGHT_OPERAND is an any object type, the runtime type checking is performed.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | object[] | OBJECT_ARRAY_Y | None |
True | object[] | undef | None |
True | object[] | object | Runtime type checking |
False | object[] | OTHER | None |
Examples:
my $any_object : object;
my $any_objects = (object[])$any_object;
my $any_objects0 : object[];
my $any_objects = (object[])$any_objects0;
my $points : Point[];
my $any_object = (object[])$points;
my $any_object = (object[])undef;
my $points_2dim : Point[][];
my $any_object = (object[])$points_2dim;
my $stringables : Stringable[];
my $any_object = (object[])$stringables;
my $strings : string[];
my $any_object = (object[])$strings;
Cast Requirement to Multi-Dimensional Array
If the type of LEFT_OPERAND is a multi-dimensional array type and and the types of RIGHT_OPERANDs are the following cases:
If the type of RIGHT_OPERAND is the same type of LEFT_OPERAND or the undef type, the cast requirement is true.
If the type of RIGHT_OPERAND is an any object type, the cast requirement is true.
If the type dimesion of LEFT_OPERAND is equal to the type dimension of RIGHT_OPERAND, and the basic type of LEFT_OPERAND is a super class of the basic type of RIGHT_OPERAND, the cast requirement is true.
If the type dimesion of LEFT_OPERAND is equal to the type dimension of RIGHT_OPERAND, and the basic type of RIGHT_OPERAND is a super class of the basic type of LEFT_OPERAND, the cast requirement is true.
If the basic type of the type of LEFT_OPERAND is an interface type and the basic type of the type of RIGHT_OPERAND is a class type and the dimension of the type of RIGHT_OPERAND is the same as the dimension of the type left oerand and the basic type of the type of RIGHT_OPERAND has the interface of the basic type of the type of LEFT_OPERAND , the cast requirement is true.
Otherwise, the cast requirement is false.
Cast Requirement | To | From | Conversion or Type Checking |
---|---|---|---|
True | ANY_X[].. | ANY_X[].. | None |
True | ANY_X[].. | object | Runtime type checking |
True | ANY_X[].. | object[] | Runtime type checking |
True | ANY_X[].. | undef | None |
True | SUPER_CLASS_X[].. | CLASS_Y[].. | None |
True | CLASS_X[].. | SUPER_CLASS_Y[].. | Runtime type checking |
True | INTERFACE_X[].. | INTERFACE_HAVING_Y[].. | None |
False | object[] | OTHER | None |
([]..
means one or more []
)
Examples:
my $points_2dim : Point[][];
my $muldim_array : Point[][] = $points_2dim;
my $muldim_array : Point[][] = undef;
my $strings_2dim : String[][];
my $muldim_array : Stringable[][] = $strings_2dim;
{
my $cb = method : string ($object : object) {
my $point = (Point)$object;
return $point->to_string;
};
my $muldim_array : Stringer[][] = [[$cb]];
}
Type Conversion
Type conversion is explained.
Explicite Type Conversion
The explicite type conversion is the type conversion performed by a type cast expicitely.
Examples:
# The explicte type conversion from long to int
my $num = (int)123L;
# The explicte type conversion from byte[] to string
my $num = (string)new byte[3];
# The explicte type conversion from string to byte[]
my $num = (byte[])"Hello";
Implicite Type Conversion
The implicite type conversion is the type conversion performed implicitly when a value is assigned using assignment operator, pass an argument to a method using a method call, or set a return value using the return statement.
See "Assignment Requirement" if you know when implicite type conversion is performed.
Examples:
# The implicite type conversion from int to double
my $num : double = 5;
# The implicite type conversion from double to Double
my $num_object : Double = 5.1;
# The implicite type conversion from Double to double
my $num : double = Double->new(5.1);
# The implicite type conversion from int to string
my $string : string = 4;
Integer Promotional Conversion
The integer promotional conversion is a type conversion to convert an integer type within int to the int type using the numeric widening conversion.
Numeric Widening Conversion
The numeric widening conversion is a type conversion from a small-order numeric type to a large-order numeric type.
See also numeric types order abount the order of numeric type.
The return value of a converion are same as the return value of the type cast of the C language.
(TYPE)OPERAND
byte to short:
int8_t from = VALUE;
int16_t to = (int16_t)from;
byte to int:
int8_t from = VALUE;
int32_t to = (int32_t)from;
byte to long:
int8_t from = VALUE;
int64_t to = (int64_t)from;
byte to float:
int8_t from = VALUE;
float to = (float)from;
byte to double:
int8_t from = VALUE;
double to = (double)from;
short to int:
int16_t from = VALUE;
int32_t to = (int32_t)from;
short to long:
int16_t from = VALUE;
int64_t to = (int64_t)from;
short to float:
int16_t from = VALUE;
float to = (float)from;
short to double:
int16_t from = VALUE;
double to = (double)from;
int to long:
int32_t from = VALUE;
int64_t to = (int64_t)from;
int to float:
int32_t from = VALUE;
float to = (float)from;
int to double:
int32_t from = VALUE;
double to = (double)from;
long to float:
int64_t from = VALUE;
float to = (float)from;
long to double:
int64_t from = VALUE;
double to = (double)from;
The numeric widening conversion is performed in some of the type casts, the index of the array access, the length of the creating array, OPERAND of the unary plus operator, OPERAND of the unary minus operator, and the left and right operands of the shift operators.
Numeric Narrowing Conversion
The numeric narrowing conversion is a conversion from a wide numeric type to a narrow numeric type.
See also numeric types order abount the order of numeric type.
The return value of a converion are same as the return value of the type cast of the C language.
(TYPE)OPERAND
double to float:
double from = value;
float to = (float)from;
double to long:
double from = value;
int64_t to = (int64_t)from;
double to int:
double from = value;
int32_t to = (int32_t)from;
double to short:
double from = value;
int16_t to = (int16_t)from;
double to byte:
double from = value;
int8_t to = (int8_t)from;
float to long:
float from = value;
int64_t to = (int64_t)from;
float to int:
float from = value;
int32_t to = (int32_t)from;
float to short:
float from = value;
int16_t to = (int16_t)from;
float to byte:
float from = value;
int8_t to = (int8_t)from;
long to int:
int64_t from = value;
int32_t to = (int32_)from;
long to short:
int64_t from = value;
int16_t to = (int16_t)from;
long to byte:
int64_t from = value;
int8_t to = (int8_t)from;
int to short:
int32_t from = value;
int16_t to = (int16_t)from;
int to byte:
int32_t from = value;
int16_t to = (int16_t)from;
short to byte:
int16_t from = value;
int8_t to = (int8_t)from;
The numeric narrowing conversion is performed in some of the type casts.
Binary Numeric Conversion
The binary numeric conversion is a type conversion to upgrade the type of LEFT_OPERAND or RIGHT_OPERAND of the binary operator that operands are numeric types.
The following rules apply in order.
1. If LEFT_OPERAND or RIGHT_OPERAND is the double type, OPERAND of the small type is converted to the big type using the numeric widening conversion.
2. If LEFT_OPERAND or RIGHT_OPERAND is the float type, OPERAND of the small type is converted to the big type using the numeric widening conversion.
3. If LEFT_OPERAND or RIGHT_OPERAND is the long type, OPERAND of the small type is converted to the big type using the numeric widening conversion.
4, Otherwise, both LEFT_OPERAND and RIGHT_OPERAND are converted to the int type using the numeric widening conversion.
Numeric-to-String Conversion
The numeric-to-string conversion is a type conversion from a numeric type to the string type.
# The numeric-to-string conversion
my $byte = (byte)1;
my $short = (short)2;
my $int = 3;
my $long = 4L;
my $float = 2.5f;
my $double = 3.3;
# The string is 1.
my $string_byte = (string)$byte;
# The string is 2.
my $string_short = (string)$short;
# The string is 3.
my $string_int = (string)$int;
# The string is 4.
my $string_long = (string)$long;
# The string is "2.5"
my $string_float = (string)$float;
# The string is "3.3"
my $string_double = (string)$double;
String-to-byte Conversion
The String-to-byte conversion is a type conversion from the string Type to "byte Type".
# The String-to-byte conversion
my $string : string = "Hello";
my $num : byte = (byte)$string;
If the string is not defined, returns 0.
If not, the string is coverted to a number by the strtoll
function in the C language.
The number is greater than INT8_MAX
, the number is set to INT8_MAX
.
The number is less than INT8_MIN
, the number is set to INT8_MIN
.
And returns the number.
String-to-short Conversion
The String-to-short conversion is a type conversion from the string Type to "short Type".
# The String-to-short conversion
my $string : string = "Hello";
my $num : short = (short)$string;
If the string is not defined, returns 0.
If not, the string is coverted to a number by the strtoll
function in the C language.
The number is greater than INT16_MAX
, the number is set to INT16_MAX
.
The number is less than INT16_MIN
, the number is set to INT16_MIN
.
And returns the number.
String-to-int Conversion
The String-to-int conversion is a type conversion from the string Type to "int Type".
# The String-to-int conversion
my $string : string = "Hello";
my $num : int = (int)$string;
If the string is not defined, returns 0.
If not, the string is coverted to a number by the strtoll
function in the C language.
The number is greater than INT32_MAX
, the number is set to INT32_MAX
.
The number is less than INT32_MIN
, the number is set to INT32_MIN
.
And returns the number.
String-to-long Conversion
The String-to-long conversion is a type conversion from the string Type to "long Type".
# The String-to-long conversion
my $string : string = "Hello";
my $num : long = (long)$string;
If the string is not defined, returns 0.
If not, the string is coverted to a number by the strtoll
function in the C language.
And returns the number.
String-to-float Conversion
The String-to-float conversion is a type conversion from the string Type to "float Type".
# The String-to-float conversion
my $string : string = "Hello";
my $float : float = (float)$string;
If the string is not defined, returns 0.
If not, the string is coverted to a number by the strtof
function in the C language.
And returns the number.
String-to-double Conversion
The String-to-double conversion is a type conversion from the string Type to "double Type".
# The String-to-double conversion
my $string : string = "Hello";
my $num : double = (double)$string;
If the string is not defined, returns 0.
If not, the string is coverted to a number by the strtod
function in the C language.
And returns the number.
String-to-byte[] Conversion
The String-to-byte[] conversion is a type conversion from the string Type to "byte[] Type".
# The String-to-byte[] conversion
my $string : string = "Hello";
my $bytes : byte[] = (byte[])$string;
A new byte[] object is created and all characters in the string are copied to the elements of byte[] object.
byte[]-to-string Conversion
The byte[]-to-string conversion is a type conversion from the byte[] type to the string Type.
# byte[]-to-string conversion
my $bytes : byte[] = new byte[3];
$bytes->[0] = 'a';
$bytes->[1] = 'b';
$bytes->[2] = 'c';
my $string : string = (string)$bytes;
A new string is created and all elements in the byte[]
object are copied to the characters of the string.
Boxing Conversion
The boxing conversion is a type coversion to convert the value of numeric type to the corresponding numeric object type.
Unboxing Conversion
The unboxing conversion is a type coversion to convert the value of the numeric object type to the value of the corresponding numeric type.
Boolean Conversion
The boolean conversion converts an operand to an int value that indicates a boolean value.
This conversion is performed on the follwoing operands.
The operand of the if statement:
if (CONDITION) {
}
The operand of the unless statement:
unless (CONDITION) {
}
The second operand of the for statement:
for (INITIALIZEATION;CONDITION;NEXT_VALUE;) {
}
The operand of the while statement:
while (CONDITION) {
}
The left and right operand of the logical AND operator:
CONDITION && CONDITION
The left and right operand of the logical OR operator:
CONDITION || CONDITION
The operand of the logical NOT operator:
!CONDITION
The boolean conversion returns the following value corresponding to the type of the condional operand.
If the type is the int type, return the value.
If the type is the undef, returns 0.
If the type is the value returned by the TRUE method of Bool, returns 1.
If the type is the value returned by the FALSE method of Bool, returns 0.
If the type is an integer type within int, the integer promotional conversion is performed on OPERAND.
And the following operation in the C language is performed on OPERAND .
!!OPERAND
Compilation Errors:
The type of OPERAND of the boolean conversion must be a numeric type, an object type or an reference type or the undef type. Otherwise a compilation error occurs.
Examples:
if (1) {
# ok
}
if (0) {
# not ok
}
if (1.5) {
# ok
}
if (0.0) {
# not ok
}
if (true) {
# ok
}
if (Bool->TRUE) {
# ok
}
if (false) {
# not ok
}
if (Bool->FALSE) {
# not ok
}
my $object = SPVM::Int->new(1);
if ($object) {
# ok
}
$object = undef;
if ($object) {
# not ok
}
my $value = 1;
my $ref = \$value;
if ($ref) {
# ok
}
if (undef) {
# not ok
}
Assignment Requirement for Interface Method Requirement
This section describes assignment requirements used to check a return type and argument types for interface method requirement.
(TODO)
Runtime Assignment Requirement
The runtime type cheking is the type cheking that is performed at runtime.
The type cast operators that operand is an object type performe the runtime type checking by the rule of the runtime assignment requirement.
The runtime assignment requirement is the assignment requirement at runtime.
The isa operator checks the "Runtime Assignment Requirement" in runtime assignment requirement
The runtime assignment requirement is false, an exception is thrown.
If the type of the distribution is an object type and the type of the source is undef, the runtime assignment requirement is true.
If the type of the distribution is the same as the type of the source, the runtime assignment requirement is true.
If the type of the distribution is the any object type object
and the type of the source is an object type, the runtime assignment requirement is true.
If the type of the distribution is the any object array type object[]
and the type of the source is an object array type, the runtime assignment requirement is true.
If the type of distribution is an class type, an class array type, an class multi-dimensional array type and the dimention of the type of the distribution is the same as the dimention of the type of the source and the basic type of distribution is a super class of the basic type of the source, the runtime assignment requirement is true.
If the type of distribution is an interface type, an interface array type, an interface multi-dimensional array type and the dimention of the type of the distribution is the same as the dimention of the type of the source and the basic type of distribution has the interface of the basic type of the source, the runtime assignment requirement is true.
Runtime Assignment Requirement | To | From |
---|---|---|
True | OBJECT_X | undef |
True | OBJECT_X | OBJECT_X |
True | object | OBJECT_Y |
True | object[] | OBJECT_ARRAY_Y |
True | SUPER_CLASS_X | CLASS_Y |
True | SUPER_CLASS_X[] | CLASS_Y[] |
True | SUPER_CLASS_X[].. | CLASS_Y[].. |
True | INTERFACE_X | INTERFACE_HAVING_Y |
True | INTERFACE_X[] | INTERFACE_HAVING_Y[] |
True | INTERFACE_X[].. | INTERFACE_HAVING_Y[].. |
False | OBJECT_X | OTHER |
([]..
means one or more []
)
Type Comment
The type comment syntax is supported. The type comment can be written after of
keyword.
TYPE of TYPE
TYPE of TYPE1|TYPE2
TYPE of TYPE1|TYPE2|TYPE3
The type comment can be used the type of the field decralation, the class variable definition, the local variable declaration, and the return value and the types of arguments of the method definition.
has points : List of Point;
our $POINTS : List of Point;
my $points : List of Point;
static method foo : List of Point ($arg : List of Point) { ... }
my $replace : object of string|Regex::Replacer;
Type comments have no meanings at runtime.
Compilation Errors:
If the type specified as the type comment is not found, a compilation error occurs.
Copyright & License
Copyright (c) 2023 Yuki Kimoto
MIT License