KingSejong 언어 레퍼런스

KingSejong 프로그래밍 언어의 완전한 문법 레퍼런스

버전: 1.0 최종 업데이트: 2025-11-10

---

목차

1. 기본 문법
2. 데이터 타입
3. 변수와 상수
4. 연산자
5. 제어 구조
6. 함수
7. 배열
8. 조사 표현식
9. 비동기 함수와 대기
10. 모듈 시스템
11. 내장 함수
12. 표준 라이브러리

---

기본 문법

주석

# 한 줄 주석
출력("안녕")  # 라인 끝 주석

문장 종결

문장은 개행(줄바꿈)으로 구분됩니다. 세미콜론은 필요 없습니다.

x = 10
y = 20
출력(x + y)

---

데이터 타입

KingSejong은 동적 타입 언어입니다.

1. 정수 (Integer)

나이 = 25
점수 = 100
음수 = -42

2. 실수 (Float)

파이 = 3.14
온도 = -5.5
가격 = 1000.0

3. 문자열 (String)

이름 = "홍길동"
메시지 = "안녕하세요"
빈문자열 = ""

문자열 연결:

인사 = "안녕" + "하세요"
출력("점수: " + 문자열(95))   # 점수: 95

4. 불리언 (Boolean)

참값 = 참
거짓값 = 거짓

조건(만약, 반복, 동안)에는 논리 값을 씁니다. 의미 분석기가 타입을 알 수 있는 식(리터럴, 길이() 같은 내장 함수의 결과)이 논리가 아니면 실행 전에 오류를 냅니다.

메모 = ""
만약 (길이(메모) == 0) {   # 만약 ("") 나 만약 (길이(메모)) 는 의미 분석 오류
    출력("비어 있음")
}

변수처럼 실행 전에 타입을 알 수 없는 값도 실행 중에 같은 규칙을 적용합니다. 조건 값이 참/거짓이 아니면 실행 오류(시도 로 잡을 수 있음)이며, 0 이나 "" 를 거짓으로 바꿔 주지 않습니다. 패턴 매칭의 when 가드도 같습니다.

개수 = 0
만약 (개수) { }        # 실행 오류: 조건은 참 또는 거짓이어야 합니다
만약 (개수 != 0) { }   # 이렇게 비교식으로 씁니다

!, 그리고, 또는 는 지금처럼 피연산자를 진리값으로 판별합니다(거짓, 0, 0.0, "", 없음 은 거짓, 그 외는 참).

5. 배열 (Array)

숫자들 = [1, 2, 3, 4, 5]
혼합 = [1, "문자열", 참, [1, 2]]
빈배열 = []

6. 함수 (Function)

더하기 = 함수(a, b) {
    반환 a + b
}

7. 없음 (Null)

값 = 없음

---

변수와 상수

변수 선언

타입을 명시하거나 생략할 수 있습니다:

# 타입 명시
정수 나이 = 25
실수 키 = 175.5
문자열 이름 = "홍길동"

# 타입 생략 (타입 추론)
점수 = 95
메시지 = "안녕"

변수 할당

x = 10
x = 20  # 재할당

---

연산자

산술 연산자

a = 10 + 5   # 덧셈: 15
b = 10 - 5   # 뺄셈: 5
c = 10 * 5   # 곱셈: 50
d = 10 / 5   # 나눗셈: 2
e = 10 % 3   # 나머지: 1
f = "=" * 10 # 문자열 반복: "=========="

정수는 64비트(-9223372036854775808 ~ 9223372036854775807)입니다. 결과가 이 범위를 넘으면 "정수 오버플로" 실행 오류가 나며 시도 로 잡을 수 있습니다. 해시처럼 넘쳐서 감싸 도는 계산이 필요하면 감싸더하기, 감싸빼기, 감싸곱하기 를 씁니다.

시도 {
    출력(9223372036854775807 + 1)
} 오류 (e) {
    출력("넘침")                              # 넘침
}
출력(감싸더하기(9223372036854775807, 1))     # -9223372036854775808

비교 연산자

x = 3
y = 5
x == y   # 같음
x != y   # 다름
x < y    # 작음
x > y    # 큼
x <= y   # 작거나 같음
x >= y   # 크거나 같음

== 는 값의 내용을 비교합니다.

• 정수와 실수는 수의 크기로 비교합니다: 1 == 1.0 은 참입니다.
• 배열과 딕셔너리는 요소를 차례로 비교합니다: [1, [2]] == [1, [2]] 은 참, [1, 2] == [2, 1] 은 거짓입니다.
• 함수와 클래스 인스턴스는 같은 객체일 때만 같습니다.
• 그 밖에 타입이 다르면 거짓입니다: 1 == "1" 은 거짓입니다.

논리 연산자

&&, ||, ! 외에 한국어 낱말 그리고, 또는 도 같은 뜻으로 쓸 수 있습니다.

나이 = 20
회원 = 참
만약 (나이 >= 18 그리고 회원 == 참) {
    출력("입장")
}

없음 (null) 과 배열 연산

없음 은 null 값입니다. 배열은 + 로 이어 붙이고, 배열[i] = 값 과 사전["키"] = 값 으로 요소를 바꿉니다.

값 = 없음
목록 = [1, 2] + [3]
목록[0] = 9

a = 참
b = 거짓
a && b   # 논리 AND
a || b   # 논리 OR
!a       # 논리 NOT

단항 연산자

x = 5
값 = 참
-x       # 부호 반전
!값      # 논리 부정

---

제어 구조

조건문 (만약)

점수 = 85
만약 (점수 >= 90) {
    출력("A 학점")
} 아니면 만약 (점수 >= 80) {
    출력("B 학점")
} 아니면 {
    출력("C 학점")
}

조건 반복 (반복 / 동안)

조건이 참인 동안 본문을 반복합니다. 무한 반복은 평가기의 안전 한도(평가 횟수·시간)에서 멈춥니다.

i = 0
반복 (i < 5) {
    출력(i)
    i = i + 1
}

# 동안 도 같은 뜻입니다
동안 (i > 0) {
    i = i - 1
}

N번 반복

# 리터럴 사용
10번 반복한다 {
    출력("반복")
}

# 변수 사용
횟수 = 5
횟수번 반복한다 {
    출력("실행")
}

범위 반복

# 1부터 10까지
i가 1부터 10까지 {
    출력(i)
}

# 0부터 5 미만
i가 0부터 5 미만 {
    출력(i)
}

# 1부터 10 이하 (까지와 같다)
i가 1부터 10 이하 {
    출력(i)
}

# 10부터 1 이상 (1씩 줄이며 거꾸로 센다. 시작이 끝보다 작으면 돌지 않는다)
i가 10부터 1 이상 {
    출력(i)
}

# 변수 사용
시작 = 1
끝 = 100
i가 시작부터 끝까지 {
    출력(i)
}

1부터 3까지 같은 범위 식은 배열 인덱스 안(배열[1부터 3까지])과 범위 반복문에서만 쓴다. r = 1부터 3까지 처럼 값으로 쓰면 실행 전에 의미 분석 오류가 난다.

반복문의 변수 범위

반복문은 회차마다 새 범위에서 본문을 돕니다. 반복 변수와 본문에서 처음 만든 변수는 그 회차에만 있고, 반복문이 끝나면 없습니다. 반복문 앞에 이미 있던 변수에 대입하면 그 변수가 바뀝니다.

합 = 0
i가 1부터 3까지 {
    두배 = i * 2      # 회차마다 새로 생긴다
    합 = 합 + 두배    # 바깥의 합이 바뀐다
}
출력(합)              # 12
# 출력(i), 출력(두배) 는 오류: 반복문 밖에서는 없다

그래서 본문에서 만든 함수는 그 회차의 값을 잡습니다.

함수들 = []
i가 1부터 3까지 {
    f = 함수() { 반환 i }
    함수들 = 추가(함수들, f)
}
출력(함수들[0](), 함수들[1](), 함수들[2]())   # 1 2 3

회차를 넘어 값을 이어 가려면 변수를 반복문 앞에 만듭니다.

반복 제어 (중단 / 계속)

중단 은 가장 안쪽 반복문을 끝내고, 계속 은 이번 회차의 나머지를 건너뛰고 다음 회차로 갑니다. 조건 반복, N번 반복, 범위 반복에서 모두 쓸 수 있습니다.

# 처음 찾은 위치에서 멈춘다
목록 = [5, 7, 9, 7]
위치 = -1
i가 0부터 길이(목록) 미만 {
    만약 (목록[i] == 7) {
        위치 = i
        중단
    }
}
출력(위치)   # 1

# 짝수는 건너뛴다
i가 1부터 5까지 {
    만약 (i % 2 == 0) { 계속 }
    출력(i)   # 1, 3, 5
}

• 중첩 반복에서는 가장 안쪽 반복문만 끝나거나 넘어갑니다.
• 시도 블록 안에서 써도 마지막 블록은 돕니다. 오류 블록은 돌지 않습니다(에러가 아닙니다).
• 함수 본문은 바깥 반복문을 보지 않습니다. 반복문 밖이나, 반복문 안에서 만든 함수 안에서 쓰면 실행 전에 의미 분석 오류가 납니다.
• 중단, 계속 은 키워드라 변수 이름으로 쓸 수 없습니다.
• 바이트코드 VM(--vm)은 마지막 블록 안의 중단/계속 을 아직 지원하지 않아 컴파일 오류를 냅니다. 평가기(기본)는 지원합니다.

---

함수

함수 정의

# 기본 형태
더하기 = 함수(a, b) {
    반환 a + b
}

# 매개변수 없음
인사 = 함수() {
    출력("안녕하세요")
}

# 반환값 없음
로그 = 함수(메시지) {
    출력("[LOG] " + 메시지)
}

함수 호출

더하기 = 함수(a, b) { 반환 a + b }
인사 = 함수() { 출력("안녕하세요") }

결과 = 더하기(10, 20)
출력(결과)  # 30

인사()  # "안녕하세요"

클로저

함수는 외부 변수를 캡처할 수 있습니다:

카운터_생성 = 함수() {
    개수 = 0
    반환 함수() {
        개수 = 개수 + 1
        반환 개수
    }
}

카운터 = 카운터_생성()
출력(카운터())  # 1
출력(카운터())  # 2
출력(카운터())  # 3

재귀 함수

팩토리얼 = 함수(n) {
    만약 (n <= 1) {
        반환 1
    }
    반환 n * 팩토리얼(n - 1)
}

출력(팩토리얼(5))  # 120

고차 함수

함수를 인자로 받거나 반환할 수 있습니다:

적용 = 함수(f, 값) {
    반환 f(값)
}

제곱 = 함수(x) { 반환 x * x }

출력(적용(제곱, 5))  # 25

---

배열

배열 생성

숫자들 = [1, 2, 3, 4, 5]
혼합 = [1, "문자", 참]
빈배열 = []

인덱싱

arr = [10, 20, 30, 40]
첫번째 = arr[0]     # 10
두번째 = arr[1]     # 20
넷째 = arr[3]       # 40

슬라이싱

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

# 범위 추출: 까지는 끝 인덱스를 포함하고, 미만은 포함하지 않는다
일부 = arr[2부터 5까지]    # [3, 4, 5, 6]
앞부분 = arr[0부터 3미만]  # [1, 2, 3]

배열 메서드 (조사 기반)

정렬한다

숫자들 = [3, 1, 4, 1, 5, 9]
정렬된 = 숫자들을 정렬한다
출력(정렬된)  # [1, 1, 3, 4, 5, 9]

역순으로_나열한다

원본 = [1, 2, 3, 4, 5]
역순 = 원본을 역순으로_나열한다
출력(역순)  # [5, 4, 3, 2, 1]

걸러낸다 (filter)

숫자들 = [1, 2, 3, 4, 5, 6]
짝수 = 숫자들을 걸러낸다(함수(x) {
    반환 x % 2 == 0
})
출력(짝수)  # [2, 4, 6]

변환한다 (map)

숫자들 = [1, 2, 3, 4, 5]
제곱들 = 숫자들을 변환한다(함수(x) {
    반환 x * x
})
출력(제곱들)  # [1, 4, 9, 16, 25]

축약한다 (reduce)

숫자들 = [1, 2, 3, 4, 5]
합계 = 숫자들을 축약한다(0, 함수(누적, 현재) {
    반환 누적 + 현재
})
출력(합계)  # 15

찾다 (find)

숫자들 = [3, 5, 7, 12, 15]
큰수 = 숫자들을 찾다(함수(x) {
    반환 x > 10
})
출력(큰수)  # 12

메서드 체이닝

조사 메서드의 결과에 바로 다음 조사를 붙여 이어 쓸 수 있다. 조사는 바로 앞 단계의 결과에 붙으므로 왼쪽부터 차례로 적용된다.

결과 = [1, 2, 3, 4, 5, 6]을 걸러낸다(함수(x) { 반환 x % 2 == 0 })을 변환한다(함수(x) { 반환 x * x })

출력(결과)  # [4, 16, 36]

정렬역순 = [3, 1, 2]를 정렬한다를 역순으로_나열한다
출력(정렬역순)  # [3, 2, 1]

소유격 의 도 같은 방식으로 이어진다: 사용자의 이름을 대문자로 변환한다 는 (사용자의 이름)을 대문자로 변환한다 로 읽힌다. 괄호로 묶는 형태도 그대로 쓸 수 있다.

---

조사 표현식

KingSejong의 핵심 차별화 기능입니다.

지원하는 조사

• 을/를 - 목적격
• 이/가 - 주격
• 은/는 - 보조사
• 의 - 소유격
• 로/으로 - 방향
• 에서 - 처소
• 에 - 위치

조사 표현식 값을 함수(인자) 는 함수(값, 인자) 로 평가됩니다. 사용자 정의 함수와 내장 함수 모두 이렇게 부를 수 있습니다 (문장을 길이 는 길이(문장)). 배열 전용 메서드(걸러낸다, 변환한다, 축약한다, 찾다, 정렬한다, 역순으로_나열한다)는 그 다음에 찾습니다. 의 는 클래스 인스턴스의 필드나 사전의 키를 읽습니다 (사용자의 이름).

조사는 바로 뒤의 동사 하나에만 붙습니다. x를 문자열로 변환한다 + "점" 은 (x를 문자열로 변환한다) + "점" 이고, 목록을 길이 == 3 은 길이(목록) == 3 입니다. 값을 문자열로 변환한다 꼴의 변환 관용구는 내장 함수 절의 문자열(값) 을 보세요.

받침 규칙

조사는 앞 명사의 받침에 따라 고릅니다. 실행기는 을/를, 이/가, 은/는, 로/으로를 같은 뜻으로 받아들이므로 틀린 조사도 실행되지만, 린터의 josa-agreement 규칙이 경고합니다 (kingsejong lint 파일.ksj).

있다 = 함수(목록) { 반환 길이(목록) > 0 }
크다 = 함수(값, 기준) { 반환 값 > 기준 }

# 받침 있음 → 을/이/은
목록 = [3, 1, 2]
출력(목록을 정렬한다)     # [1, 2, 3]
출력(목록이 있다)         # 참
값 = 10
출력(값은 크다(5))        # 참

# 받침 없음 → 를/가/는
데이터 = [9, 7, 8]
출력(데이터를 정렬한다)   # [7, 8, 9]
출력(데이터가 있다)       # 참
결과 = 3
출력(결과는 크다(5))      # 거짓

ㄹ받침 특수 규칙

로/으로 조사는 ㄹ받침 뒤에서 받침이 있어도 로 를 씁니다. 변환 관용구 값을 함수로 변환한다 로 확인할 수 있습니다:

묶음 = 함수(값) { 반환 [값] }

숫자 = "42"를 정수로 변환한다     # 받침 없음 → 로
출력(숫자 + 1)                   # 43
출력(숫자를 문자열로 변환한다)    # ㄹ받침 → 로: 42
출력(숫자를 묶음으로 변환한다)    # 받침(ㅁ) → 으로: [42]

---

비동기 함수와 대기

비동기 함수

비동기 함수 는 호출하면 바로 Promise 를 돌려주고, 본문의 결과(반환값 또는 던진 에러)로 그 Promise 가 끝난다.

덧셈 = 비동기 함수(a, b) {
    반환 a + b
}

p = 덧셈(10, 20)   # Promise

함수 이름() 처럼 이름을 붙여 선언할 수도 있다. 위의 대입 형태와 같다.

비동기 함수 곱셈(a, b) {
    반환 a * b
}

출력(타입(곱셈(2, 3)))   # 프로미스

대기

대기 는 Promise 가 끝날 때까지 기다려 값을 꺼낸다. Promise 가 아닌 값은 그대로 돌려준다.

덧셈 = 비동기 함수(a, b) {
    반환 a + b
}

합 = 대기 덧셈(10, 20)
출력(합)   # 30

거부된 Promise 를 기다리면 거부 이유가 던지다 처럼 던져진다. 시도 블록으로 잡을 수 있고, 비동기 함수 안이라면 그 함수의 Promise 가 같은 이유로 거부되며, 아무도 잡지 않으면 실행 에러로 끝난다.

실패 = 비동기 함수() {
    던지다 "연결 실패"
}

시도 {
    값 = 대기 실패()
} 오류 (e) {
    출력(e)   # Error: 연결 실패
}

그러면 / 오류시

대기 대신 콜백을 붙일 수도 있다. 그러면 은 이행 값을, 오류시 는 거부 이유를 받고, 둘 다 콜백 결과로 끝나는 새 Promise 를 돌려주므로 이어 쓸 수 있다.

덧셈 = 비동기 함수(a, b) {
    반환 a + b
}

결과 = 덧셈(1, 2).그러면(함수(값) {
    반환 값 * 10
}).오류시(함수(e) {
    반환 0
})
출력(대기 결과)   # 30

모듈 시스템

모듈 가져오기

가져오기 "stdlib/math"
가져오기 "stdlib/string"
가져오기 "stdlib/array"

사용자 정의 모듈

mymodule.ksj:

# 함수 정의
더하기 = 함수(a, b) {
    반환 a + b
}

곱하기 = 함수(a, b) {
    반환 a * b
}

상수 = 42

main.ksj:

가져오기 "mymodule"

출력(더하기(10, 20))  # 30
출력(곱하기(5, 6))    # 30
출력(상수)            # 42

모듈 경로 해석

• 상대 경로: 가져오기 "mymodule" → ./mymodule.ksj
• stdlib: 가져오기 "stdlib/math" → ./stdlib/math.ksj

---

내장 함수

출력(값)

값을 출력합니다:

출력("안녕하세요")
출력(42)
출력([1, 2, 3])

입력([프롬프트])

표준 입력에서 한 줄을 읽어 문자열로 반환합니다. 프롬프트를 주면 줄바꿈 없이 먼저 출력합니다. 줄 끝의 개행은 떼어내며, 더 읽을 입력이 없으면 없음을 반환합니다. 숫자가 필요하면 정수()/실수()로 변환합니다.

이름 = 입력("이름을 입력하세요: ")
출력("안녕하세요, " + 이름 + "님!")

나이 = 정수(입력("나이: "))

브라우저 플레이그라운드에는 표준 입력이 없어 입력()을 쓸 수 없습니다.

타입(값)

값의 타입을 문자열로 반환합니다:

출력(타입(42))        # "정수"
출력(타입(3.14))      # "실수"
출력(타입("안녕"))    # "문자열"
출력(타입(참))        # "논리"
출력(타입([1, 2]))    # "배열"
출력(타입({"a": 1}))  # "딕셔너리"

그 밖에 "없음", "함수", "내장함수", "클래스", "에러", "프로미스" 를 돌려줍니다.

길이(배열/문자열)

배열이나 문자열의 길이를 반환합니다:

출력(길이([1, 2, 3, 4, 5]))  # 5
출력(길이("안녕하세요"))      # 5

문자열(값), 정수(값), 실수(값)

타입을 바꿉니다. 문자열 은 어떤 값이든 출력될 모양 그대로의 문자열로 만듭니다.

출력("점수: " + 문자열(95))   # "점수: 95"
출력(정수("42") + 1)          # 43
출력(실수("2.5") * 2)         # 5.0

조사 관용구로도 쓸 수 있습니다: 값을 문자열로 변환한다 는 문자열(값) 이고, 로/으로 뒤에는 내장 함수뿐 아니라 직접 정의한 함수 이름도 올 수 있습니다 (21을 두배로 변환한다 는 두배(21)). 동사는 변환한다 또는 바꾼다 입니다.

부분문자열(문자열, 시작, [끝])

문자 단위(바이트가 아니라 글자)로 [시작, 끝) 구간을 잘라냅니다. 끝을 생략하면 끝까지입니다.

출력(부분문자열("안녕하세요", 1, 3))  # "녕하"
출력(부분문자열("안녕하세요", 3))     # "세요"

포함(컨테이너, 값)

문자열은 부분 문자열을, 배열은 요소를, 딕셔너리는 키를 찾습니다.

출력(포함("안녕하세요", "녕하"))  # 참
출력(포함([1, 2, 3], 2))         # 참
출력(포함({"a": 1}, "b"))        # 거짓

추가(배열, 값, ...)

값을 뒤에 붙인 새 배열을 돌려줍니다. 원본은 바뀌지 않습니다. 배열 + [값] 과 같습니다.

목록 = [1, 2]
목록 = 추가(목록, 3)      # [1, 2, 3]
목록 = 목록 + [4, 5]      # [1, 2, 3, 4, 5]

---

표준 라이브러리

가져오기 "stdlib/이름" 으로 쓰는 모듈은 14개다. 아래는 자주 쓰는 세 모듈의 요약이고, 전체 모듈과 함수, 내장 함수는 표준 라이브러리 레퍼런스에 있다.

math 모듈

수학 함수 라이브러리 (14개 함수, 상수 2개):

가져오기 "stdlib/math"

출력(절댓값(-10))           # 10
출력(거듭제곱(2, 10))       # 1024
출력(제곱근(16))            # 4
출력(계승(5))               # 120
출력(최대공약수(12, 18))    # 6
출력(소수인가(17))          # 참

주요 함수:

• 절댓값(x) - 절댓값
• 최댓값(a, b), 최솟값(a, b) - 두 수 비교
• 배열_최댓값(arr), 배열_최솟값(arr) - 배열 최댓/최솟값
• 합계(arr), 평균(arr) - 배열 통계
• 거듭제곱(밑, 지수) - 거듭제곱
• 계승(n) - 팩토리얼
• 최대공약수(a, b), 최소공배수(a, b) - GCD, LCM
• 제곱근(n) - 제곱근 (음수는 없음)
• 소수인가(n) - 소수 판별
• 제한(값, 최소, 최대) - Clamp

상수:

• 파이 - π ≈ 3.14159...
• 자연상수 - e ≈ 2.71828...

string 모듈

문자열 처리 라이브러리 (10개 함수):

가져오기 "stdlib/string"

출력(반복("*", 10))         # "**********"
출력(결합([1, 2, 3], ", "))  # "1, 2, 3"
출력(줄_만들기(20, "="))    # "===================="

주요 함수:

• 반복(문자열, 횟수) - 문자열 반복
• 결합(배열, 구분자) - 배열 → 문자열
• 비어있는가(문자열) - 빈 문자열 확인
• 같은가(문자열1, 문자열2) - 문자열 비교
• 역순(문자열) - 글자 단위로 뒤집기
• 왼쪽_채우기(문자열, 길이) - 왼쪽 패딩
• 오른쪽_채우기(문자열, 길이) - 오른쪽 패딩
• 문자로_채우기(문자, 길이) - 문자 반복
• 줄_만들기(길이, 문자) - 선 그리기
• 제목_형식(텍스트, 길이) - 제목 형식

array 모듈

배열 유틸리티 라이브러리 (15개 함수):

가져오기 "stdlib/array"

출력(범위(1, 10))           # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
출력(중복_제거([1, 2, 2, 3]))  # [1, 2, 3]
출력(쌍으로_묶기([1, 2], ["a", "b"]))  # [[1, a], [2, b]]

주요 함수:

• 범위(시작, 끝) - 범위 배열 생성
• 중복_제거(배열) - 중복 제거
• 채우기(값, 개수) - 특정 값으로 채우기
• 연결(배열1, 배열2) - 배열 연결
• 자르기(배열, 시작, 끝) - 슬라이싱
• 포함하는가(배열, 값) - 값 포함 여부
• 찾기(배열, 값) - 인덱스 찾기
• 모두(배열, 함수) - 모든 요소 확인 (every)
• 일부(배열, 함수) - 일부 요소 확인 (some)
• 그룹_나누기(배열, 크기) - 배열 그룹화 (chunk)
• 처음(배열, n), 마지막(배열, n) - 일부 추출
• 쌍으로_묶기(배열1, 배열2) - Zip

---

예제 코드

Hello World

출력("안녕, KingSejong!")

피보나치 수열

피보나치 = 함수(n) {
    만약 (n <= 1) {
        반환 n
    }
    반환 피보나치(n - 1) + 피보나치(n - 2)
}

i가 0부터 10까지 {
    출력(피보나치(i))
}

소수 찾기 (표준 라이브러리 활용)

가져오기 "stdlib/math"
가져오기 "stdlib/array"

# 1부터 50까지 소수 찾기
숫자들 = 범위(1, 50)
소수들 = 숫자들을 걸러낸다(소수인가)
출력(소수들)

배열 처리 파이프라인

# 짝수만 걸러내고 제곱한 뒤 합계
숫자들 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

짝수 = 숫자들을 걸러낸다(함수(x) { 반환 x % 2 == 0 })
제곱 = 짝수를 변환한다(함수(x) { 반환 x * x })
합계 = 제곱을 축약한다(0, 함수(누적, 현재) { 반환 누적 + 현재 })

출력(합계)  # 220

---

참고 자료

• 초보자용 튜토리얼
• 표준 라이브러리 가이드
• 예제 프로그램
• 프로젝트 README

---

KingSejong 언어 - 한글로 프로그래밍하는 즐거움 © 2025 KingSejong Team