Typst에서 타이핑을 시작하는 것은 쉽습니다.
대부분의 경우 패키지나 다른 복잡한 설정이 필요하지 않습니다.

빈 줄은 텍스트를 새로운 단락으로 이동시킵니다.

참고로, 글꼴이 지원하는 한 모든 언어와 유니코드 기호를
문제없이 사용할 수 있습니다: ßçœ̃ɛ̃ø∀αβёыა😆…

= 마크업

이것은 제목(heading)이었습니다. 이름 앞의 `=` 개수는 제목 수준에 해당합니다.

== 2단계 제목

이제 _강조(emphasis)_와 *굵게(bold)* 표시된 텍스트로 넘어가 보겠습니다.

마크업 구문은 일반적으로
`AsciiDoc`과 비슷합니다 (이것은 고정 폭 텍스트를 위한 `raw`였습니다!)

"\\" 기호를 사용하여 \
어디서든 줄을 \
바꿀 수 있습니다.

또한 마크업이나 다른 특수 기호로
해석되지 않기를 원하는 경우,
해당 기호를 이스케이프(\_기호 앞뒤에 언더스코어\_ 등)하는 데
이 기호를 사용할 수 있습니다.

`//`와 `/* 주석 */`를 사용하여 주석을 작성할 수 있습니다:
// 이와 같이
/* 또는 이와
같은 방식으로 */

```typ
혹시 소스를 읽지 않으셨을까 봐,
작성 방식은 다음과 같습니다:

// 이와 같이
/* 또는 이와
같은 방식으로 */

참고로, 저는 이 모든 것을 *구문 강조*가 적용된 _코드 블록(fenced code block)_으로 작성하고 있습니다!
```

== 그 외에 또 무엇이 있나요?

기본 "마크업" 구문에는 많은 것이 없지만,
곧 훨씬 더 흥미로운 것들을 보게 될 것입니다!
여기서 자동으로 짝이 맞춰지는 "스마트 따옴표"를 확인하셨기를 바랍니다.

- 목록을 간단하게 작성하는 것은 아주 좋습니다.
- 복잡할 것 없이, `-`로 항목을 시작하면
  목록이 됩니다.
  - 들여쓰기를 통해 하위 목록을 만듭니다.

+ 번호가 매겨진 목록은 `-` 대신 `+`로 시작합니다.
+ 목록을 위한 다른 대안 마크업 구문은 없습니다.
+ 그러니 `-`와 `+`만 기억하세요. 다른 기호들은
  의도치 않은 방식으로 작동하지 않을 것입니다.
  + 이것이 Typst 마크업의 일반적인 특징입니다.
  + 마크다운과 달리, 무언가를 작성하는 방법은
    오직 한 가지뿐입니다.

Typst의 번호 매겨진 목록은 마크다운 스타일의 목록 구문과 다릅니다. 손으로 직접 숫자를 써도 번호가 유지됩니다:

1. 사과
1. 오렌지
1. 복숭아

수식($a + b/c = sum_i x^i$)이
가능하며 꽤 예쁘게 표현된다는 점만 언급하겠습니다:

$
7.32 beta +
  sum_(i=0)^nabla
    (Q_i (a_i - epsilon)) / 2
$

수식에 대해 더 자세히 알아보려면 해당 장을 참조하세요.

이제 좀 더 복잡한 내용으로 넘어가 보겠습니다.

Typst 마법의 주요 부분은 스크립팅입니다.
스크립팅 모드로 들어가려면 `#`을 입력하고 그 뒤에 *함수 이름*을
입력하세요. _지루한 것_부터 시작해 보겠습니다:

#lorem(50)

_이 *함수* 는 방금 50개의 "Lorem Ipsum" 단어를 생성했습니다!_

#underline[함수는 무엇이든 할 수 있습니다!]

#text(orange)[정]말 #text(size: 0.8em)[모든] #sub[것]을요!

#figure(
  caption: [
    이것은 Typst로 작성된 초기 논문 중 하나의 스크린샷입니다. \
    _이 모든 것들도 #text(blue)[사용자 정의 함수]로 작성되었습니다._
  ],
  image("../boxes.png", width: 80%)
)

사실, 여러분은 마크업을 #strong[잊어버리고]
모든 곳에 함수만 #emph[사용해서 작성]할 수도 있습니다!

#list[
  그 모든 마크업은 사실 함수 위에 씌워진 #emph[구문 설탕(syntax sugar)]일 뿐입니다!
]

먼저 `#`으로 시작합니다. 그런 다음 이름을 씁니다.
마지막으로 괄호를 쓰고 그 안에 무언가를 넣을 수 있습니다.

#link("https://typst.app/docs/reference/")[공식 참조 문서]에서
수많은 내장 함수를 찾아볼 수 있습니다.

#quote(block: true, attribution: "Typst 예시 북")[
  맞습니다, 링크, 인용 및 기타 수많은
  문서 요소들이 함수로 생성됩니다.
]

함수 인수에는 _두 가지 유형_이 있습니다:

+ *위치 인수(Positional).* `lorem(50)`의 `50`과 같습니다.
  그냥 괄호 안에 쓰면 됩니다. 여러 개인 경우 쉼표를 사용하세요.
+ *명명된 인수(Named).* `#quote(attribution: "누군가")`에서와 같습니다.
  이름과 콜론 뒤에 값을 씁니다.

명명된 인수인 경우 일종의 _기본값_ 을 가집니다.
그것이 무엇인지 확인하려면
#link("https://typst.app/docs/reference/")[공식 Typst 참조 문서]를 확인하세요.

Typst 언어에서 가장 "보편적인" 타입은 *콘텐츠(content)*입니다.
문서에 작성하는 모든 것이 콘텐츠가 됩니다.

#[
  하지만 *대괄호* 를 사용해 _스크립팅 모드_ 에서
  명시적으로 콘텐츠를 생성할 수도 있습니다.

  대괄호 안에서는 어떤 마크업 함수나
  원하는 모든 것을 사용할 수 있습니다.
]

`#`을 사용하면 코드 모드로 "전환"됩니다.
`[]`를 사용하면 다시 _마크업_(또는 콘텐츠) 모드로 돌아갑니다:

// +-- 마크업(기본 모드)에서 해당 함수를 위한 스크립팅으로 전환
// |                 +-- 스크립팅 모드: `text` 호출, 마지막 인수는 마크업
// |     첫 번째 인수  |
// v     vvvvvvvvv   vvvv
   #rect(width: 5cm, text(red)[안녕 *세상아*])
//  ^^^^                       ^^^^^^^^^^^^^ `text`를 위한 마크업 인수일 뿐입니다.
//  |
//  +-- 스크립팅 모드에서 너비(width)와 다른 콘텐츠라는 두 인수로 `rect`를 호출합니다.

그렇다면 함수 뒤의 이 대괄호들은 무엇일까요?

만약 *함수 바로 뒤에 콘텐츠를 작성하면,
그 콘텐츠는 해당 함수의 위치 인수로 전달됩니다*.

#quote(block: true)[
  이를 통해 저는 #underline[함수]에 전달하는 것들에
  #text(red)[_말 그대로 무엇이든_] 작성할 수 있게 됩니다!
]

명확하게 하기 위해 다음과 같이 작성하면:

```typ
- #text(red)[빨간색 텍스트]
- #text([빨간색 텍스트], red)
- #text("빨간색 텍스트", red)
//      ^            ^
// 여기서 따옴표는 콘텐츠가 아니라 일반 문자열을 의미합니다!
// 이것은 그냥 텍스트입니다.
```

이 모든 것은 #text([빨간색 텍스트], red)와 같은 결과를 보여줍니다.

#set page(width: 15cm, margin: (left: 4cm, right: 4cm))

멋진 결과물이 나왔네요! 하지만 문서의 모든 곳에서 매번 복잡한 인수를 
사용하며 함수를 호출하는 것은 매우 번거로운 일입니다.

그래서 Typst에는 **규칙(rules)**이라는 개념이 있습니다. 
정확히는 문서를 구성하는 요소들이 따라야 할 규칙이죠.

#set par(justify: true)

가장 먼저 살펴볼 것은 `set` 규칙입니다.
위 예제에서 `par`(단락, paragraph의 약자)에 규칙을 적용하자 
이후의 모든 단락이 **양쪽 맞춤(justified)**으로 정렬되었습니다.

이 규칙은 설정된 지점 이후의 모든 요소에 적용되지만, 
특정 **범위(scope)** 내에서만 유효합니다(범위에 대해서는 나중에 자세히 다룹니다).

#par(justify: false)[
  물론 필요할 때는 `set` 규칙을 개별적으로 덮어쓸 수도 있습니다. 
  `set` 규칙은 단순히 해당 요소의 인수에 대한 **기본값** 을 
  지정하는 것이기 때문입니다.
]

참고: 위 예제의 첫 번째 줄에서는 양쪽 맞춤 효과를 잘 보여주기 위해 
페이지 크기를 줄이고 좌우 여백을 넓게 설정했습니다.

다른 규칙으로 넘어가기 전에, Typst에서 사용하는 길이에 대해 알아봅시다. 
Typst는 다음과 같은 다양한 절대 길이 단위를 지원합니다.

#set rect(height: 1em)

#table(
  columns: 2,
  [포인트(Points)], rect(width: 72pt),
  [밀리미터(Millimeters)], rect(width: 25.4mm),
  [센티미터(Centimeters)], rect(width: 2.54cm),
  [인치(Inches)], rect(width: 1in),
  [글꼴 크기 기준(Relative to font size)], rect(width: 6.5em)
)

여기서 `1em`은 **현재 글꼴의 크기**와 같습니다. 
문맥에 맞춰 유연하게 크기를 조절할 때 매우 유용한 단위이므로 
앞으로 자주 사용하게 될 것입니다.

#set quote(block: true, attribution: [Typst 예시 북])

#quote[
  Typst는 정말 훌륭한 도구입니다!
]

#quote[
  인터넷에 떠도는 명언의 가장 큰 문제는 
  그 진위 여부를 확인하기가 매우 어렵다는 점입니다.
]

#set par(justify: true)
#set list(indent: 1em)
#set enum(indent: 1em)
#set page(numbering: "1")

- 목록 첫 번째 항목
- 목록 두 번째 항목

+ 순서가 있는 항목 1
+ 순서가 있는 항목 2

= 번호 매기기

제목(heading)과 같은 일부 요소에는 `numbering`이라는 속성이 있습니다. 
여기에 특정 "번호 매기기 패턴"을 지정하고 `set` 규칙과 결합하면 
복잡한 계층 구조도 자동으로 관리할 수 있습니다.

#set heading(numbering: "I.1:")

= 1단계 제목
= 또 다른 1단계 제목
== 2단계 소제목
== 또 다른 2단계 소제목
=== 3단계 상세 제목
== 다시 2단계로
= 다시 1단계로

스타일링의 정점에는 **`show` 규칙**이 있습니다. 
소스 코드와 출력 결과를 비교하며 어떻게 작동하는지 확인해 보세요.

#show "조심하세요": strong[놀아요]

이 기능은 매우 강력해서 문서의 내용을 완전히 뒤바꿀 수도 있습니다. 
따라서 신중하게 사용해야 합니다.

#show "인질로 잡혀 있어요": text(green)[전 괜찮아요]

방금 어떤 일이 일어났나요? 소스 코드에는 분명 "조심하세요"라고 적었지만, 
실제 문서에는 "놀아요"라고 출력되었습니다. 

도와주세요, 인질로 잡혀 있어요.

`show` 규칙은 특정 **선택자(selector)**를 찾아 
원하는 형태나 스타일로 변형하는 기능을 제공합니다.

다음 예제처럼 매우 실용적으로 활용할 수 있습니다.

#show emph: set text(blue)

이제 문서 전체에서 _강조(emphasize)_된 텍스트는 
기울임꼴과 동시에 **파란색** 으로 표시됩니다. 
일일이 색상을 지정할 필요가 없어 매우 편리합니다.

`show` 규칙은 겉보기에 복잡해 보일 수 있지만, 근본적인 원리는 모두 같습니다. 

// 아래 예제들은 기본적으로 특정 함수를 입히는 것과 같습니다.
// `with`는 인자가 미리 설정된 새로운 함수를 만듭니다.
#let redify(string) = text(red, string)

// 주황색 테두리를 입히는 함수 정의
#let framify(object) = rect(object, stroke: orange)

// 문서 전체의 기본 글자 색상을 파란색으로 설정
#show: set text(blue)

파란색 글자들.

// 모든 요소를 사각형 프레임으로 감싸기
#show: framify

프레임이 씌워진 텍스트.

// 익명 함수를 사용해 위와 동일한 효과를 낼 수도 있습니다.
#show: a => framify(a)

이중 프레임.

// 특정 단어 "the"에만 빨간색 적용
#show "the": redify
// 모든 제목(heading)의 색상을 보라색으로 설정
#show heading: set text(purple)

= 결론

결국 이 모든 규칙은 '무엇을(선택자)', '어떻게(변형)' 바꿀 것인지를 정의하는 과정입니다.

텍스트 이전
= 제목
텍스트 이후

#show heading: set block(spacing: 0.5em)

텍스트 이전
= 제목
텍스트 이후

`show` 규칙은 다음과 같은 다양한 선택자를 사용할 수 있습니다.

- 요소 함수 (element functions)
- 문자열 (strings)
- 정규 표현식 (regular expressions)
- 필드 필터 (field filters)

특정 조건에만 스타일을 적용하는 예시를 살펴보겠습니다.

#show heading.where(level: 1): set align(center)

= 1단계 제목 (중앙 정렬됨)
== 2단계 제목 (기본 정렬)

물론 개별 요소에서 직접 설정할 수도 있지만, 
`show` 규칙을 쓰면 일관된 스타일을 유지하기 훨씬 쉽습니다.

#align(center)[== 수동으로 정렬한 제목]

제목 스타일을 완전히 새롭게 정의하는 함수를 직접 작성해 봅시다.

// "it"은 선택된 제목(heading) 객체입니다.
#show heading: it => {
  // 중앙 정렬 설정
  set align(center)
  // 글자 크기와 굵기 설정
  set text(12pt, weight: "regular")
  
  // 내용을 작은 대문자(smallcaps)로 변환하고 블록으로 감쌉니다.
  block(smallcaps(it.body))
}

= Smallcaps Heading Example

#set page(
  // 상단 헤더 설정
  header: align(
    right + horizon,
    [여기에 헤더 내용 입력]
  ),
  height: 12cm
)

#align(center, text(17pt)[
  *문서의 주요 제목*
])

#grid(
  columns: (1fr, 1fr),
  align(center)[
    저자 성함 \
    소속 기관 \
    #link("mailto:some@mail.edu")
  ],
  align(center)[
    공동 저자 \
    공동 소속 기관 \
    #link("mailto:another@mail.edu")
  ]
)

// 본문을 두 단(2 columns)으로 나눕니다.
#show: rest => columns(2, rest)

// 1단계 제목 스타일 정의
#show heading.where(level: 1): it => block(width: 100%)[
  #set align(center)
  #set text(12pt, weight: "regular")
  #smallcaps(it.body)
]

// 2단계 제목 스타일 정의 (이탤릭체 및 마침표 추가)
#show heading.where(level: 2): it => text(
  size: 11pt,
  weight: "regular",
  style: "italic",
  it.body + [.],
)

= 서론
== 소제목 예시
#lorem(15)

== 두 번째 섹션
#lorem(20)

= 본론
#lorem(40)

// 다음과 같은 함수를 정의합니다:
// - 콘텐츠를 인수로 받음
// - 스타일을 적용함
// - 스타일이 적용된 콘텐츠를 반환함
#let apply-template(body) = [
  #show heading.where(level: 1): emph
  #set heading(numbering: "1.1")
  // ...
  #body
]

// 스크립팅 모드를 사용하면 필요한 해시(#) 기호의 수를 줄일 수 있습니다.
// 위와 동일하지만, 마크업 모드에서 스크립팅 모드로 전환하기 위해
// `[...]`를 `{...}`로 바꿨습니다.
#let apply-template(body) = {
  show heading.where(level: 1): emph
  set heading(numbering: "1.1")
  // ...
  body
}

#import "template.typ": apply-template
#show: apply-template

// 선택적인 명명된 인수를 추가합니다.
#let apply-template(body, name: "나의 문서") = {
  show heading.where(level: 1): emph
  set heading(numbering: "1.1")

  align(center, text(name, size: 2em))

  body
}

#import "template.typ": apply-template

// `func.with(..)`는 함수에 인수를 적용하고,
// 해당 기본값이 적용된 새로운 함수를 반환합니다.
#show: apply-template.with(name: "보고서")

// 이것은 기능적으로 다음과 동일합니다.
#let new-template(..args) = apply-template(name: "보고서", ..args)
#show: new-template

박스(box)를 사용하여 무엇이든
텍스트 안으로 감쌀 수 있습니다: #box(image("../tiger.jpg", height: 2em)).

블록(block)은 항상 "별도의 단락"이 됩니다.
텍스트 안에 들어가지 않습니다: #block(image("../tiger.jpg", height: 2em))

#box(stroke: red, inset: 1em)[박스 텍스트]
#block(stroke: red, inset: 1em)[블록 텍스트]

#rect[블록 텍스트]

@tiger 는 호랑이를 보여줍니다. 호랑이는
동물입니다.

#figure(
  image("../tiger.jpg", width: 80%),
  caption: [호랑이.],
) <tiger>

당신에게 편지를 쓰라고 하더군요. 여기 있습니다:

#figure(
  text(size: 5em)[나],
  caption: [나 멋지지 않나요?],
) 

가로 #h(1cm) 간격.
#v(1cm)
그리고 세로 간격도 있습니다!

#set rect(height: 1em)
#table(
  columns: 2,
  [포인트(Points)], rect(width: 72pt),
  [밀리미터(Millimeters)], rect(width: 25.4mm),
  [센티미터(Centimeters)], rect(width: 2.54cm),
  [인치(Inches)], rect(width: 1in),
)

#set rect(height: 1em)
#table(
  columns: 2,
  [센티미터], rect(width: 2.54cm),
  [글꼴 크기 기준], rect(width: 6.5em)
)

글꼴 크기 두 배: #box(stroke: red, baseline: 40%, height: 2em, width: 2em)

조합: #box(rect(height: 5pt + 1em))

#(5pt + 1em).abs
#(5pt + 1em).em

이 선의 너비는 사용 가능한 페이지 너비(여백 제외)의 50%입니다:

#line(length: 50%)

이 선의 너비는 박스 너비의 50%입니다: #box(stroke: red, width: 4em, inset: (y: 0.5em), line(length: 50%))

#rect(width: 100% - 50pt)

#(100% - 50pt).length \
#(100% - 50pt).ratio

왼쪽 #h(1fr) 오른쪽

#rect(height: 1em)[
  #h(1fr)
]

왼쪽 #h(1fr) 왼쪽 중심 #h(2fr) 오른쪽

단어: #h(1fr) #box(height: 1em, stroke: red)[
  #h(2fr)
]

#set page(height: 60pt)
안녕, 세상아!

#place(
  top + right, // 페이지 오른쪽 상단에 배치
  square(
    width: 20pt,
    stroke: 2pt + blue
  ),
)

#set page(height: 150pt)
#let note(where, body) = place(
  center + where,
  float: true,
  clearance: 6pt,
  rect(body),
)

#lorem(10)
#note(bottom)[하단 1]
#note(bottom)[하단 2]
#lorem(40)
#note(top)[상단]
#lorem(10)

#set page(height: 100pt)
#for i in range(16) {
  let amount = i * 4pt
  place(center, dx: amount - 32pt, dy: amount)[A]
}

#rect(inset: 0pt, move(
  dx: 6pt, dy: 6pt,
  rect(
    inset: 8pt,
    fill: white,
    stroke: black,
    [아브라카다브라]
  )
))

#scale(x: -100%)[좌우가 반전되었습니다.]

A#box(scale(75%)[A])A \
B#box(scale(75%, origin: bottom + left)[B])B

안녕 철수 \
#hide[안녕] 영희

#align(center)[이 텍스트는 중앙에 배치됩니다.]

#align(right + bottom)[
  오른쪽 아래에 배치되는 내용입니다.
]

#set rect(stroke: 1pt)
#rect[패딩이 없는 상자]
#pad(left: 2em)[#rect[왼쪽에 2em 패딩이 추가된 상자]]

#pad(x: 1em, y: 0.5em)[가로 1em, 세로 0.5em 패딩]

#rect(inset: 10pt)[내부 여백이 10pt인 상자]

#set text(size: 9pt)

#let yield_cells(n) = {
  for i in range(0, n + 1) {
    for j in range(0, n + 1) {
      let product = if i * j != 0 {
        // 더 예쁜 외관을 위해 수식 사용
        if j <= i { $#{ j * i }$ } 
        else {
          // 표의 윗부분
          text(gray.darken(50%), str(i * j))
        }
      } else {
        if i == j {
          // 오른쪽 상단 모서리 
          $times$
        } else {
          // 둘 중 하나가 0이면 상단/좌측에 위치함
          $#{i + j}$
        }
      }
      // 이것은 배열이며, for 루프는 이들을 
      // 하나의 커다란 셀 배열로 병합합니다.
      (
        table.cell(
          fill: if i == j and j == 0 { orange } // 오른쪽 상단 모서리
          else if i == j { yellow } // 대각선
          else if i * j == 0 { blue.lighten(50%) }, // 곱하는 수
          product,),
      )
    }
  }
}

#let n = 10
#table(
  columns: (0.6cm,) * (n + 1), rows: (0.6cm,) * (n + 1), align: center + horizon, inset: 3pt, ..yield_cells(n),
)

#table(
  columns: 2,
  fill: (x, y) => if y == 2 { highlight.fill },
  [A], [B],
  [C], [D],
  [E], [F],
  [G], [H],
)

#table(
  columns: 2,
  [A], [B],
  table.cell(fill: yellow)[C], table.cell(fill: yellow)[D],
  [E], [F],
  [G], [H],
)

#set page(height: 8em)
#(
table(
  columns: 5,
  [Aligner], [publication], [Indexing], [Pairwise alignment], [Max. read length  (bp)],
  [BWA], [2009], [BWT-FM], [Semi-Global], [125],
  [Bowtie], [2009], [BWT-FM], [HD], [76],
  [CloudBurst], [2009], [Hashing], [Landau-Vishkin], [36],
  [GNUMAP], [2009], [Hashing], [NW], [36]
  )
)

#set page(height: 8em)
// 이것이 없으면 표가 여러 페이지에 걸쳐 나뉘지 못합니다.
#show figure: set block(breakable: true)
#figure(
table(
  columns: 5,
  [Aligner], [publication], [Indexing], [Pairwise alignment], [Max. read length  (bp)],
  [BWA], [2009], [BWT-FM], [Semi-Global], [125],
  [Bowtie], [2009], [BWT-FM], [HD], [76],
  [CloudBurst], [2009], [Hashing], [Landau-Vishkin], [36],
  [GNUMAP], [2009], [Hashing], [NW], [36]
  )
)

#import "@preview/treet:0.1.1": *

#show list: tree-list
#set par(leading: 0.8em)
#show list: set text(font: "Noto Sans CJK KR", size: 0.8em)
- chapters/
  - chapter_1.typ
  - chapter_2.typ
- main.typ 👁 #text(gray)[← 문서 진입점]
- template.typ

// template.typ

#let template = doc => {
    set page(header: "나의 멋진 문서")
    show "physics": "magic"
    doc
}

#let infoblock = block.with(stroke: blue, fill: blue.lighten(70%))
#let author = "@sitandr"

// main.typ

#import "template.typ": *
// 템플릿이 있다면
#show: template

= 이것은 문서 제목입니다

// 추가 서식

#show emph: set text(blue)

// 하지만 여기에 함수나 변수를 정의하지 마세요!
// 챕터에서는 볼 수 없습니다

// 이제 챕터 자체를 Typst 콘텐츠로 포함합니다
#include("chapters/chapter_1.typ")
#include("chapters/chapter_1.typ")

// chapter_1.typ

#import "../template.typ": *

_스타일링_ 과 블록이 있는 콘텐츠일 뿐입니다:

#infoblock[일부 정보].

// 문서에 포함하고 싶은 모든 콘텐츠

#let author = "홍길동"

이것은 #author 가 쓴 책입니다. #author 는 정말 멋진 사람입니다.

#quote(block: true, attribution: author)[
  \<어떤 인용문\>
]

#let block_text = block(stroke: red, inset: 1em)[텍스트]

#block_text

#figure(caption: "블록", block_text)

// 이것은 앞서 보았던 구문입니다.
#let f = (name) => "안녕, " + name

#f("세상아!")

// 다음 구문들은 동일합니다.
#let f = (name) => "안녕, " + name
#let f(name) = "안녕, " + name

#f("세상아!")

#let v = [일부 텍스트, _마크업_ 및 다른 #strong[함수들]]
#v

#let f(name) = [안녕, #name]
#f[세상] // 콘텐츠를 전달하는 데 사용할 수 있다는 점도 잊지 마세요!

#let f(name) = {
  // 여기는 코드 모드입니다.

  // 출력의 첫 번째 부분
  "안녕, "

  // 이름이 비어 있는지 확인하고, 비어 있다면
  // 자리 표시자를 삽입합니다.
  if name == "" {
      "무명씨"
  } else {
      name
  }

  // 문장 마무리
  "!"
}

#f("")
#f("철수")
#f("세상")

#let f(name: "무명씨") = [안녕, #name!]

#f()
#f(name: "철수")
#f(name: "세상")

#let f(name) = [
  안녕, #name
]
#f("철수")

#let f(name) = {
  [안녕,]
  name
}
#f("철수")

// 이렇게 하지 마세요
// 제발요
#let f(inner) = [
  #set align(center)
  #set box(stroke: red)
  #show heading: it => [
    #set text(size: 2em)
    #it
  ]
  #box[#inner]
]

#{
  let a = 3;
}
// 여기서 "a"를 사용할 수 없습니다.

#[
  #show "참": "거짓"

  이것은 참입니다.
]

이것은 참입니다.

#let change_world() = {
  // 세상의 모든 것을 바꾸는 어떤 코드
  str(4e7)
  // 세상을 바꾸는 또 다른 코드
}

#let g() = {
  "하하하, 이제 세상을 바꾸겠다! "
  change_world()
  " 이것이 나의 길고 사악한 독백이다..."
}

#g()

#let f() = {
  "어떤 긴 텍스트"
  // 엄청난 숫자들
  "2e7"
  return none
}

// 아무것도 반환하지 않음
#f()

#let c = [이것은 _콘텐츠_ 입니다!]

// c의 타입 확인
#(type(c) == content)

#c

// repr은 값의 "내부 표현"을 보여줍니다.
#repr(c)

#none
#repr(none)

#let s = "어떤 긴 문자열. 이스케이프 문자가 포함될 수 있습니다: \n,
 줄 바꿈, 그리고 유니코드 코드까지: \u{1251}"
#s \
#type(s) \
`repr`: #repr(s)

#let s = "또 다른 짧은 문자열"
#s.replace("또", sym.alpha) \
#s.split(" ") // 공백으로 분할

#str(5) // 문자열이 되어 문자열처럼 다룰 수 있습니다.

#let b = false
#b \
#repr(b) \
#(true and not true or true) = #((true and (not true)) or true) \
#if (4 > 3) {
  "4는 3보다 큽니다"
}

#let n = 5
#n \
#(n += 1) \
#n \
#calc.pow(2, n) \
#type(n) \
#repr(n)

#(1 + 2) \
#(2 - 5) \
#(3 + 4 < 8)

#0xff \
#0o10 \
#0b1001

#int(false) \
#int(true) \
#int(2.7) \
#(int("27") + int("4"))

#let n = 5.0

// 부동 소수점과 정수를 섞어 쓸 수 있으며,
// 암시적으로 변환됩니다.
#(n += 1) \
#calc.pow(2, n) \
#(0.2 + 0.1) \
#type(n) 

#3.14 \
#1e4 \
#(10 / 4)

#float(40%) \
#float("2.7") \
#float("1e5")

#let values = (1, 7, 4, -3, 2)

// 인덱스 0의 값 가져오기
#values.at(0) \
// 인덱스 0의 값을 3으로 설정
#(values.at(0) = 3)
// 음수 인덱스 => 뒤에서부터 시작
#values.at(-1) \
// 짝수인 항목의 인덱스 찾기
#values.find(calc.even)

#let values = (1, 7, 4, -3, 2)

// 홀수만 남기기
#values.filter(calc.odd) \
// 리스트 값들의 절대값으로 새로운 리스트 생성
#values.map(calc.abs) \
// 뒤집기
#values.rev() \
// 배열의 배열을 평탄한 배열로 변환
#(1, (2, 3)).flatten() \
// 문자열 배열을 하나의 문자열로 결합
#(("A", "B", "C")
 .join(", ", last: " 및 "))

// 리스트 덧셈:
#((1, 2, 3) + (4, 5, 6))

// 리스트 곱셈:
#((1, 2, 3) * 4)

#() \ // 빈 리스트입니다.
#(1,) \  // 요소가 하나인 리스트입니다.
잘못됨: #(1) // 이것은 리스트가 아니라 그냥 하나의 요소입니다!

#let dict = (
  name: "Typst",
  born: 2019,
)

#dict.name \
#(dict.launch = 20)
#dict.len() \
#dict.keys() \
#dict.values() \
#dict.at("born") \
#dict.insert("city", "Berlin ")
#("name" in dict)

이것은 빈 리스트입니다: #() \
이것은 빈 딕셔너리입니다: #(:)

#if 1 < 2 [
  이 내용이 보입니다.
] else [
  이 내용은 보이지 않습니다.
]

#let a = 3

#if a < 4 {
  a = 5
}

#a

#let a = 5

#if a < 4 {
  a = 5
} else if a < 6 {
  a = -3
}

#a

#let a = 5

#if (a > 1 and a <= 4) or a == 5 [
    `a`가 조건에 부합합니다.
]

#let draft = true

// 여기서 바로 조건 연산을 수행할 수 있습니다.
#set page(columns: 2, width: 20em, height: 10em) if not draft

// show 규칙 내부에서도 사용할 수 있습니다.
#show "TODO": set text(red, size: 2em) if draft

TODO: 실제 텍스트를 작성하세요.

#lorem(50)

#let a = 3

#while a < 100 {
    a *= 2
    str(a)
    " "
}

#for c in "ABC" [
  #c 는 글자입니다.
]

#let s = 0

#for i in range(3, 6) {
    s += i
    [숫자 #i 가 합계에 더해졌습니다. 현재 합계는 #s 입니다.]
}

#let s = 0

#for i in (3, 4, 5) {
    s += i
    [숫자 #i 가 합계에 더해졌습니다. 현재 합계는 #s 입니다.]
}

#let people = (Alice: 3, Bob: 5)

#for (name, value) in people [
    #name 은 #value 개의 사과를 가지고 있습니다.
]

#for letter in "abc nope" {
  if letter == " " {
    // 공백이 있으면 중단
    break
  }

  letter
}

#for letter in "abc nope" {
  if letter == " " {
    // 공백은 건너뜀
    continue
  }

  letter
}

#let func(a, b, c, d, e) = [#a #b #c #d #e]
#func(..(([안녕],) * 5))

#let a = ("안녕", "b", "c")

#table(columns: 3,
  [테스트], [x], [안녕],
  ..a
)

#let text-params = (fill: blue, size: 0.8em)

일부 #text(..text-params)[텍스트].

#let f(..args) = [
  #args.pos()\
  #args.named()
]

#f(1, "a", width: 50%, block: false)

#let format(title, ..authors) = {
  let by = authors
    .pos()
    .join(", ", last: " 및 ")

  [*#title* \ _작성자: #by;_]
}

#format("ArtosFlow", "Jane", "Joe")

#let a = 7
#let b = 7.0
#(a == b)
#(type(a) == type(b))

#let a = (x: 1, y: 2)
#let b = (y: 2, x: 1)
#(a == b)
#(a.pairs() == b.pairs())

#let dict = (a: 1, b: 2)

#("a" in dict)
// 다음과 동일한 결과를 줍니다.
#(dict.keys().contains("a"))

#("a" in ("b", "c", "a"))
#(("b", "c", "a").contains("a"))

#let x = 0
#let compute(expr) = {
  // eval은 문자열을 Typst 코드로 해석하여
  // 새로운 x 값을 계산합니다.
  x = eval(
    expr.replace("x", str(x))
  )
  [새로운 값은 #x 입니다.]
}

#compute("10") \
#compute("x + 3") \
#compute("x * 2") \
#compute("x - 5")

#let s = state("x", 0)
#let compute(expr) = [
  // 이 함수로 x의 현재 상태를 업데이트합니다.
  #s.update(x =>
    eval(expr.replace("x", str(x)))
  )
  // 그리고 이를 표시합니다.
  새로운 값은 #context s.get() 입니다.
]

#compute("10") \
#compute("x + 3") \
#compute("x * 2") \
#compute("x - 5")

계산은 문서에 _위치한 순서_대로 이루어집니다. 따라서 계산을 먼저 만들었지만 문서의 나중에 배치한다면... 직접 확인해 보세요:

#let more = [
  #compute("x * 2") \
  #compute("x - 5")
]

#compute("10") \
#compute("x + 3") \
#more

#let x = state("state-id")
#let y = state("state-id", 2)

#x, #y

상태는 #context x.get() 입니다. \ // 다음과 동일합니다.
#context [상태는 #y.get() 입니다.] \ // 다음과 동일합니다.
#context {"상태는 " + str(y.get()) + " 입니다."}

#let x = state("x", 0)
#context x.get() \
#let _ = x.update(3)
// 아무 일도 일어나지 않습니다. `update`를 문서 흐름에 넣지 않았기 때문입니다.
#context x.get()

#repr(x.update(3)) // 해당 콘텐츠가 어떻게 보이는지 확인해 보세요. \

#context x.update(3)
#context x.get() // 드디어 업데이트되었습니다!

#let x = state("x", 0)

#context {
  x.update(3)
  str(x.get())
}

#let f(x) = {
  // 새로운 상태를 반환하지만...
  // ...ID가 같습니다!
  // 따라서 항상 동일한 상태가 됩니다!
  let y = state("x", 0)
  y.update(y => y + x)
  context y.get()
}

#let a = f(2)
#let b = f(3)

#a, #b \
#raw(repr(a) + "\n" + repr(b))

// 코드에서의 위치가 다릅니다!
#let x = state("state-id")
#let y = state("state-id", 2)

#x, #y

#let x = state("state-id")
#let y = state("state-id", 2)

#context [#x.get(); #y.get()]

#x.update(3)

#context [#x.get(); #y.get()]

#set heading(numbering: "1.")

= 배경
#counter(heading).update(3)
#counter(heading).update(n => n * 2)

== 분석
현재 제목 번호: #context counter(heading).get()

패턴을 사용해 예쁘게 렌더링할 수도 있습니다: #context counter(heading).display("I: 1.")

또는 현재 설정된 스타일을 사용합니다: #context counter(heading).display()

이는 현재 설정된 스타일에 따라 달라집니다:

#set heading(numbering: ":1:1:")
#context counter(heading).display()

#let mine = counter("mycounter")
#context mine.display()

#mine.step()
#context mine.display()

#mine.update(c => c * 3)
#context mine.display()

#set heading(numbering: "1.")

= 서론
내용이 들어갑니다.

#context counter(heading).display(both: true) \
#context counter(heading).display("1 / 1", both: true) \
#context counter(heading).display(
  (num, max) => [#num / #max],
   both: true
)

= 배경
현재 값은 다음과 같습니다: #context counter(heading).display()

#set heading(numbering: "1.")

= 서론
#context counter(heading).step()

= 분석
3.1은 건너뜁시다.
#context counter(heading).step(level: 2)

== 분석
현재 위치: #context counter(heading).display()

#let c = counter("theorem")
#let theorem(it) = block[
  #c.step()
  *정리 #context c.display():*
  #it
]

#theorem[$1 = 1$]
#theorem[$2 < 3$]

현재 글꼴: #context text.font

#let colorful-rect = context box(stroke: text.fill, inset: 0.3em)[#repr(text.fill)]

동일한 색상의 박스 안에 있는 현재 색상: #colorful-rect.

#set text(red)

동일한 색상의 박스 안에 있는 현재 색상: #colorful-rect.

(나쁜 예)

#let page-dimensions = context (page.width, page.height)
#page-dimensions, 이 객체의 표현(representation)은 다음과 같습니다: #repr(page-dimensions)

(좋은 예!)

// 컨텍스트 의존적 함수가 되려면 단순한 고정 콘텐츠가 아니라 함수여야 합니다.
#let page-dimensions() = (page.width, page.height)

#context page-dimensions()

#context [
    #let (x, y) = page-dimensions()
    너비의 절반은 #(x/2) 이고, 높이는 #y 입니다.
]

#context [
    텍스트 색상: #text.fill

    #set text(blue)

    텍스트 색상: #text.fill
]

#let content = [안녕!]
#content
#set text(14pt)
#content

#let thing(body) = context {
  let size = measure(body)
  ["#body" 의 너비는 #size.width 입니다.]
}

#thing[이봐요] \
#thing[환영합니다]

/// 부모 크기를 받아서 무언가를 렌더링하는 블랙박스입니다.
#layout(size => {
  let half = 50% * size.width
  [페이지의 절반 너비는 #half 입니다.]
})

#let text = lorem(30)
#layout(size => context [
  #let (height,) = measure(
    block(width: size.width, text)
  )
  이 텍스트의 높이는 현재 페이지 너비에서 #height 입니다: \
  #text
])

#let s = state("x", 0)
#let compute(expr) = [
  #s.update(x =>
    eval(expr.replace("x", str(x)))
  )
  새로운 값은 #context s.get() 입니다.
]

`<here>` 지점에서의 값은 다음과 같습니다:
#context s.at(
  query(<here>)
    .first()
    .location()
)

#compute("10") \
#compute("x + 3") \
*여기.* <here> \
#compute("x * 2") \
#compute("x - 5")

#set page(header: context {
  let elems = query(
    selector(heading).before(here())
  )
  let academy = smallcaps[
    Typst Academy
  ]
  if elems == () {
    align(right, academy)
  } else {
    let body = elems.last().body
    academy + h(1fr) + emph(body)
  }
})

= 서론
#lorem(23)

= 배경
#lorem(30)

= 분석
#lorem(15)

// 어딘가에 메타데이터를 배치합니다.
#metadata("이것은 메모입니다") <note>

// 그리고 다른 어디서든 이를 찾습니다.
#context {
  query(<note>).first().value
}

// 이것은 인라인 수식입니다.
$a$, $b$, $c$를 직각삼각형의
변의 길이라 하자.
그러면 다음을 알 수 있습니다:

// 이것은 디스플레이 수식입니다.
$ a^2 + b^2 = c^2 $

수학적 귀납법으로 증명하기:

// 공백으로 줄 바꿈을 사용할 수도 있습니다!
$
sum_(k=1)^n k = (n(n+1)) / 2
$

#show math.equation: set text(red)

$
integral_0^oo (f(t) + g(t))/2
$

#math.integral, #math.underbrace([a + b], [c])

$
a = b\
a = c
$

$
a  / b \
a \/ b
$

#lorem(17) $display(1)/display(1+x^n)$ #lorem(20)

#lorem(17) #box($display(1)/display(1+x^n)$, inset: 0.2em) #lorem(20)

$
forall v, w in V, alpha in KK: alpha dot (v + w) = alpha v + alpha w
$

$
∀ v, w ∈ V, α ∈ 𝕂: α ⋅ (v + w) = α v + α w
$

$
// cont — contour (폐곡선)
integral, integral.cont, integral.double, integral.square, sum.integral\

// lt — less than (미만), gt — greater than (초과)
lt, lt.circle, lt.eq, lt.not, lt.eq.not, lt.tri, lt.tri.eq, lt.tri.eq.not, gt, lt.gt.eq, lt.gt.not
$

$
gt.nequiv, gt.napprox, gt.ntilde, gt.tilde.not
$

$
alpha, Alpha, beta, Beta, beta.alt, gamma, pi, Pi,\
pi.alt, phi, phi.alt, Phi, omicron, kappa, kappa.alt, Psi,\
theta, theta.alt, xi, zeta, rho, rho.alt, kai, Kai,
$

$bb(A), AA, bb(1)$

// 기본 수학 글꼴의 nothing 기호는 좋지 않습니다.
$nothing, nothing.rev, diameter$

#show math.equation: set text(font: "Fira Math")

// Fira math가 더 일관성이 있습니다.
$nothing, nothing.rev, diameter$

#show math.equation: set text(features: ("cv01",))

$nothing, nothing.rev, diameter$

#show math.nothing: math.diameter

$nothing, nothing.rev, diameter$

$ (a^2 + b^2)/2 $

$
{[((a + b)/2) + 1]_0}
$

$
lr([a/2, b)) \
lr([a/2, b), size: #150%)
$

$
abs(a + b), norm(a + b), floor(a + b), ceil(a + b), round(a + b)
$

#show math.equation: set align(right)

$
(a + b)/2
$

#align(left, block($ x = 5 $))

$ (3x + y) / 7 &= 9 && "주어짐" \
  3x + y &= 63 & "7을 곱함" \
  3x &= 63 - y && "y를 뺌" \
  x &= 21 - y/3 & "3으로 나눔" $

$
integral_a^b\
limits(integral)_a^b
$

#show math.integral: math.limits

$
integral_a^b
$

이것은 인라인 수식입니다: $integral_a^b$

#show math.integral: math.limits.with(inline: false)

$
integral_a^b
$

이것은 인라인 수식입니다: $integral_a^b$.

$
sum_a^b, scripts(sum)_a^b
$

$a =_"보조정리 1에 의해" b, a scripts(=)_+ b$

$
lim x_n, "lim" x_n, "lim"x_n
$