Tinoc docs

#import std.io;

// Main function
fn main() void {
    var name str = "Prathmesh";
    const lang = "Tinoc";

    io.println("{s} is creator of {s} Programming Language!", name, lang);
}

#include <stdio.h>
#include <tinoc.h>

int main() {
    str name = {"Prathmesh", 9};
    const str lang = {"Tinoc", 5};

    printf("%s is creator of %s Programming Language!\n", name.data, lang.data);
}

fn main() void {
    var name str = "Lucifer";
    name = "Julius";

    var number = 101;        // inferred as i32
    number += 10;

    var isAdmin = false;     // inferred as bool
    isAdmin = true;
}

fn main() void {
    const lang str = "Tinoc";
    const codename = "C^";

    // lang = "Tinoc Is Not C"
    // Won't work — compile error.
}

const decimal_int = 98222;
const hex_int = 0xff;
const another_hex_int = 0xFF;
const octal_int = 0o755;
const binary_int = 0b11110000;

// underscores may sit between two digits as a visual separator
const one_billion = 1_000_000_000;
const binary_mask = 0b1_1111_1111;
const permissions = 0o7_5_5;
const big_address = 0xFF80_0000_0000_0000;

const floating_point = 123.0E+77;
const another_float = 123.0;
const yet_another = 123.0e+77;
const hex_floating_point = 0x103.70p-5;
const another_hex_float = 0x103.70;
const yet_another_hex_float = 0x103.70P-5;

// underscores may sit between two digits as a visual separator
const lightspeed = 299_792_458.000_000;
const nanosecond = 0.000_000_001;
const more_hex = 0x1234_5678.9ABC_CDEFp-10;

#import std.math;

const inf = math.inf();
const negative_inf = - math.inf();
const nan = math.nan();

#import std.io;

fn add(a i8, b i8) i8 {
    return a + b;
}

fn greet() void {
    io.println("Hi");
}

fn Identity:T(val T) T {
    return val;
}

fn main() void {
    const result = add(10, 25);
    greet();
    io.println("result = {d}", result);
    io.println("{any}", Identity:str("Tinoc"));
}

#import std.io;

// simple struct with method
struct Point {
    x f32;
    y f32;

    fn translate(self ^Point, dx f32, dy f32) void {
        self^.x += dx;
        self^.y += dy;
    }

    fn length(self ^Point) f32 {
        return sqrt(self^.x * self^.x + self^.y * self^.y);
    }
}

// generic struct with method
struct Pair:T {
    first T;
    second T;

    fn swap(self ^Pair:T) void {
        var tmp T = self^.first;
        self^.first = self^.second;
        self^.second = tmp;
    }
}

// multi-param generic struct
struct Map:(K, V) {
    key K;
    value V;
}

fn main() void {
    var p Point = Point { .x = 1.0, .y = 2.0 };
    p.translate(0.5, 1.5);

    var pair Pair:i32 = Pair:i32 { .first = 10, .second = 20 };
    pair.swap();
    io.println("{any}", p);
}

#import std.{io, collection.*};

enum Direction {
    North, East, South, West,
}

// enum with data and method
enum Shape {
    Circle(f32),       // radius
    Rect(f32, f32),    // width, height
    Point,

    fn area(self ^Shape) f32 {
        // match on self variant
    }
}

enum Literal {
    String(hstr),
    Integer(usize),
    // …
    // enums can also have methods and static methods, like structs
}

enum Something:T {
    First,
    Second(T),
}

fn main() void {
    const direction1 = Direction.North;
    io.println("{any}", direction1);

    const literal1 = Literal.String(hstr.from("String Literal"));
    io.println("{any}", literal1); // prints: String("String Literal")

    var s Shape = Shape.Circle(5.0);
    var a f32 = s.area();
}

// simple union with method
union Data {
    as_int i32;
    as_float f32;
    as_bytes [4]u8;

    fn zero(self ^Data) void {
        self^.as_int = 0;
    }
}

// generic union with method
union Either:T {
    value T;
    raw u64;

    fn clear(self ^Either:T) void {
        self^.raw = 0;
    }
}

// multi-param generic union
union OneOf:(A, B) {
    a A;
    b B;
}

fn main() void {
    var d Data;
    d.as_int = 42;
    d.zero();
    // d.as_float now reads the same memory as f32
}

// array literal
const message = ['h', 'e', 'l', 'l', 'o'];

// alternative initialization using a result location
const alt_message [5]u8 = ['h', 'e', 'l', 'l', 'o'];

const mat4x5 [4][5]f32 = [
    [1.0, 0.0, 0.0, 0.0, 0.0],
    [0.0, 1.0, 0.0, 1.0, 0.0],
    [0.0, 0.0, 1.0, 0.0, 0.0],
    [0.0, 0.0, 0.0, 1.0, 9.9],
];

#import std.testing.expectEqual;

test "0-terminated sentinel array" {
    const array [_:0]u8 = [1, 2, 3, 4];

    try expectEqual([4:0]u8, @TypeOf(array));
    try expectEqual(4, array.len);
    try expectEqual(0, array[4]);
}

enum TokenKind {
    Int,
    Ident,
    Plus,
    Eof,
}

fn main() void {
    var tok TokenKind = TokenKind.Plus;

    switch tok {
        TokenKind.Int   => { /* handle int */ }
        TokenKind.Ident => { /* handle ident */ }
        TokenKind.Plus  => { /* handle plus */ }
        _               => { /* default */ }
    }

    var x i32 = 2;

    switch x {
        1 => { /* one */ }
        2 => { /* two */ }
        _ => { /* anything else */ }
    }
}

fn main() void {
    var x i32 = 10;

    if x > 0 {
        // positive
    }

    if x > 0 {
        // positive
    } else {
        // zero or negative
    }

    if x > 0 {
        // positive
    } else if x == 0 {
        // zero
    } else {
        // negative
    }
}

fn main() void {
    // range loop — 0 to 9
    for 0..10 |i| {
        // i goes 0, 1, 2, … 9
    }

    // range with a step is done with while, if needed
    var i i32 = 0;
    while i < 10 {
        i += 2;
    }

    // iterate over a slice
    var nums [5]i32 = [1, 2, 3, 4, 5];
    for nums |n| {
        // n is each element
    }
}

fn main() void {
    var i i32 = 0;

    // normal while
    while i < 10 {
        i += 1;
    }

    // infinite loop — break to exit
    while true {
        if i == 20 {
            break;
        }
        i += 1;
    }

    // do-while equivalent — run the body first, check at the end
    while true {
        i += 1;
        if i >= 5 {
            break;
        }
    }
}

pub fn add(a i32, b i32) i32 {
    return a + b;
}

#import std.io;
#import util;
#import std.collections.*;

fn main() void {
    // std.io symbols accessed via the module name
    io.println("Hello, Tinoc");

    // std.collections.* symbols available directly
    var v vec:i32;

    const result = util.add(125, 2022);
    io.println("{any}", result);
}