토파즈 데이터 타입

토파즈는 강력한 정적 타입 시스템과 똑똑한 타입 추론을 결합하여 안전하면서도 간결한 코드 작성을 가능하게 합니다. 타입을 명시하지 않아도 컴파일러가 알아서 추론해주지만, 필요할 때는 명확하게 지정할 수 있습니다. 🎯

🔢 기본 타입 (Primitive Types)

정수와 실수

// 정수 타입
let 나이: int = 25
let 큰수: bigint = 9999999999999999999

// 실수 타입  
let 가격: float = 19.99
let 정밀도높은수: double = 3.141592653589793

// 타입 추론으로 간단하게
let 점수 = 95        // int로 추론
let 평균 = 87.5      // float로 추론

불리언 (Boolean)

let 활성화됨 = true
let 관리자권한 = false

// 조건문에서 사용
if 활성화됨 {
    print("서비스가 활성화되었습니다")
}

문자와 문자열

// 문자 (단일)
let 등급: char = 'A'
let 이모지: char = '🎉'

// 문자열
let 이름 = "김토파즈"
let 긴문장 = "코드가 시가 되는 언어, Topaz에 오신 것을 환영합니다!"

// 문자열 보간
let 인사말 = "안녕하세요, {이름}님! 오늘 날씨가 좋네요."
print(인사말)  // "안녕하세요, 김토파즈님! 오늘 날씨가 좋네요."

📊 컬렉션 타입 (Collection Types)

배열 (Array)

// 배열 선언과 초기화
let 숫자들: [int] = [1, 2, 3, 4, 5]
let 이름들 = ["김철수", "이영희", "박민수"]  // [string]으로 추론

// 배열 조작
let 첫번째 = 숫자들[0]           // 1
숫자들.push(6)                   // [1, 2, 3, 4, 5, 6]
let 길이 = 숫자들.length()       // 6

// 함수형 스타일 연산
let 제곱들 = 숫자들.map(x => x * x)
let 짝수들 = 숫자들.filter(x => x % 2 == 0)

객체 (Object)

// 객체 정의
let 사용자 = {
    이름: "김토파즈",
    나이: 28,
    이메일: "topaz@example.com",
    활성화됨: true
}

// 프로퍼티 접근
print(사용자.이름)               // "김토파즈"
사용자.나이 = 29                 // 값 변경

// 메서드가 있는 객체
let 계산기 = {
    값: 0,
    더하기: function(x: int) -> int {
        this.값 += x
        return this.값
    },
    곱하기: function(x: int) -> int {
        this.값 *= x
        return this.값
    }
}

계산기.더하기(10).곱하기(2)      // 메서드 체이닝

🏗️ 고급 타입 (Advanced Types)

옵션 타입 (Option)

// null 안전성을 위한 Option 타입
let 검색결과: Option<string> = None
let 사용자이름: Option<string> = Some("admin")

// 패턴 매칭으로 안전하게 처리
match 사용자이름 {
    case Some(이름) => print("환영합니다, {이름}님!")
    case None => print("로그인이 필요합니다")
}

// ?. 와 ?? 를 조합한 안전한 처리
let 길이 = 사용자이름?.length ?? 0

결과 타입 (Result)

// 에러 처리를 위한 Result 타입
function 파일읽기(경로: string) -> Result<string, Error> {
    if 파일존재함(경로) {
        Ok(파일내용읽기(경로))
    } else {
        Err(Err("파일을 찾을 수 없습니다"))
    }
}

// 안전한 에러 처리
match 파일읽기("data.txt") {
    case Ok(내용) => print("파일 내용: {내용}")
    case Err(에러) => print("에러 발생: {에러.message}")
}

유니온 타입 (Union Types)

// 여러 타입 중 하나를 가질 수 있는 타입
type ID = int | string
type 상태 = "대기중" | "진행중" | "완료" | "실패"

let 사용자ID: ID = 12345
let 작업상태: 상태 = "진행중"

// 패턴 매칭으로 타입별 처리
function ID표시(id: ID) -> string {
    match id {
        case int => "숫자 ID: {id}"
        case string => "문자 ID: {id}"
    }
}

🧬 제네릭 타입 (Generic Types)

제네릭 함수

// 타입 매개변수를 사용한 제네릭 함수
function 배열생성<T>(값: T, 개수: int) -> [T] {
    let 결과: [T] = []
    for i in 0..개수 {
        결과.push(값)
    }
    return 결과
}

let 숫자배열 = 배열생성(42, 5)      // [42, 42, 42, 42, 42]
let 문자배열 = 배열생성("안녕", 3)   // ["안녕", "안녕", "안녕"]

제네릭 구조체

// 제네릭 구조체 정의
struct 컨테이너<T> {
    값: T,
    
    function 새값설정(새값: T) {
        this.값 = 새값
    }
    
    function 값가져오기() -> T {
        return this.값
    }
}

let 숫자컨테이너 = 컨테이너 { 값: 100 }
let 문자컨테이너 = 컨테이너 { 값: "Hello" }

🎨 타입 별칭 (Type Aliases)

// 복잡한 타입에 간단한 이름 부여
type 사용자정보 = {
    이름: string,
    나이: int,
    이메일: string,
    권한들: [string]
}

type 콜백함수 = function(데이터: string) -> void
type 상태변경자<T> = function(이전상태: T) -> T

// 사용 예시
let 관리자: 사용자정보 = {
    이름: "김관리자",
    나이: 35,
    이메일: "admin@topaz.ooo",
    권한들: ["읽기", "쓰기", "삭제"]
}

🔄 타입 변환 (Type Conversion)

// 명시적 타입 변환
let 문자숫자 = "123"
let 숫자 = int(문자숫자)         // 123
let 실수 = float(숫자)           // 123.0
let 다시문자 = string(실수)      // "123.0"

// 안전한 타입 변환
let 결과 = tryInt("abc")         // Option<int>
match 결과 {
    case Some(값) => print("변환 성공: {값}")
    case None => print("변환 실패")
}

// 타입 검사
let 값: any = "Hello"
if 값 is string {
    print("문자열입니다: {값 as string}")
}

✨ 고급 패턴

구조 분해 할당

// 배열 구조 분해
let [첫번째, 두번째, ...나머지] = [1, 2, 3, 4, 5]
print(첫번째)    // 1
print(나머지)    // [3, 4, 5]

// 객체 구조 분해
let { 이름, 나이 } = 사용자
print("이름: {이름}, 나이: {나이}")

// 함수 매개변수에서 구조 분해
function 인사하기({ 이름, 나이 }: { 이름: string, 나이: int }) {
    print("안녕하세요, {이름}님! {나이}세이시군요.")
}

타입 가드

// 사용자 정의 타입 가드
function 문자열인가(값: any): 값 is string {
    match 값 {
        case _: string => true
        case _ => false
    }
}

function 안전한처리(값: any) {
    if 문자열인가(값) {
        // 여기서 값은 string 타입으로 처리됨
        print(값.toUpperCase())
    }
}

🚀 실전 활용

// 실제 프로젝트에서 사용할 만한 타입 정의
type API응답<T> = {
    성공: boolean,
    데이터: Option<T>,
    에러: Option<string>,
    상태코드: int
}

type 사용자 = {
    id: int,
    이름: string,
    이메일: string,
    생성일시: Date
}

// API 함수 정의 (자동 비동기; 수동 대기 불필요)
function 사용자가져오기(id: int) -> API응답<사용자> {
    let 응답 = fetch("/api/users/{id}")
    
    if 응답.ok {
        let 사용자데이터 = 응답.json()
        return {
            성공: true,
            데이터: Some(사용자데이터),
            에러: None,
            상태코드: 응답.status
        }
    } else {
        return {
            성공: false,
            데이터: None,
            에러: Some("사용자를 찾을 수 없습니다"),
            상태코드: 응답.status
        }
    }
}

토파즈의 타입 시스템은 안전성과 표현력을 모두 제공합니다. 타입 추론 덕분에 간결하게 코드를 작성할 수 있으면서도, 필요할 때는 정확한 타입 지정으로 버그를 사전에 방지할 수 있습니다. 🎯