Members

The members of a class, value, record or interface are declared inside its braces, usually grouped under access sections:

Fields

A field is declared like a variable. It can have an initializer, which runs when the object is made, before the constructor's body. Several fields of one type can share a declaration:

public class Point
{
	public:
		i32 X = 1, Y = 2, Z;
		readonly str Name = "p";
}

A field without an initializer starts at zero when its type has one (numbers, bool, enums, values, nullable types). A field of a class type or str with no initializer must be set by every constructor before it is used.

A field cannot be void (AN1021), and a name can be declared once per type (AN1020). virtual, override and final do not apply to fields (AN1102).

Constants

const T Name = value; declares a constant: a value computed when the program compiles and written into the code where it is used. A constant is static by nature; static, readonly, fixed and reactive do not go with it (AN1086). Constants can be declared in a type, in a namespace and inside a body.

import System;

public value Point
{
	public:
		i32 X;
		i32 Y;
		new(i32 X, i32 Y);
}

public static class Limits
{
	public:
		const i32 Base = 10;
		const i64 Widest = Int32.MaxValue + 1i64;
		const str Label = "max " + "size";
		const f64 Half = Base / 2.0;
		const Point Origin = new Point(Base, -Base);
}

Main()
{
	const i32 local = Limits.Base * 3;
	Console.WriteLine(Limits.Widest + " " + Limits.Label + " " + Limits.Half);
	Console.WriteLine(Limits.Origin.Y + local);
}

$ larva run
2147483648 max size 5
20

• The type of a constant is a number, bool, a character, str, an enum, a nullable type (for null) or a value (AN1088). Arrays and classes are not constants.
• Its value is made of literals, other constants (wherever they are declared, even later in the file), enum members, the operators - ~ ! + - * / % & | ^ << >> && || ?? == != < <= > >=, casts between numbers and enums, and ?: (AN1091 otherwise). Integer arithmetic wraps as it does at run time.
• A value constant is made with new and constant arguments (AN1089), and none of its fields can change.
• A constant cannot depend on itself (AN1090) and cannot be assigned (AN2071, AN2140).
• The limits of the number types (Int32.MaxValue, Float64.Epsilon…) are constants. Name them through the library type: i32.MaxValue gives the same value, but not as a constant (AN1091 in a constant).

Constructors

new(parameters) { … } is a constructor. A type can have several, with different parameters (two with the same ones are AN1033). A class without any gets an empty one. Only classes and values have constructors (AN1032).

import System;

public class Shape
{
	public:
		i32 Id;
		new(i32 Id);
}

public class Circle : Shape
{
	public:
		f64 Radius;
		new(i32 id, f64 Radius) : base(id);
		new(f64 r) : (0, r);
		new() : (1.0) { Console.WriteLine("default circle"); }
}

Main()
{
	Circle c = new Circle(7, 2.5);
	Circle d = new Circle();
	Console.WriteLine(c.Id + " " + c.Radius + " " + d.Id + " " + d.Radius);
}

$ larva run
default circle
7 2.5 0 1

The access of a constructor controls who can make objects: new Token() from outside a type whose constructors are private is AN1401.

Destructors

A class can declare one destructor, destroy(): no parameters, no result, not static (AN1078). It runs once, when the object stops existing, and a derived class's destructor runs before its base's. When that is depends on the project's memory mode; see Memory. Values, interfaces and enums have none (AN1077).

public class File
{
	public:
		destroy() { Console.WriteLine("closed"); }
}

Properties

A property is read and written like a field, through accessors:

import System;

public class Temperature
{
	f64 celsius;

	public:
		f64 Celsius { get => celsius; set { celsius = value; Changes += 1; } }
		f64 Fahrenheit { get => celsius * 9 / 5 + 32; }
		static i32 Changes { get; set; }
		virtual str Unit { get => "C"; }
}

public class Kelvin : Temperature
{
	public:
		override str Unit { get => "K"; }
}

Main()
{
	Temperature t = new Kelvin();
	t.Celsius = 100;
	Console.WriteLine(t.Fahrenheit + " " + Temperature.Changes + " " + t.Unit);
}

$ larva run
212 1 K

• A property needs a get (AN1044). Assigning one without set is AN2095.
• An accessor can have a narrower access than its property (private set).
• Properties can be static, virtual and override, like methods.
• Properties belong to classes, values and interfaces (AN1043).

Indexers

Antril has no indexer declaration. Indexing an object calls its methods by name:

import System;

public class Board
{
	i32[] cells = new i32[9];

	public:
		At(i32 x, i32 y) : i32 => cells[y * 3 + x];
		SetAt(i32 x, i32 y, i32 v) { cells[y * 3 + x] = v; }
}

Main()
{
	Board b = new Board();
	b[1, 2] = 7;
	Console.WriteLine(b[1, 2]);
}

$ larva run
7

List<T>, Dictionary<K, V> and str are indexed this way.

Methods

A method is a function declared in a type: Name(parameters) : Result with a block body, an expression body after =>, or (in a base class or interface) no body. Without : Result it returns nothing. Methods follow the rules of functions: overloads, generic methods, async, iterators.

• An instance method runs on an object: inside it, this is that object (or that value), and the type's members can be named directly.
• A static method belongs to the type and is called through it: MathX.Twice(4). It has no this (AN2029), and instance members are not available in it (AN2034).
• A method and a field or property cannot share a name (AN1031).

virtual, override and final

• Methods are not virtual unless they say so. A method that has the same signature as a virtual method of its base must say override (AN1038).
• Only instance methods of classes are virtual (AN1029); virtual in a class nothing can derive from is AN1100.
• final alone, or with virtual, is AN1101: a method that is not virtual is final already.
• A bodiless method in a base class is abstract: derived classes must override it.
• Overloads of a virtual method are separate: overriding one does not replace the others.

public class A
{
	public:
		virtual Name() : str => "a";
}

public class B : A
{
	public:
		final override Name() : str => "b";
}

Modifiers on members

A modifier can be written once per declaration (AN0013), and one access word at most (AN0038).