Name
SPVM::Document::Language::Types - Types in SPVM Language
Description
This document describes types in SPVM language.
Types
SPVM language has data types.
See Data type - Wikipedia about data types.
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 Type |
All fields are set to 0 (All bits are 0 )
|
Numeric Type
The numeric type are an integer type and "Floating Point Type".
Numeric Type Order
a numeric type has the type order. The order is "byte", "short", "int", "long", "float", "double" from the smallest.
Integer Type
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.
Integer Type 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.
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.
Floating Point Type
Floating Point Type 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.
Class Type
The class type is the type that can create the object using a new operator.
new ClassType;
Basic Object Type
Basic object types are the class type, the array type, the string type, and the any object type.
Object Type
Object types are the basic object types and the array types.
A object type can be assigned to a any object type.
my $object: object = new Foo;
my $object: object = "abc";
Numeric Object Type
A numeric object type is the object type that is corresponding to the numeric type.
The list of numeric object types:
Numeric Object Type | Corresponding Numeric Type |
---|---|
Byte | byte |
Short | short |
Int | int |
Long | long |
Float | float |
Double | double |
See also the boxing conversion and "Unboxing Conversion".
undef Type
The undef type is the type of undef value.
Undefined Value
An undefined value is represented by undef
.
undef
An undefined value can be assigned to an object type.
In the level of native APIs, undef is defined as (void*)NULL
.
(void*)NULL
An undefined value can be compared by the ==
operator and the !=
operator. An undefined value is guaranteed not to be equal to the any created object.
The type of undef is undef type
Examples:
# Undefine values
my $string : string = undef;
if (undef) {
}
my $message = "Hello";
if ($message == undef) {
}
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 Type" for Any Object Type.
my $object: object = new Foo;
my $object: object = "abc";
my $object: object = new Foo [3];
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
Basic Type
The basic types are numeric types, multi-numeric types, the class type, the any object type, and the string type.
Another definition of basic types are the types that is not array types and can become the element of array types.
Array Type
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.
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.
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 "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];
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.
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;
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.
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;
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;
Multi-Numeric Type
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 "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 Value
A multi-numeric value is a value that represents continuous multiple numeric values in memory.
Multi-Numeric Type Definition
A multi-numeric type is defined by the class definition that has the mulnum_t
class attribute.
# Continuous two 64bit floating point
class Complex_2d : mulnum_t {
re : double;
im : double;
}
The type of a field must be a numeric type.
The types of all fields must be the same types.
The length of the fields must be less than or equal to 255.
The multi-numeric type must end with the following suffix.
_[FieldsLength][TypeSuffix]
The length of the fields in the suffix must be the same as the length of the fields.
The type suffix in the suffix must correspond to the numeric type that is explained in the multi-numeric type suffix.
See the multi-numeric type field access to get and set the field of the multi-numeric type.
Multi-Numeric Type Suffix
The list of the multi-numeric type suffix.
Numeric Type | Type Suffix |
---|---|
byte | b |
short | s |
int | i |
long | l |
float | f |
double | d |
Multi-Numeric Type 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
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);
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 Qualifier
Type qualifiers qualify the type.
QUALIFIER TYPE
mutable Type Qualifier
The mutable
type qualifier is used to allow to set the character of the string.
my $string : mutable string;
Examples:
# Mutable string
my $message = (mutable string)"abc";
$message->[0] = 'd';
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;
Type Assignability
The assignability at compile-time is explained.
Compilation Errors:
The assignability is false, a compilation error occurs.
Type Assignability to Numeric
Explains the assignability to the numeric types.
Type Assignability 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 assignability 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.
Type Assignability | 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 assignability 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.
Type Assignability | 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;
Type Assignability 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 assignability is true.
Type Assignability | 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);
Type Assignability 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 assignability is true.
The unboxing conversion corresponding to the numeric type is performed.
Type Assignability | 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);
Type Assignability 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 assignability is false.
Type Assignability 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 assignability is true.
Otherwise, the assignability is false.
Type Assignability | 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;
Type Assignability 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 assignability is true.
Otherwise, the assignability is false.
Type Assignability | 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;
Type Assignability 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 assignability 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 assignability 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 assignability 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 assignability is true.
If the type of RIGHT_OPERAND is a numeric type, the numeric-to-string conversion is performed.
Type Assignability | 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;
Type Assignability 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 assignability is true.
Otherwise, the assignability is false.
If the type of RIGHT_OPERAND is a numeric type, the boxing conversion is performed.
Type Assignability | 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;
Type Assignability 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 assignability is true.
If the type of LEFT_OPERAND is a super class of the type of RIGHT_OPERAND, the assignability is true.
Otherwise, the assignability is false.
Type Assignability | 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;
Type Assignability 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 assignability 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 assignability is true.
Otherwise, the assignability is false.
Type Assignability | 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;
Type Assignability 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 assignability is true.
Otherwise, the assignability is false.
If the type of RIGHT_OPERAND is a numeric type, the boxing conversion is performed.
Type Assignability | 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;
Type Assignability to Undefined
If the type of LEFT_OPERAND is the undef type, the assignability is false.
Type Assignability | To | From | Implicite Type Conversion |
---|---|---|---|
False | undef Type | OTHER | None |
Examples:
# The assignability is false
undef = Point->new;
Type Assignability 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 assignability is true.
Otherwise, the assignability is false.
Type Assignability | 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;
Type Assignability 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 assignability is true.
Otherwise, the assignability is false.
Type Assignability | 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;
Type Assignability 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 assignability is true.
Otherwise, the assignability is false.
Type Assignability | 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;
Type Assignability 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 assignability is true.
If the basic type of LEFT_OPERAND is an super class of the type of RIGHT_OPERAND, the assignability is true.
Otherwise, the assignability is false.
Type Assignability | 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;
Type Assignability 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 assignability 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 assignability is true.
Otherwise, the assignability is false.
Type Assignability | 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;
Type Assignability 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 assignability is true.
Otherwise, the assignability is false.
Type Assignability | 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;
Type Assignability 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 assignability 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 assignability 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 assignability is true.
Otherwise, the assignability is false.
Type Assignability | 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 two 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 Castability
The castability at compile-time is explained.
Compilation Errors:
The castability is false, a compilation error occurs.
Type Castability to Numeric
The castability to the numeric types is explained.
Type Castability 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 castability 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;
Type Castability 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 castability is true.
Type Castability | 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);
Type Castability 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 castability is true.
The unboxing conversion corresponding to the numeric type is performed.
Type Castability | 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;
Type Castability 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 castability is false.
Type Castability 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 castability is true.
Otherwise, the castability is false.
Type Castability | 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;
Type Castability 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 castability is true.
Otherwise, the castability is false.
Type Castability | 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;
Type Castability to String
If the type of LEFT_OPERAND is the string type and the type of RIGHT_OPERAND is the string type, the castability 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 castability 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 castability is true and the runtime type checking is performed.
Type Castability | 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;
Type Castability 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 castability is true.
The type of RIGHT_OPERAND is other than above, the castability 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.
Type Castability | 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;
Type Castability 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 castability is true.
If the type of LEFT_OPERAND is a super class of the type of right operand, the castability is true.
If the type of RIGHT_OPERAND is a super class of the type of left operand, the castability is true.
Otherwise, the castability is false.
If the type of RIGHT_OPERAND is the any object type object
or an interface type, the runtime type checking is performed.
Type Castability | 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;
Type Castability 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 castability is true.
If the type of RIGHT_OPERAND is a class type and the class has the interface of LEFT_OPERAND, the castability is true.
Otherwise, the castability is false.
If the type of RIGHT_OPERAND is the any object type object
, an interface type, the runtime type checking is performed.
Type Castability | 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;
Type Castability 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 castability is true.
Otherwise, the castability is false.
If the type of RIGHT_OPERAND is a numeric type, the boxing conversion is performed.
Type Castability | 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;
Type Castability to Numeric Array
If the type of LEFT_OPERAND is the byte[] type and the type of RIGHT_OPERAND is the string type, the castability 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 castability is true.
Otherwise, the castability 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.
Type Castability | 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;
Type Castability 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 castability is true.
Otherwise, the castability is false.
If the type of RIGHT_OPERAND is the any object type obejct
, the runtime type checking is performed.
Type Castability | 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;
Type Castability 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 castability is true.
Otherwise, the castability 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.
Type Castability | 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;
Type Castability 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 castability is true.
If the basic type of RIGHT_OPERAND is a super class of the basic type of LEFT_OPERAND, the castability 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 castability is true.
Otherwise, the castability 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.
Type Castability | 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;
Type Castability 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 castability is true.
If the type of RIGHT_OPERAND is the same type of LEFT_OPERAND, the castability is true.
If the type of RIGHT_OPERAND is an differnt type of interface array type, the castability 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 castability is true.
Otherwise, the castability 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.
Type Castability | 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;
Type Castability 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 castability is true.
If the type of RIGHT_OPERAND is an any object type, the castability is true.
Otherwise, the castability is false.
If the type of RIGHT_OPERAND is an any object type, the runtime type checking is performed.
Type Castability | 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;
Type Castability 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 castability is true.
If the type of RIGHT_OPERAND is an any object type, the castability 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 castability 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 castability 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 castability is true.
Otherwise, the castability is false.
Type Castability | 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 two 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 "Type Assignability" 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 $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
}
Runtime Type Assignability
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 type assignability.
The runtime assignability is the assignability at runtime.
The isa operator checks the "Runtime Type Assignability" in runtime assignability
The runtime assignability 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 assignability is true.
If the type of the distribution is the same as the type of the source, the runtime assignability 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 assignability 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 assignability 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 assignability 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 assignability is true.
Runtime Type Assignability | 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 two 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.
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.
Copyright & License
Copyright (c) 2023 Yuki Kimoto
MIT License