++ed by:

14 PAUSE users
7 non-PAUSE users.

Author image Yuki Kimoto


SPVM::Document::Language - SPVM Language


  package Point {
    has x : int;
    has y : int;
    sub new : Point ($x : int, $y : int) {
      my $self = new Point;
      $self->{x} = $x;
      $self->{y} = $y;
      return $self;
    sub clear ($self : self) {
      $self->{x} = 0;
      $self->{y} = 0;
  package HTTP::Message::Request {

Use Module

  package Foo {
    use Point;
    use HTTP::Message::Request;


  package Point {
    has x : int;
    has y : int;


Subroutine Definition is the following.

  descripter_names sub sub_name : type_name (arg_name : type_name, ...) {

sub_name is subroutine name. Subroutine name is consist of Upper Case and Lower Case and Number and Under Score _. Subroutine name must not start with Number. Under score must not continue more than one.

  # Legal
  # Illegal

arg_name is Argument Name. This is Variable name. Variable name is explained in "Variable Declaration" section,

type_name is a Type. Type is explained "Type" section.

arg_name : type_name can be repeated with ,. If argument is none, that is ok. Max arguments count is 255.

descripter_name is a Descripter. If descripter is none, that is ok. Available descripters are following. Currently only one descripter is available.

  [Name]     [Description]
  native     the subroutine is native

Native subroutine is explained in "Native Subroutine".

return_type_name is a Type or void. void mean the subroutine don't have return value. Type is explained "Type" section.

Subroutine Definition must be just under Package Definition.

  # Legal
  package PackageName {
    sub foo : int ($values : int[]) {
  # Illeagal
  sub foo : double () {
    sub var() : void {

Variable Declaration

Variable Declaration is the following.

  my var_name : type_name;

var_name is Variable Name. Variable Name first character is $. Rest characters is consist of Upper case, Lower case, Number and Under score _.

  # Legal

If Variable Declaration is done, you can use variable after the Definition.

type_name is a <Type>. Type is explained at "Type" section.

You can Initialize the variable as same time as Variable Declaration.

  my $num : int = 3;

Variable Declaration Example:

  # Numeric Type
  my $value : byte;
  my $value : short;
  my $value : int;
  my $value : long;
  my $value : float;
  my $value : double;
  # Array Type
  my $values : byte[];
  my $values : short[];
  my $values : int[];
  my $values : long[];
  my $values : float[];
  my $values : double[];
  my $values : PackageName[];

  # Multiple Dimension Array Type
  my $values : byte[][];
  my $values : short[][];
  my $values : int[][];
  my $values : long[][];
  my $values : float[][];
  my $values : double[][];
  my $values : PackageName[][];

  # Package Type
  my $obj : PackageName;

Type Inference

If the Type of right value is known, the type of left value is automatically decided.

  my $num = 2;
  my $obj = new Foo;
  my $values = new int[3];

Above is same as the following.

  my $num : int = 2;
  my $obj : Foo = new Foo;
  my $values : int[3] = new int[3];

Number Literal

Int Literal

Int Literal is composed of


For example:


Default Number Literal Type is int.

  # Type is int

You can use hex number literal by start 0x.

a, b, c, d, e, f, A, B, C, D, E, F is used as hex number.


You can use octal number literal by start 0.


You can use binary number literal by start 0b.


You can use under line _ in number literal. Under line is meanless, only for visuality.


You can use type specifier to specify integer leteral type.

  • L

      # Long
  • f

      # Float
  • d

      # Double

Floating Point Literal

If you use . in number literal, the number is floating point literal. Default type of floating point value is double.


You can use E or e to specify exponential notation.


You can use type specifier to specify integer leteral type.

  • f

      # Float
  • d

      # Double

If you know more Type, see "Type" section.

String Literal

String Literal is the following.


Type of String literal is const byte[].

  my $string : const byte[] = "abc";

string is short name of const byte[]. You can also write the following.

  my $string : string = "abc";

If you use type inference, you can also write the follwoing.

  my $string = "abc";

Escape Sequences

A character preceded by a backslash (\) is an escape sequence and has special meaning to the compiler. The following table shows the SPVM escape sequences:

  [Escape Sequences]    [Escape Sequence        Description]
  \t                    Insert a tab in the text at this point.
  \b                    Insert a backspace in the text at this point.
  \n                    Insert a newline in the text at this point.
  \r                    Insert a carriage return in the text at this point.
  \f                    Insert a formfeed in the text at this point.
  \'                    Insert a single quote character in the text at this point.
  \"                    Insert a double quote character in the text at this point.
  \\                    Insert a backslash character in the text at this point.

Undefined Literal

Undefined Literal is:



The SPVM programming language is a statically typed language, which means that every variable and every expression has a type that is known at compile time.

The SPVM programming language is also a strongly typed language, because types limit the values that a variable can hold or that an expression can produce, limit the operations supported on those values, and determine the meaning of the operations. Strong static typing helps detect errors at compile time.

The types of the SPVM programming language are divided into two categories: numeric types and reference types. The numeric types are the numeric types. The numeric types are the integral types byte, short, int, long, and the floating-point types float and double. The reference types are package types, and array types. There is also a special undef type. An object is a dynamically created instance of a package type or a dynamically created array. The values of a reference type are references to objects. String literals are represented by array of byte.

Numeric Type

Numeric types are byte, short, int, long, float, double.

  [Type]  [Type Description]   [Type Bit Size]
  byte    Integral type        8-bit
  short   Integral type        16-bit
  int     Integral type        32-bit
  long    Integral type        64-bit
  float   floating-point type  32-bit
  double  floating-point type  64-bit

Numeric values do not share state with other numeric values.

The numeric types are the integral types and the floating-point types.

The integral types are byte, short, int, and long, whose values are 8-bit, 16-bit, 32-bit and 64-bit signed two's-complement integers.

The floating-point types are float, whose values include the 32-bit IEEE 754 floating-point numbers, and double, whose values include the 64-bit IEEE 754 floating-point numbers.

The values of the integral types are integers in the following ranges:

For byte, from -128 to 127, inclusive

For short, from -32768 to 32767, inclusive

For int, from -2147483648 to 2147483647, inclusive

For long, from -9223372036854775808 to 9223372036854775807, inclusive

Varialbe Definition

Varialbe Definition with Type is the following.

  my $value : byte;
  my $value : short;
  my $value : int;
  my $value : long;
  my $value : float;
  my $value : double;

If you know more Variable Declaration, see "Variable Declaration" section.

Array Type

Array Type describe multiple values.

  [Type]         [Type Description]
  byte[]         byte array
  short[]        short array
  int[]          int array array
  long[]         long array
  float[]        float array
  doube[]        double array
  PackageName[]  object array

Array Type is a Object Type. You can create Array by new keyword.

  my $values : int[] = new int[3];

If you know more Array Creating, see "New Array" section.

Multiple Dimention Array Type

Multiple Dimention Array Type is a Array Type.

Two Dimension Array Type


Three Dimension Array Type


Max Dimension is 255.

You can create Multiple Dimension Array by new keyword.

  my $values : int[][] = new int[][3];

This mean that Multiple Dimension Array is created, the multiple dimension array have 3 int[] type array. The elements is initialized by undef.

If you know Multiple Dimension Array Creating, see "New Multiple Dimention Array".

Package Type

If Package is defined, Package name is used as Type.


If you know more Package Definition, see "Package Definition" section.

You can create Object by new subroutine. This is Default Constructor.

  my $obj : PackageName = PackageName->new;

New Array

Array is created by new. Elements values is not initialized.

  my $values = new byte[3];
  my $values = new short[3];
  my $values = new int[3];
  my $values = new long[3];
  my $values = new float[3];
  my $values = new double[3];

Array Initialization

Array Initialization Syntax:

  my $values = new int[] {1, 2, 3};
  my $points = new Point[] {Point->new(), Point->new(), Point->new()};

Array Manipulation

Get Array Length

You can use the three ways to get Array Length.

  len $values;

Get and Set Array Element

Get Array Element:

  # Get

Set Array Element:

  # Set
  $values->[0] = 5;

Object Manipulation

Field Access

Get field:

  # Get field

Set field:

  # Set field;
  $object->{foo} = 5;

Field value is private. You can only use Field Access from self package.

Condition branch

  if (1) {

  elsif (2) {

  else {


Loop Syntax

for statement

  my $values = new int[10];
  for (my $i = 0; $i < @$values; $i++) {
    $values->[$i] = 0;

while statement

  my $values = new int[10];
  my $i = 0;
  while ($i < @$values) {
    $values->[$i] = 0;



  # Comment


Pod syntax:



Script Ending:



Throw Exception

Throw Exception:

  croak "Error";

Catch Exception

Catch Exception:

  eval {
    croak "Error";

Exception Message



new operator

Constructor is new operator.

  new Point;

new operator is private. new operator is only used in same package.


If new subroutine is not defined, Default Constructor is defined automatically.

  sub new ($class : class) { return new Point }

This is used from other package.

  my $point = Point->new();



  package Foo {
    sub DESTROY : void ($self : Foo) {



  package Foo {
    enum {
    enum {
      FORE = 4,

Weak Reference

weaken operator

Using Weak Reference, recursive reference is resolved.

  my $foo = Foo->new();
  my $bar = Bar->new();
  # Recursive reference
  # Weak reference

Foo package;

  package Foo {
    has bar;
    set bar;
    sub wekan_bar : void () {
      weaken $foo->{bar};

Extension native function

  package TestCase::Extension {
    native sub sum : int ($num1 : int, $num2 : int);


Assign Operator


Special Assign Operator


Basic Operator


Comparison Operator


Logical Operator


Bit Operator


Increment/Decrement Operator