Tipos

import System;

into namespace Bank
{
	public class Account
	{
		public:
			new(str owner, i32 start)
			{
				this.owner = owner;
				balance = start;
				Opened += 1;
			}

			str Owner { get => owner; }
			i32 Balance { get { return balance; } private set { balance = value; } }
			static i32 Opened { get; set; }

			Deposit(i32 amount)
			{
				Balance = balance + amount;
			}

		private:
			str owner;
			i32 balance;
	}

	Main()
	{
		Account a = new Account("Ana", 10);
		a.Deposit(5);
		Account b = a;
		b.Deposit(1);
		Console.WriteLine(a.Owner + " has " + a.Balance);
		Console.WriteLine(Account.Opened + " account opened");
	}
}

$ larva run
Ana has 16
1 account opened

import System;

into namespace Geometry
{
	public value Size
	{
		public:
			i32 Width;
			i32 Height;

			// No body: each parameter is stored in the field of the same name.
			new(i32 Width, i32 Height);

			// Calls the other constructor.
			new(i32 side) : (side, side);

			i32 Area { get => Width * Height; }
	}

	public class Label
	{
		readonly str text;

		public:
			new(str text) { this.text = text; }
			override ToString() : str => "[" + text + "]";
	}

	Main()
	{
		Size square = new Size(4);
		Console.WriteLine(square.Area);
		Console.WriteLine(new Label("ok"));
	}
}

$ larva run
16
[ok]

public static class Settings
{
	public:
		static i32 Retries = 3;
		Describe() : str => "retries: " + Retries;
}

import System;

public value Point
{
	public:
		i32 X;
		i32 Y;
		new(i32 X, i32 Y);
		Length2() : i32 => X * X + Y * Y;
		Move(i32 dx) { X = X + dx; }
}

Main()
{
	Point p = new Point(3, 4);
	Point q = p;
	q.X = 0;
	p.Move(1);
	Console.WriteLine(p.Length2() + " " + q.Length2());
}

$ larva run
32 16

import System;

into namespace Shapes
{
	public interface IShape
	{
		Area() : f64;
		Describe() : str => "a shape of area " + Area();
	}

	public base class Shape : IShape
	{
		public:
			Area() : f64;
			virtual Name() : str => "shape";
	}

	public class Circle : Shape
	{
		f64 radius;

		public:
			new(f64 radius) { this.radius = radius; }
			override Area() : f64 => 3.14 * radius * radius;
			override Name() : str => "circle";
	}

	public final class Square : Shape
	{
		f64 side;

		public:
			new(f64 side) { this.side = side; }
			override Area() : f64 => side * side;
	}

	Main()
	{
		List<Shape> shapes = new List<Shape>();
		shapes.Add(new Circle(1));
		shapes.Add(new Square(2));
		loop (Shape s in shapes)
			Console.WriteLine(s.Name() + ": " + s.Area());

		IShape i = new Square(3);
		Console.WriteLine(i.Describe());

		Shape first = shapes[0];
		if (first is Circle c)
			Console.WriteLine("a circle of area " + c.Area());
		Square? square = first as Square;
		Console.WriteLine(square == null);
	}
}

$ larva run
circle: 3.14
shape: 4
a shape of area 9
a circle of area 3.14
true

import System;

into namespace Palette
{
	public enum Size { Small, Medium = 5, Large }

	public enum Word : str { Hello = "hola", World }

	public bitflag enum Access : u8 { Read, Write, Execute, All = declbits }

	public record value Rgb
	{
		public:
			u8 R;
			u8 G;
			u8 B;
			new(u8 R, u8 G, u8 B);
	}

	public enum Color : Rgb
	{
		Red = new Rgb(255, 0, 0),
		Green = new Rgb(0, 255, 0),
	}

	Main()
	{
		Size s = Size.Large;
		Console.WriteLine(s + " is " + (i32)s);
		Console.WriteLine((str)Word.Hello + " " + (str)Word.World);

		Access a = Access.Read | Access.Write;
		Console.WriteLine((a & Access.Write) == Access.Write);
		Console.WriteLine(a.HasFlag(Access.Execute));
		Console.WriteLine((u8)Access.All);

		Rgb green = (Rgb)Color.Green;
		Console.WriteLine(green);
	}
}

$ larva run
Large is 6
hola World
true
false
7
Rgb { R = 0, G = 255, B = 0 }

import System;

into namespace People
{
	public record class Person
	{
		public:
			str Name;
			i32 Age;
			new(str Name, i32 Age);
	}

	Main()
	{
		Person ana = new Person("Ana", 31);
		Person older = ana with { Age = 32 };
		Console.WriteLine(ana);
		Console.WriteLine(ana == new Person("Ana", 31));
		Console.WriteLine(older.Age);
		if (ana is Person(var name, > 30))
			Console.WriteLine(name + " is over 30");
		Console.WriteLine(older is { Name: "Ana", Age: 32 });
	}
}

$ larva run
Person { Name = Ana, Age = 31 }
true
32
Ana is over 30
true

import System;

MinMax(i32[] values) : (i32, i32)
{
	i32 low = values[0], high = values[0];
	loop (i32 v in values)
	{
		if (v < low)
			low = v;
		if (v > high)
			high = v;
	}
	return (low, high);
}

Main()
{
	(i32, i32) range = MinMax([4, 9, 1, 7]);
	Console.WriteLine(range);
	Console.WriteLine(range.Item2 - range.Item1);

	(i32, str) pair = (1, "one");
	if (pair is (1, var word))
		Console.WriteLine(word);

	Dictionary<(i32, i32), str> grid = new Dictionary<(i32, i32), str>();
	grid[(0, 1)] = "a";
	Console.WriteLine(grid[(0, 1)]);
}

$ larva run
(1, 9)
8
one
a

import System;

public class Person
{
	public:
		str Name;
		new(str Name);
}

Find(str name) : Person?
{
	if (name == "ana")
		return new Person("Ana");
	return null;
}

Main()
{
	Person? found = Find("ana");
	Person? missing = Find("bob");
	Console.WriteLine(found?.Name ?? "nobody");
	Console.WriteLine(missing?.Name ?? "nobody");

	i32? count = null;
	Console.WriteLine(count ?? -1);
	count = 7;
	Console.WriteLine(count.HasValue);
	Console.WriteLine(count.Value);

	if (found is Person p)
		Console.WriteLine("found " + p.Name);
}

$ larva run
Ana
nobody
-1
true
7
found Ana