Zig

// 1. Zig 기본 문법
const std = @import("std");

pub fn main() void {
    // 변수 선언 (const: 불변, var: 가변)
    const name: []const u8 = "Zig";
    var count: u32 = 0;
    count += 1;

    // 배열과 슬라이스
    const numbers = [_]i32{ 1, 2, 3, 4, 5 };
    const slice = numbers[1..4];  // [2, 3, 4]

    // 구조체
    const Point = struct {
        x: f32,
        y: f32,

        fn distance(self: Point, other: Point) f32 {
            const dx = self.x - other.x;
            const dy = self.y - other.y;
            return @sqrt(dx * dx + dy * dy);
        }
    };

    const p1 = Point{ .x = 0, .y = 0 };
    const p2 = Point{ .x = 3, .y = 4 };
    const dist = p1.distance(p2);  // 5.0

    // 열거형
    const Color = enum { red, green, blue };
    const myColor = Color.green;

    // switch 표현식
    const rgb = switch (myColor) {
        .red => [_]u8{ 255, 0, 0 },
        .green => [_]u8{ 0, 255, 0 },
        .blue => [_]u8{ 0, 0, 255 },
    };

    // 출력
    std.debug.print("{s} 언어, count: {}\n", .{ name, count });
}

// 2. Comptime (컴파일 타임 실행)
const std = @import("std");

// comptime 파라미터로 제네릭 구현
fn Matrix(comptime T: type, comptime rows: usize, comptime cols: usize) type {
    return struct {
        data: [rows][cols]T,

        const Self = @This();

        pub fn init(value: T) Self {
            return .{ .data = [[_]T{value} ** cols] ** rows };
        }

        pub fn get(self: Self, row: usize, col: usize) T {
            return self.data[row][col];
        }

        pub fn set(self: *Self, row: usize, col: usize, value: T) void {
            self.data[row][col] = value;
        }
    };
}

// 컴파일 타임 문자열 처리
fn compileTimeConcat(comptime a: []const u8, comptime b: []const u8) []const u8 {
    return a ++ b;
}

// 컴파일 타임 계산
fn fibonacci(comptime n: u32) u32 {
    if (n < 2) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

pub fn main() void {
    // 컴파일 타임에 타입 생성
    const Mat3x3 = Matrix(f32, 3, 3);
    var matrix = Mat3x3.init(0.0);
    matrix.set(1, 1, 5.0);

    // 컴파일 타임 문자열 연결
    const greeting = compileTimeConcat("Hello, ", "Zig!");
    // "Hello, Zig!" - 런타임 비용 없음

    // 컴파일 타임 피보나치 계산
    const fib10 = fibonacci(10);  // 컴파일 시 55로 치환됨

    // comptime 블록
    const hash = comptime blk: {
        var result: u32 = 0;
        for ("compile-time-hash") |c| {
            result = result *% 31 +% c;
        }
        break :blk result;
    };

    std.debug.print("fib(10) = {}, hash = {}\n", .{ fib10, hash });
}

// 3. 에러 핸들링
const std = @import("std");

// 에러 집합 정의
const FileError = error{
    NotFound,
    PermissionDenied,
    OutOfMemory,
};

// 에러 유니온 타입 반환
fn readConfig(path: []const u8) FileError![]u8 {
    if (std.mem.eql(u8, path, "")) {
        return FileError.NotFound;
    }
    // 실제 파일 읽기 로직...
    return "config_data";
}

// try 키워드: 에러 시 즉시 반환
fn loadSettings() !void {
    const config = try readConfig("settings.json");
    std.debug.print("Config: {s}\n", .{config});
}

// catch로 에러 처리
fn safeRead(path: []const u8) []const u8 {
    return readConfig(path) catch |err| switch (err) {
        FileError.NotFound => "default_config",
        FileError.PermissionDenied => {
            std.debug.print("Permission denied!\n", .{});
            return "restricted";
        },
        else => "unknown_error",
    };
}

// Optional 타입 (?T)
fn findFirst(haystack: []const u8, needle: u8) ?usize {
    for (haystack, 0..) |char, index| {
        if (char == needle) return index;
    }
    return null;  // 찾지 못함
}

pub fn main() !void {
    // 에러 처리 패턴들
    const result = readConfig("app.json") catch "fallback";
    std.debug.print("Result: {s}\n", .{result});

    // orelse로 Optional 처리
    const text = "Hello, Zig!";
    const pos = findFirst(text, 'Z') orelse {
        std.debug.print("Not found\n", .{});
        return;
    };
    std.debug.print("Found at: {}\n", .{pos});

    // if로 Optional 언래핑
    if (findFirst(text, 'x')) |index| {
        std.debug.print("Found x at {}\n", .{index});
    } else {
        std.debug.print("x not found\n", .{});
    }

    // errdefer: 에러 발생 시에만 실행
    const allocator = std.heap.page_allocator;
    const buffer = try allocator.alloc(u8, 1024);
    errdefer allocator.free(buffer);  // 이후 에러 시 자동 해제
    // ... buffer 사용 ...
}