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;

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 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) {
    
  }

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 ();
  }

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 undef 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 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]];
  }

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.

Cast Requirement	To	From	Conversion or Type Checking
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
True	byte	short	Numeric Narrowing Conversion
True	byte	int	Numeric Narrowing Conversion
True	byte	long	Numeric Narrowing Conversion
True	byte	float	Numeric Narrowing Conversion
True	byte	double	Numeric Narrowing Conversion
True	short	int	Numeric Narrowing Conversion
True	short	long	Numeric Narrowing Conversion
True	short	float	Numeric Narrowing Conversion
True	short	double	Numeric Narrowing Conversion
True	int	long	Numeric Narrowing Conversion
True	int	float	Numeric Narrowing Conversion
True	int	double	Numeric Narrowing Conversion
True	long	float	Numeric Narrowing Conversion
True	long	double	Numeric Narrowing Conversion
True	float	double	Numeric Narrowing Conversion

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 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 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 "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 undef, 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 undef, 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 undef, 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 undef, 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 undef, 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 undef, 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 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.

Copyright & License

MIT License

To install SPVM, copy and paste the appropriate command in to your terminal.

cpanm

cpanm SPVM

CPAN shell

perl -MCPAN -e shell
install SPVM

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)