Seil 언어

Seil은 인터프리터와 컴파일러를 지원하는 현대적인 프로그래밍 언어입니다. C#으로 변환하거나 직접 실행 파일(EXE)로 빌드할 수 있습니다.

주요 특징

• 인터프리터 지원: 즉시 실행 및 REPL 모드
• C# 컴파일: C#으로 변환 가능 (계획)
• 원클릭 EXE 빌드: Seil 파일을 직접 실행 파일로 컴파일 (계획)
• Native AOT 지원: .NET 런타임 없이 실행되는 네이티브 바이너리 생성
• Trait 시스템: 현대적인 타입 시스템과 다중 상속 지원
• 고성능: Span를 활용한 메모리 최적화
• 다중 타입 컬렉션: 배열과 딕셔너리에서 여러 타입 혼합 지원
• 강력한 패턴 매칭: 범위 패턴을 포함한 match 표현식
• while 루프: 조건 기반 반복문 지원
• 조건부 표현식: 문자열 연결 등에서 사용 가능한 인라인 조건문 (여러 줄 지원)
• 향상된 for-in 순회: 배열, 사전, 문자열을 직관적으로 순회
• 사용자 입력 지원: 다양한 타입의 입력 함수 제공
• 슬라이싱: Python 스타일 배열/문자열 슬라이싱

빠른 시작

Hello World

print("안녕하세요, Seil 월드!")

func greet(name: string) -> string {
    return "Hello, " + name + "!"
}

print(greet("Seil"))

기본 타입과 변수

// 타입 추론
let name = "Seil"
let age = 25
let pi = 3.14159
let isActive = true

// 명시적 타입 지정
let message: string = "안녕하세요!"
let year: int = 2024
let temperature: float = 36.5
let isFinished: bool = false

// 변수 할당 (let으로 먼저 선언되어야 함)
let count = 10
count = 20  // 할당 가능

사용자 입력

// 기본 문자열 입력
let name = input("이름을 입력하세요: ")
print("안녕하세요, " + name + "님!")

// 타입별 입력 (자동 검증)
let age = input_int("나이: ")
let height = input_float("키 (cm): ")
let agree = input_bool("동의하시나요? (y/n): ")

// 선택지 입력
let options = ["옵션1", "옵션2", "옵션3"]
let choice = input_choice(options, "선택하세요:")

// 비밀번호 입력 (마스킹)
let password = input_password("비밀번호: ")

// 여러 줄 입력
let lines = input_multiline("여러 줄을 입력하세요:", "END")

// 문자열 파싱
let num = parse_int("123")
let decimal = parse_float("3.14")
let flag = parse_bool("true")

다중 타입 컬렉션

// 다중 타입 배열
let mixedArray = [1, "hello", true, 3.14]
print(mixedArray[0])  // 1
print(mixedArray[1])  // "hello"

// 다중 타입 딕셔너리
let userData = {
    "name": "김철수",
    "age": 30,
    "scores": [85, 90, 78],
    "isActive": true,
    "metadata": {"created": "2024-01-01"}
}
print("이름: " + userData["name"])
print("첫 번째 점수: " + userData["scores"][0])

향상된 순회 (for-in)

// 배열 순회
let fruits = ["apple", "banana", "cherry"]
for fruit in fruits {
    print("- " + fruit)
}

// 사전 순회 (키-값 쌍)
let scores = {"수학": 85, "영어": 92}
for pair in scores {
    print(pair[0] + ": " + pair[1])
}

// 문자열 순회
for char in "Hello" {
    print(char)
}

// range 함수 활용
for i in range(5) {           // 0, 1, 2, 3, 4
    print(i)
}

for i in range(2, 8) {        // 2, 3, 4, 5, 6, 7
    print(i)
}

for i in range(0, 10, 2) {    // 0, 2, 4, 6, 8
    print(i)
}

// enumerate 활용 (인덱스와 값)
for item in enumerate(fruits) {
    print(item[0] + ": " + item[1])  // 0: apple, 1: banana, ...
}

// 사전 키/값만 순회
for key in keys_only(scores) {
    print("키: " + key)
}

for value in values_only(scores) {
    print("값: " + value)
}

슬라이싱 (Python 스타일)

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// 기본 슬라이싱
let slice1 = numbers[2:5]    // [3, 4, 5]
let slice2 = numbers[:3]     // [1, 2, 3]
let slice3 = numbers[7:]     // [8, 9, 10]

// 음수 인덱스 지원
let lastTwo = numbers[-2:]   // [9, 10]
let withoutLast = numbers[:-1] // [1, 2, 3, 4, 5, 6, 7, 8, 9]

// 문자열 슬라이싱
let text = "Hello, World!"
let hello = text[:5]         // "Hello"
let world = text[7:]         // "World!"

함수와 조건문

func getGrade(score: int) -> string {
    match score {
        90..101 -> "A"
        80..90 -> "B"
        70..80 -> "C"
        60..70 -> "D"
        _ -> "F"
    }
}

print("등급: " + getGrade(85))

// 복잡한 조건문
let age = 25
let hasLicense = true

if age >= 18 and hasLicense {
    print("운전 가능")
} else if age >= 16 {
    print("보호자 동승 시 운전 가능")
} else {
    print("운전 불가")
}

반복문

for 루프

for i in 1..6 {
    print("숫자: " + i)
}

while 루프

let i = 1
while i <= 5 {
    print("카운트: " + i)
    i = i + 1
}

// while로 팩토리얼 계산
func factorial(n: int) -> int {
    let result = 1
    let counter = 1
    while counter <= n {
        result = result * counter
        counter = counter + 1
    }
    return result
}

print("5! = " + factorial(5))

패턴 매칭

기본 패턴 매칭

func getDayName(day: int) -> string {
    match day {
        1 -> "월요일"
        2 -> "화요일"
        3 -> "수요일"
        _ -> "기타"
    }
}

범위 패턴 매칭

func classifyTemperature(temp: int) -> string {
    match temp {
        -50..0 -> "빙점 이하"
        0..10 -> "추움"
        10..20 -> "서늘함"
        20..30 -> "적당함"
        30..40 -> "더움"
        _ -> "극한 온도"
    }
}

func getAgeGroup(age: int) -> string {
    match age {
        0..13 -> "어린이"
        13..20 -> "청소년"
        20..65 -> "성인"
        65..120 -> "노인"
        _ -> "유효하지 않음"
    }
}

조건부 표현식

// 기본 조건부 표현식
let number = 42
let status = if number % 2 == 0 { "짝수" } else { "홀수" }

// 문자열 연결 내 조건부 표현식
let message = "숫자 " + number + "는 " + if number % 2 == 0 { "짝수" } else { "홀수" } + "입니다."

// 중첩 조건부 표현식
let temperature = 25
let weather = "현재 온도는 " + temperature + "도이며, " + 
              if temperature > 30 { "덥습니다" } 
              else if temperature > 20 { "적당합니다" } 
              else { "춥습니다" } + "."

// 여러 줄에 걸친 복잡한 조건부 표현식 (문자열 연결 지원)
let username = "김철수"
let age = 25
let hasSubscription = true

let detailedReport = "사용자 " + username + "님은 " +
                    if age >= 65 { "노인" }
                    else if age >= 18 { "성인" }
                    else { "미성년자" } + "이며, " +
                    if hasSubscription { "프리미엄 회원" }
                    else { "일반 회원" } + "입니다."

Trait 시스템

trait Display {
    func display() -> string;
}

struct User implements Display {
    let name: string;
    let age: int;
    
    func display() -> string {
        return name + " (" + age + "세)"
    }
}

let user = User("김철수", 30)
print(user.display())

내장 함수

출력 함수

• print(value...) - 값 출력

입력 함수

• input([prompt]) - 문자열 입력
• input_int([prompt]) - 정수 입력 (자동 검증)
• input_float([prompt]) - 실수 입력 (자동 검증)
• input_bool([prompt]) - Boolean 입력 (y/n, yes/no, true/false)
• input_choice(choices, [prompt]) - 선택지 입력
• input_password([prompt]) - 비밀번호 입력 (마스킹)
• input_multiline([prompt], [end_keyword]) - 여러 줄 입력

타입 변환 함수

• parse_int(str) - 문자열을 정수로 변환
• parse_float(str) - 문자열을 실수로 변환
• parse_bool(str) - 문자열을 Boolean으로 변환

컬렉션 함수

• len(collection) - 길이 반환
• push(array, value) - 배열에 추가
• pop(array) - 배열에서 제거
• keys(dict) - 사전의 키들
• values(dict) - 사전의 값들
• has_key(dict, key) - 키 존재 확인
• remove(dict, key) - 키 제거

순회 함수

• range(end) - 0부터 end-1까지
• range(start, end) - start부터 end-1까지
• range(start, end, step) - step 간격으로
• enumerate(array, [start]) - 인덱스와 값 쌍
• keys_only(dict) - 사전 키만
• values_only(dict) - 사전 값만
• repeat(value, count) - 반복 배열 생성

수학 함수

• min(a, b) - 최솟값
• max(a, b) - 최댓값
• abs(num) - 절댓값
• random() - 0.0~1.0 난수
• random_int(min, max) - 정수 난수

생성 함수

• array() - 빈 배열 생성
• dict() - 빈 사전 생성

사용법

REPL 모드

SeilLang

파일 실행 (인터프리터)

SeilLang run example.seil

개발 도구

# AST 구조 확인
SeilLang ast example.seil

# 토큰 분석
SeilLang tokens example.seil

# 도움말
SeilLang help

샘플 코드 모음

프로젝트의 samples/ 디렉토리에서 다양한 예제를 확인할 수 있습니다:

기본 기능 예제

• 01_hello_world.seil - 기본 Hello World 예제
• 02_basic_types.seil - 기본 타입과 변수 사용법
• 03_variables_assignment.seil - 변수 선언과 할당
• 04_arithmetic_operations.seil - 산술 연산
• 05_functions_basic.seil - 함수 정의와 호출

제어 구조와 조건문

• 06_conditionals_basic.seil - 기본 조건문 (if/else/else if)
• 07_conditional_expressions.seil - 조건부 표현식 (여러 줄 지원)
• 08_loops_basic.seil - 기본 반복문 (for/while)

데이터 구조

• 09_arrays_basic.seil - 배열 기본 사용법
• 10_dictionaries_basic.seil - 딕셔너리 기본 사용법 (다중 타입 지원)
• 11_arrays_advanced.seil - 배열 고급 기능 (슬라이싱 포함)
• 19_complex_collections.seil - 복합 데이터 구조 활용

패턴 매칭과 함수

• 12_pattern_matching.seil - 패턴 매칭 (범위 패턴 포함)
• 14_functions_advanced.seil - 고급 함수 활용

사용자 상호작용

• 13_user_input.seil - 다양한 사용자 입력 함수들
• 16_calculator_app.seil - 계산기 애플리케이션
• 17_number_guessing_game.seil - 숫자 맞추기 게임

Trait 시스템

• 15_traits_basic.seil - 기본 Trait 시스템 사용법

복합 예제

• 18_data_analysis.seil - 데이터 분석 예제
• 20_advanced_programming.seil - 고급 프로그래밍 기법 종합

주요 예제 코드

대화형 프로그램 (13_user_input.seil)

// 간단한 설문조사 프로그램
print("=== 사용자 설문조사 ===")

let name = input("이름: ")
let age = input_int("나이: ")
let programming = input_bool("프로그래밍 경험이 있나요? (y/n): ")

let languages = ["Python", "JavaScript", "C#", "Java", "기타"]
let favorite = input_choice(languages, "선호하는 언어:")

print("=== 설문 결과 ===")
print("이름: " + name)
print("나이: " + age + "세")
print("프로그래밍 경험: " + if programming { "있음" } else { "없음" })
print("선호 언어: " + favorite)

피보나치 수열 (while 루프 활용)

print("피보나치 수열 (처음 10개):")
let a = 0
let b = 1
let count = 0

print("피보나치: " + a)
print("피보나치: " + b)

while count < 8 {
    let next = a + b
    print("피보나치: " + next)
    a = b
    b = next
    count = count + 1
}

복합 데이터 구조 활용 (19_complex_collections.seil)

let classRooms = {
    "1반": [85, 92, 78, 88, 95],
    "2반": [90, 87, 82, 91, 89]
}

func calculateAverage(scores: array) -> float {
    let sum = 0
    for score in scores {
        sum = sum + score
    }
    return sum / len(scores)
}

for className in keys_only(classRooms) {
    let scores = classRooms[className]
    let average = calculateAverage(scores)
    print(className + " 평균: " + average)
}

슬라이싱 활용 (11_arrays_advanced.seil)

let data = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

print("전체 데이터: " + data)
print("처음 3개: " + data[:3])
print("마지막 3개: " + data[-3:])
print("중간 부분: " + data[3:7])

// 문자열 처리
let message = "Hello, Seil Programming Language!"
print("인사말: " + message[:5])      // "Hello"
print("언어명: " + message[7:11])    // "Seil"
print("마지막 단어: " + message[-9:]) // "Language!"

조건부 표현식 고급 활용 (07_conditional_expressions.seil)

let products = [
    {"name": "노트북", "price": 1500000, "stock": 5},
    {"name": "마우스", "price": 50000, "stock": 0},
    {"name": "키보드", "price": 150000, "stock": 10}
]

for i in range(len(products)) {
    let product = products[i]
    let status = if product["stock"] > 0 { "재고 있음" } else { "품절" }
    let priceLevel = if product["price"] > 1000000 { "고가" } 
                     else if product["price"] > 100000 { "중가" } 
                     else { "저가" }
    
    // 여러 줄에 걸친 문자열 연결에서 조건부 표현식 사용
    let description = product["name"] + ": " + status + " (" + priceLevel + " 제품, " + 
                     product["price"] + "원) - " +
                     if product["stock"] > 10 { "충분한 재고" }
                     else if product["stock"] > 0 { "제한된 재고" }
                     else { "재고 부족" }
    
    print(description)
}

숫자 맞추기 게임 (17_number_guessing_game.seil)

print("=== 숫자 맞추기 게임 ===")
print("1부터 100 사이의 숫자를 맞춰보세요!")

let answer = random_int(1, 100)
let attempts = 0
let maxAttempts = 7

while attempts < maxAttempts {
    let guess = input_int("숫자를 입력하세요 (남은 기회: " + (maxAttempts - attempts) + "): ")
    attempts = attempts + 1
    
    if guess == answer {
        print("🎉 정답입니다! " + attempts + "번 만에 맞추셨네요!")
        break
    } else if guess < answer {
        print("⬆️ 더 큰 숫자입니다!")
    } else {
        print("⬇️ 더 작은 숫자입니다!")
    }
    
    if attempts == maxAttempts {
        print("😢 게임 오버! 정답은 " + answer + "이었습니다.")
    }
}

아키텍처

핵심 컴포넌트

1. 렉서 (Lexer): 소스 코드를 토큰으로 분해
2. 파서 (Parser): 토큰을 AST로 변환 (여러 줄 표현식 지원)
3. Trait 시스템: 타입 시스템과 다중 상속 지원
4. 인터프리터: AST를 직접 실행
5. 내장 함수 시스템: 다양한 타입의 사용자 입력 및 유틸리티 함수

메모리 최적화

• Span<T> 및 ReadOnlySpan<T> 적극 활용
• 구조체 기반 토큰 시스템
• 객체 풀링으로 GC 압박 최소화
• Native AOT 호환 설계

테스트 현황

통과한 테스트 ✅ (343개)

• 렉서 테스트: 토큰화 및 어휘 분석
• 파서 테스트: AST 생성 및 구문 분석
• 인터프리터 테스트: 기본 실행 엔진
• 타입 시스템 테스트: 기본 타입 및 타입 추론
• 제어 구조 테스트: 조건문, 반복문, 패턴 매칭
• 함수 시스템 테스트: 함수 정의, 호출, 재귀
• 컬렉션 테스트: 배열, 딕셔너리, 슬라이싱
• Trait 시스템 테스트: Trait 정의 및 구현
• 내장 함수 테스트: 입출력, 타입 변환, 수학 함수
• 통합 테스트: 기본 샘플 실행

개선 필요한 부분 🔧 (11개 실패)

• 고급 샘플 실행: 일부 복잡한 샘플의 실행 안정성
• 장시간 실행 프로그램: 사용자 입력이 포함된 대화형 프로그램 처리
• EXE 컴파일 테스트: 실행 파일 생성 기능

개발 상태

완료된 기능 ✅

• 렉서 (토큰화) - 고성능 Span 기반
• 파서 (AST 생성) - 여러 줄 표현식 지원
• 기본 타입 시스템 (int, float, string, bool)
• 변수 선언 및 할당
• 함수 정의 및 호출 (재귀 포함)
• 조건문 (if/else/else if) - 복잡한 중첩 지원
• 반복문 (for/while) - 범위 기반 및 컬렉션 순회
• 패턴 매칭 (match) - 범위 패턴 포함
• 조건부 표현식 - 문자열 연결 및 여러 줄 지원
• Trait 시스템 - 정의, 구현, 상속
• 구조체 (struct) - 메서드 및 Trait 구현
• 배열 (array) - 다중 타입 지원 및 슬라이싱
• 딕셔너리 (dict) - 다중 타입 지원 및 중첩 구조
• 인덱스 접근 및 슬라이싱 (Python 스타일, 음수 인덱스 포함)
• 향상된 for-in 순회 (배열, 사전, 문자열)
• 사용자 입력 시스템 (타입별 검증, 선택지, 비밀번호 등)
• 내장 함수 (print, len, push, pop, keys, values, range, enumerate, min, max, abs, random 등)
• 인터프리터 실행 엔진 - 최적화된 성능
• REPL 모드 - 대화형 실행 환경
• 포괄적인 단위 테스트 (343개 통과)
• 20개 샘플 코드 및 문서화

개선 중인 기능 🚧

• EXE 컴파일러 안정성 향상
• 장시간 실행 프로그램 최적화
• 대화형 프로그램 처리 개선

계획된 기능 🚀

• 모듈 시스템 및 import 문
• 표준 라이브러리 확장
• 제네릭 타입 시스템
• 에러 처리 (try/catch/Result 타입)
• 클로저 및 람다 표현식
• 매크로 시스템
• 문자열 보간법 확장
• C# 코드 생성기 완성
• 패키지 관리 시스템
• 디버거 지원
• IDE 플러그인

문서

• SPEC.md - Seil 언어 상세 사양서 (최신 업데이트)
• samples/ - 20개 예제 코드 모음 (기본~고급)
• tests/ - 350개 이상의 단위 테스트 및 통합 테스트

기술 스택

• .NET 10: 최신 .NET 플랫폼
• C# 13.0: 최신 C# 언어 기능 (record, pattern matching 등)
• Native AOT: 네이티브 컴파일 지원
• Span: 고성능 메모리 관리
• XUnit: 단위 테스트 프레임워크
• 현대적 아키텍처: 인터페이스 기반 설계, partial 클래스 분리

성능 특징

• 빠른 파싱: 단일 패스 파서로 빠른 구문 분석
• 효율적인 인터프리터: 최적화된 AST 순회
• 메모리 효율성: Span 활용으로 최소한의 힙 할당
• 확장성: 대용량 파일 처리 가능
• Native AOT 호환: 런타임 의존성 없는 네이티브 바이너리

빌드 및 개발

요구사항

• .NET 10 SDK
• C# 13.0 컴파일러

빌드

dotnet build

테스트

dotnet test
# 현재 343개 테스트 통과, 11개 개선 중

실행

# REPL 모드
dotnet run --project SeilLang

# 파일 실행
dotnet run --project SeilLang run example.seil

# AST 확인
dotnet run --project SeilLang ast example.seil

# 토큰 분석
dotnet run --project SeilLang tokens example.seil

샘플 실행

# 기본 예제
dotnet run --project SeilLang run samples/01_hello_world.seil

# 사용자 입력 예제
dotnet run --project SeilLang run samples/13_user_input.seil

# 계산기 앱
dotnet run --project SeilLang run samples/16_calculator_app.seil

# 숫자 맞추기 게임
dotnet run --project SeilLang run samples/17_number_guessing_game.seil

라이선스

MIT License

기여하기

1. Fork the repository
2. Create a feature branch
3. Commit your changes
4. Push to the branch
5. Create a Pull Request

기여 가이드라인

• 테스트 우선: 새 기능은 테스트와 함께 개발
• 문서 갱신: SPEC.md와 README.md 업데이트
• 샘플 코드: 새 기능은 samples/ 디렉토리에 예제 추가
• 성능 고려: Span 활용 및 메모리 효율성 고려
• Native AOT 호환: 리플렉션 사용 금지

---

Seil 언어는 현대적이고 실용적인 프로그래밍 언어로, 학습하기 쉽고 강력한 기능을 제공합니다. 지속적인 개발과 개선을 통해 더욱 완성도 높은 언어로 발전시켜 나가겠습니다.