Getting Started with Vais

Vais는 AI 최적화된 시스템 프로그래밍 언어입니다. 단일 문자 키워드, 완전한 타입 추론, LLVM 백엔드를 제공합니다. 이 가이드를 따라 Vais를 설치하고 첫 번째 프로그램을 작성해보세요.

설치

시스템 요구사항

  • Rust 1.70 이상
  • LLVM 17
  • Git

소스에서 빌드

# Vais 저장소 클론
git clone https://github.com/vaislang/vais.git
cd vais

# 컴파일러 빌드
cargo build --release

# 설치 (선택 사항)
cargo install --path crates/vaisc

바이너리 설치

최신 릴리스에서 직접 다운로드할 수 있습니다:

# macOS / Linux
curl -L https://github.com/vaislang/vais/releases/latest/download/vaisc-$(uname -s | tr '[:upper:]' '[:lower:]')-$(uname -m) -o vaisc
chmod +x vaisc
sudo mv vaisc /usr/local/bin/

Hello World

첫 번째 프로그램 작성

hello.vais 파일을 생성합니다:

F main() -> i64 {
    puts("Hello, Vais!")
    0
}

컴파일 및 실행

# 방법 1: 컴파일 후 실행
vaisc build hello.vais -o hello
./hello

# 방법 2: 직접 실행 (vaisc run 사용)
vaisc run hello.vais

# 방법 3: REPL에서 실행
vaisc repl
> puts("Hello, Vais!")

첫 번째 프로젝트

프로젝트 구조 만들기

# 새로운 프로젝트 초기화
mkdir my-vais-app
cd my-vais-app

# 기본 폴더 구조
mkdir src
mkdir bin
touch Vais.toml

Vais.toml 작성

프로젝트 메타데이터 파일을 작성합니다:

[package]
name = "my-vais-app"
version = "0.1.0"
edition = "2024"

[dependencies]

[dev-dependencies]

소스 코드 구조

my-vais-app/
├── Vais.toml
├── src/
│   ├── lib.vais       # 라이브러리 코드
│   └── main.vais      # 메인 엔트리 포인트
└── bin/
    └── cli.vais       # 추가 바이너리 (선택 사항)

프로젝트 컴파일 및 실행

# 프로젝트 빌드
vaisc build

# 최적화 빌드
vaisc build --release

# 프로젝트 실행
vaisc run

# 테스트 실행
vaisc test

기본 문법 투어

변수 선언

# 불변 변수
x := 42
name := "Vais"

# 가변 변수 (mut 키워드)
counter := mut 0
counter = counter + 1

# 축약형 (~ = mut)
~ total := 0
total = total + 5

# 타입 명시 (선택 사항)
age: i64 = 25
pi: f64 = 3.14159

함수 정의

# 간단한 함수
F add(a: i64, b: i64) -> i64 = a + b

# 함수 본문 포함
F greet(name: str) -> str {
    message := "Hello, {name}!"
    message
}

# 반환값 명시
F factorial(n: i64) -> i64 {
    I n <= 1 {
        R 1
    }
    R n * factorial(n - 1)
}

# 기본값 없는 반환 (0 반환)
F print_info(msg: str) {
    puts(msg)
}

조건문

x := 42

# if/else 기본
I x > 0 {
    puts("positive")
} E {
    puts("not positive")
}

# if/else if/else
I x > 100 {
    puts("greater than 100")
} I x > 50 {
    puts("greater than 50")
} E {
    puts("50 or less")
}

# 삼항 연산자
result := x > 0 ? "positive" : "non-positive"

반복문

# for 루프 (범위)
F print_range() {
    L i := 0; i < 5; i = i + 1 {
        puts("{i}")
    }
}

# 무한 루프
F infinite_loop_example() {
    ~ count := 0
    L {
        I count >= 10 {
            B
        }
        puts("{count}")
        count = count + 1
    }
}

# while 루프 (조건 기반)
F while_example() {
    ~ x := 0
    L x < 10 {
        puts("{x}")
        x = x + 2
    }
}

구조체

# 구조체 정의
S Point {
    x: i64
    y: i64
}

S Person {
    name: str
    age: i64
    email: str
}

# 구조체 인스턴스 생성
p := Point { x: 10, y: 20 }

# 필드 접근
puts("{p.x}, {p.y}")

# 구조체 메서드 (impl 블록)
X Point {
    F distance_from_origin(&self) -> f64 {
        a := self.x as f64
        b := self.y as f64
        sqrt(a * a + b * b)
    }
}

# 메서드 호출
dist := p.distance_from_origin()

Enum (열거형)

# 간단한 Enum
E Color {
    Red,
    Green,
    Blue
}

# 데이터를 포함한 Enum
E Result<T> {
    Ok(T),
    Err(str)
}

# Enum 사용
color := Color.Red

M color {
    Color.Red => puts("Red color"),
    Color.Green => puts("Green color"),
    Color.Blue => puts("Blue color")
}

패턴 매칭

status := 200

# 기본 match
M status {
    200 => puts("OK"),
    404 => puts("Not Found"),
    500 => puts("Server Error"),
    _ => puts("Unknown status")
}

# Enum과 함께 사용
E Response {
    Success(str),
    Failure(str)
}

response := Response.Success("Done")

M response {
    Response.Success(msg) => puts("Success: {msg}"),
    Response.Failure(err) => puts("Error: {err}")
}

제네릭

# 제네릭 함수
F max<T>(a: T, b: T) -> T {
    I a > b { R a } E { R b }
}

# 제네릭 구조체
S Container<T> {
    value: T
}

X Container<T> {
    F get_value(&self) -> T = self.value
}

# 제네릭 사용
container := Container<i64> { value: 42 }
val := container.get_value()

Trait (특성)

# Trait 정의
W Drawable {
    F draw(&self) -> i64
}

# 구조체 정의
S Circle {
    radius: i64
}

# Trait 구현
X Circle: Drawable {
    F draw(&self) -> i64 {
        puts("Drawing circle with radius {self.radius}")
        0
    }
}

# Trait 메서드 호출
circle := Circle { radius: 5 }
circle.draw()

실제 예제

간단한 계산기

S Calculator {
    result: i64
}

X Calculator {
    F add(&self, n: i64) -> i64 = self.result + n
    F subtract(&self, n: i64) -> i64 = self.result - n
    F multiply(&self, n: i64) -> i64 = self.result * n
}

F main() -> i64 {
    ~ calc := Calculator { result: 0 }
    calc.result = calc.add(10)
    calc.result = calc.multiply(2)
    calc.result = calc.subtract(5)
    puts("Result: {calc.result}")
    0
}

문자열 처리

F count_chars(s: str) -> i64 {
    # 문자열 길이 계산
    ~ len := 0
    # (실제로는 s.len() 메서드 사용)
    len
}

F main() -> i64 {
    greeting := "Hello, Vais!"
    puts(greeting)

    # 문자열 보간
    name := "World"
    message := "Hello, {name}!"
    puts(message)

    0
}

배열 처리

F sum_array(arr: [i64; 5]) -> i64 {
    ~ result := 0
    L i := 0; i < 5; i = i + 1 {
        result = result + arr[i]
    }
    result
}

F main() -> i64 {
    numbers := [1, 2, 3, 4, 5]
    total := sum_array(numbers)
    puts("Sum: {total}")
    0
}

다음 단계