Crea software rápido,
a tu manera.

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

import System;
import System.Threading.Tasks;

into namespace Jobs
{
    async Fetch(i32 id) : Task<i32>
    {
        await Task.Delay(10);
        return id * 10;
    }

    async Total() : Task<i32>
    {
        i32 a = await Fetch(1);
        i32 b = await Fetch(2);
        return a + b;
    }

    async Tick(str name, i32 times) : Task
    {
        loop (i32 i = 0..times)
        {
            Console.WriteLine(name + " " + i);
            await Task.Yield();
        }
    }

    Main()
    {
        Console.WriteLine(Total().Result);
        Task[] both = [Tick("a", 2), Tick("b", 2)];
        Task.WhenAll(both).Wait();
    }
}

import System;
import System.Reactive;

into namespace Ui
{
    public class Cart
    {
        public:
            reactive i32 items = 0;
            reactive f64 price = 2.5;
            computed f64 Total => items * price;

            reacts Log()
            {
                Console.WriteLine("items: " + items);
            }
    }

    Main()
    {
        Cart cart = new Cart();
        Effect shown = effect { Console.WriteLine("total: " + cart.Total); };
        cart.items = 2;
        Reactive.Batch(() => { cart.items = 3; cart.price = 4.0; });
        shown.Dispose();
        cart.items = 10;
    }
}

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

import System;

unsafe Fill(i32* p, i32 count, i32 value)
{
    loop (i32 i = 0..count)
        p[i] = value;
}

Main()
{
    i32[] data = new i32[4];
    unsafe
    {
        Fill(&data[0], data.Length, 9);
        i32* second = &data[0] + 1;
        *second = 1;
    }
    Console.WriteLine(data[0] + data[1] + data[2] + data[3]);
}