ShitRust

// Hello World in ShitRust - A simple example

// Function to generate a greeting
fn generate_greeting(name: string) -> string {
    let greeting = "Hello, " + name + "!";
    return greeting;
}

// Main function - entry point of the program
fn main() -> void {
    // Basic println
    println("Hello, ShitRust World!");
    
    // Variables with type inference
    let name = "ShitRust";
    let version = 0.2;
    
    // String concatenation and method calls
    println("Welcome to " + name + " version " + version.to_string() + "!");
    
    // Conditional statement
    if (version < 1.0) {
        println("This is an early preview version.");
    } else {
        println("This is a stable release.");
    }
    
    // Function call
    let message = generate_greeting("Programmer");
    println(message);
}

// Function definition
fn add(a: int, b: int) -> int {
    return a + b;
}

// Variables
let x = 5;          // Type inference
let mut y = 10;     // Mutable variable
let z: float = 3.14; // With type annotation

// Constants
const PI: float = 3.14159;
const MAX_SIZE: int = 100;

// Control flow
if x > y {
    println("x is greater");
} else {
    println("y is greater");
}

// Loops
while x > 0 {
    x = x - 1;
}

for i in 0..10 {
    println(i.to_string());
}

// Infinite loop with break
loop {
    if x > 10 {
        break;
    }
    x = x + 1;
}

// Match statement
match x {
    0 => println("Zero"),
    1 => println("One"),
    n if n < 10 => println("Single digit"),
    _ => println("Other"),
}

// Type aliases
type UserId = int;
type UserMap = HashMap;

// Generic struct
struct Point {
    x: T,
    y: T,
    
    fn distance_from_origin() -> float {
        return (this.x.to_float() * this.x.to_float() + 
                this.y.to_float() * this.y.to_float()).sqrt();
    }
    
    // Static method
    static fn origin() -> Point {
        return Point { x: T.from(0), y: T.from(0) };
    }
}

// Trait definition
trait Printable {
    fn print() -> void;
    fn debug_print() -> string;
}

// Implementing a trait
impl Printable for Point {
    fn print() -> void {
        println("Point(" + this.x.to_string() + ", " + this.y.to_string() + ")");
    }
    
    fn debug_print() -> string {
        return "Point { x: " + this.x.to_string() + ", y: " + this.y.to_string() + " }";
    }
}

// Result enum for error handling
enum Result {
    Ok(T),
    Err(E)
}

// Function returning a Result
fn divide(a: int, b: int) -> Result {
    if b == 0 {
        return Result::Err("Division by zero");
    }
    return Result::Ok(a / b);
}

// Async function with await
async fn fetch_data(url: string) -> Result {
    // Async code here
    await timing.sleep(1000);
    return Result::Ok("Data from " + url);
}

// Using async/await with error handling
fn process_data() -> void {
    try {
        let result = await fetch_data("https://api.example.com");
        match result {
            Result::Ok(data) => println("Success: " + data),
            Result::Err(err) => println("Error: " + err)
        }
    } catch e {
        println("Exception: " + e.to_string());
    }
}

// List comprehension
let numbers = [1, 2, 3, 4, 5];
let squares = [x * x for x in numbers if x % 2 == 0];

// Pipeline operator
let result = numbers 
    |> [x * 2 for x in _]
    |> _.filter(|x| -> bool { return x > 5; })
    |> _.sum();

// Optional chaining and nullish coalescing
let user = get_user(123);
let username = user?.name ?? "Unknown";
let isActive = user?.is_active() ?? false;