From 9ba5d407f72b2603e0a45ad8fb0ccf060aa67deb Mon Sep 17 00:00:00 2001
From: Alfex4936 <ikr@kakao.com>
Date: Sun, 19 Mar 2023 00:13:09 +0900
Subject: [PATCH] Fix format

---
 docs/15_ko.html                    |  48 ++++++------
 docs/16_ko.html                    | 117 ++++++++++++++++-------------
 docs/tour.css                      |   1 +
 frontend/lessons/ko/chapter_1.yaml |  84 ++++++++++++---------
 4 files changed, 139 insertions(+), 111 deletions(-)

diff --git a/docs/15_ko.html b/docs/15_ko.html
index 336748c..e1cafe9 100644
--- a/docs/15_ko.html
+++ b/docs/15_ko.html
@@ -36,42 +36,42 @@
             </div>
             <div class="page">
             <h1>match</h1>
-            <p>Rust에서 match 키워드는 패턴 매칭을 위해 사용하고
-값과 일련의 패턴을 비교할 수 있게 해줍니다.
-그리고 첫 번째 일치하는 패턴에 해당하는 코드 블록을 실행합니다.
-```rust fn main() {
-    let number = 42;</p>
-<pre><code>match number {
-    0 =&gt; println!("숫자는 영입니다"),
-    1 =&gt; println!("숫자는 일입니다"),
-    42 =&gt; println!("인생, 우주, 그리고 모든 것에 대한 답"),
-    _ =&gt; println!("숫자는 다른 것입니다"),
-}
-</code></pre>
-<p>} <code>
-여기서는 number 변수의 값을 여러 패턴과 비교합니다.
-`_` 패턴은 이전 패턴에서 명시적으로 다루지 않은 모든 값을 매치하는 `catch-all` 패턴입니다.
-</code>rust fn classify_age(age: u8) {
+            <p>Rust에서 match 키워드는 패턴 매칭을 위해 사용하고</p>
+<p>값과 일련의 패턴을 비교할 수 있게 해줍니다.</p>
+<p>그리고 첫 번째 일치하는 패턴에 해당하는 코드 블록을 실행합니다.</p>
+<pre><code class="rust">fn main() {
+    let number = 42;
+
+    match number {
+        0 => println!("숫자는 영입니다"),
+        1 => println!("숫자는 일입니다"),
+        42 => println!("인생, 우주, 그리고 모든 것에 대한 답"),
+        _ => println!("숫자는 다른 것입니다"),
+    }
+} </code></pre>
+<p>여기서는 number 변수의 값을 여러 패턴과 비교합니다.</p>
+<p><code>_</code> 패턴은 이전 패턴에서 명시적으로 다루지 않은 모든 값을 매치하는 <code>catch-all</code> 패턴입니다.</p>
+<pre><code class="rust">fn classify_age(age: u8) {
     match age {
-        0..=12 =&gt; println!("어린이"),
-        13..=19 =&gt; println!("청소년"),
-        20..=64 =&gt; println!("성인"),
-        _ =&gt; println!("노인"),
+        0..=12 => println!("어린이"),
+        13..=19 => println!("청소년"),
+        20..=64 => println!("성인"),
+        _ => println!("노인"),
     }
 }
 fn main() {
     let age = 25;
     classify_age(age);
-} ```</p>
-<p>이 예제에서는 match 표현식을 사용하여 나이를 그룹으로 분류합니다.
-나이 변수와 매치하기 위해 범위를 패턴으로 사용합니다.</p>
+} </code></pre>
+<p>이 예제에서는 match 표현식을 사용하여 나이를 그룹으로 분류하고,</p>
+<p>나이 변수와 매치하기 위해 범위를 패턴으로 사용합니다.</p>
             <div class="bottomnav">
                 <span class="back"><a href="14_ko.html" rel="prev">❮ 이전</a></span>
                 <span class="next"><a href="16_ko.html" rel="next">다음 ❯</a></span>
             </div>
             </div>
             <div class="code">
-            <iframe id="rust-playground" width="100%" src="https://" scrolling="no" frameborder="no" allowtransparency="true" allowfullscreen="true" sandbox="allow-forms allow-pointer-lock allow-popups allow-same-origin allow-scripts allow-modals" title="Rust Playground" loading="lazy"></iframe>
+            <iframe id="rust-playground" width="100%" src="https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20swap(x%3A%20i32%2C%20y%3A%20i32)%20-%3E%20(i32%2C%20i32)%20%7B%0A%20%20%20%20return%20(y%2C%20x)%3B%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20%2F%2F%20return%20a%20tuple%20of%20return%20values%0A%20%20%20%20let%20result%20%3D%20swap(123%2C%20321)%3B%0A%20%20%20%20println!(%22%7B%7D%20%7B%7D%22%2C%20result.0%2C%20result.1)%3B%0A%0A%20%20%20%20%2F%2F%20destructure%20the%20tuple%20into%20two%20variables%20names%0A%20%20%20%20let%20(a%2C%20b)%20%3D%20swap(result.0%2C%20result.1)%3B%0A%20%20%20%20println!(%22%7B%7D%20%7B%7D%22%2C%20a%2C%20b)%3B%0A%7D%0A" scrolling="no" frameborder="no" allowtransparency="true" allowfullscreen="true" sandbox="allow-forms allow-pointer-lock allow-popups allow-same-origin allow-scripts allow-modals" title="Rust Playground" loading="lazy"></iframe>
             </div>
         </div>
         <!-- <script>
diff --git a/docs/16_ko.html b/docs/16_ko.html
index 6afd83a..2250b05 100644
--- a/docs/16_ko.html
+++ b/docs/16_ko.html
@@ -36,77 +36,91 @@
             </div>
             <div class="page">
             <h1>Struct and Enum</h1>
-            <h2 id="struct">구조체 (Struct)</h2>
-<p>구조체는 struct 키워드를 사용하여 정의하며, 이름과 중괄호로 묶인 명명된 필드 집합이 뒤따릅니다.
-다음은 Person 구조체의 예입니다:
-<code>rust struct Person {
+            <p><strong>구조체 (Struct)</strong></p>
+<p>구조체는 struct 키워드를 사용하여 정의하며, 이름과 중괄호로 묶인 명명된 필드 집합이 뒤따릅니다.</p>
+<p>다음은 Person 구조체의 예입니다:</p>
+<pre><code class="rust">struct Person {
   name: String,
   age: u8,
-}</code>
-구조체의 인스턴스를 생성하려면, 구조체 이름 뒤에 중괄호를 사용하고 필드에 값을 할당합니다.
+} </code></pre>
+<p>구조체의 인스턴스를 생성하려면, 구조체 이름 뒤에 중괄호를 사용하고 필드에 값을 할당합니다.
 예를 들면:</p>
-<h2 id="rustletpersonpersonnamestringfromaliceage30"><code>rust let person = Person { name: String::from("Alice"), age: 30 };</code></h2>
-<h2 id="enum">열거형 (Enum)</h2>
-<p>열거형(enum, "enumeration"의 줄임말)은 고정된 명명된 값 집합인 "변종(variants)"을 가진 타입을 나타냅니다.
-열거형을 정의하려면, enum 키워드를 사용하고 이름과 중괄호로 묶인 명명된 변종 집합이 뒤따릅니다.
-다음은 Status 열거형의 예입니다:
-<code>rust enum Status {
+<pre><code class="rust">let person = Person { name: String::from("Alice"), age: 30 }; </code></pre>
+<hr />
+<p><strong>열거형 (Enum)</strong></p>
+<p>열거형(enum, "enumeration"의 줄임말)은 고정된 명명된 값 집합인 "변종(variants)"을 가진 타입을 나타냅니다.</p>
+<p>열거형을 정의하려면, enum 키워드를 사용하고 이름과 중괄호로 묶인 명명된 변종 집합이 뒤따릅니다.</p>
+<p>다음은 Status 열거형의 예입니다:</p>
+<pre><code class="rust">enum Status {
   Active,
   Inactive,
   Pending,
-}</code>
-열거형의 인스턴스를 생성하려면, 열거형 이름 뒤에 두 개의 콜론(<code>::</code>)과 변종 이름을 사용합니다.
-예를 들면:
-<code>rust let status = Status::Active;</code>
-열거형 변종에 따라 다른 작업을 수행하려면 match 표현식을 사용할 수 있습니다:
-<code>rust let user_status = Status::Active;</code>
-열거형을 다루려면, 종종 match 표현식을 사용하며, 이를 통해 열거형 변종에 따라 다른 작업을 수행할 수 있습니다:
-```rust fn print<em>status</em>message(status: Status) {
+} </code></pre>
+<p>열거형의 인스턴스를 생성하려면, 열거형 이름 뒤에 두 개의 콜론(<code>::</code>)과 변종 이름을 사용합니다.</p>
+<p>예를 들면:</p>
+<pre><code class="rust">let status = Status::Active; </code></pre>
+<p>열거형 변종에 따라 다른 작업을 수행하려면 match 표현식을 사용할 수 있습니다:</p>
+<pre><code class="rust">let user_status = Status::Active; </code></pre>
+<p>열거형을 다루려면, 종종 match 표현식을 사용하며, 이를 통해 열거형 변종에 따라 다른 작업을 수행할 수 있습니다:</p>
+<pre><code class="rust">fn print_status_message(status: Status) {
     match status {
-        Status::Active =&gt; println!("사용자가 활성 상태입니다."),
-        Status::Inactive =&gt; println!("사용자가 비활성 상태입니다."),
-        Status::Pending =&gt; println!("사용자가 보류 중입니다."),
+        Status::Active => println!("사용자가 활성 상태입니다."),
+        Status::Inactive => println!("사용자가 비활성 상태입니다."),
+        Status::Pending => println!("사용자가 보류 중입니다."),
     }
 }
 fn main() {
-    let user<em>status = Status::Active;
-    print</em>status<em>message(user</em>status);</p>
-<h2 id="">} ```</h2>
-<h2 id="tuplestructenum">Tuple Struct, Enum</h2>
+    let user_status = Status::Active;
+    print_status_message(user_status);
+} </code></pre>
+<hr />
+<p><strong>Tuple Struct, Enum</strong></p>
 <p>주로 간결한 표현, 타입 안전성 및 논리적 구조를 위해 사용됩니다.</p>
 <ul>
-<li><p>튜플 구조체 (Tuple Struct): 튜플 구조체는 필드에 이름이 없는 구조체로, 간단한 데이터 구조를 표현할 때 유용합니다. 튜플 구조체를 사용하면, 구조체의 의미를 명확하게 나타낼 수 있으며, 일반 튜플보다 더 강력한 타입 안전성을 제공합니다. 예를 들어, 두 개의 float 값을 나타내는 Point2D와 Vector2D를 구별하기 위해 튜플 구조체를 사용할 수 있습니다. 이렇게 하면 코드의 가독성과 정확성이 향상됩니다. - 열거형 (Enum): 열거형은 서로 관련된 값의 집합을 표현하기 위해 사용됩니다. 열거형은 여러 변종(variants)을 가질 수 있으며, 각 변종은 고유한 타입입니다. 열거형은 논리적으로 관련된 여러 값을 그룹화하여 코드의 명확성과 구조를 개선하는 데 도움이 됩니다. 또한 열거형은 패턴 매칭을 사용하여 값에 따라 다양한 작업을 수행할 수 있어, 런타임에 오류가 발생하는 가능성이 줄어듭니다. - 튜플 열거형 변종 (Tuple Enum Variants): 튜플 열거형 변종은 열거형의 각 변종에 데이터를 연관시키는 데 사용됩니다. 튜플 열거형 변종은 각 변종에 서로 다른 타입과 수의 값을 저장할 수 있습니다. 이러한 변종은 열거형의 다양한 경우를 명확하게 구분하고, 관련 데이터를 함께 저장하여 논리적 구조를 제공하는 데 유용합니다. 패턴 매칭을 사용하면 튜플 열거형 변종의 값을 안전하게 추출하고, 해당 값에 따라 다양한 작업을 수행할 수 있습니다.
-```rust // 튜플 구조체 (Tuple Struct) struct Point3D(f32, f32, f32);
-// 열거형에 튜플 변종 (Tuple Enum Variant) 포함 enum Shape {
-Circle(f32),
-Rectangle(f32, f32),
+<li>튜플 구조체 (Tuple Struct): 튜플 구조체는 필드에 이름이 없는 구조체로, 간단한 데이터 구조를 표현할 때 유용합니다. 튜플 구조체를 사용하면, 구조체의 의미를 명확하게 나타낼 수 있으며, 일반 튜플보다 더 강력한 타입 안전성을 제공합니다. 예를 들어, 두 개의 float 값을 나타내는 Point2D와 Vector2D를 구별하기 위해 튜플 구조체를 사용할 수 있습니다. 이렇게 하면 코드의 가독성과 정확성이 향상됩니다.</li>
+<li>열거형 (Enum): 열거형은 서로 관련된 값의 집합을 표현하기 위해 사용됩니다. 열거형은 여러 변종(variants)을 가질 수 있으며, 각 변종은 고유한 타입입니다. 열거형은 논리적으로 관련된 여러 값을 그룹화하여 코드의 명확성과 구조를 개선하는 데 도움이 됩니다. 또한 열거형은 패턴 매칭을 사용하여 값에 따라 다양한 작업을 수행할 수 있어, 런타임에 오류가 발생하는 가능성이 줄어듭니다.</li>
+<li>튜플 열거형 변종 (Tuple Enum Variants): 튜플 열거형 변종은 열거형의 각 변종에 데이터를 연관시키는 데 사용됩니다. 튜플 열거형 변종은 각 변종에 서로 다른 타입과 수의 값을 저장할 수 있습니다. 이러한 변종은 열거형의 다양한 경우를 명확하게 구분하고, 관련 데이터를 함께 저장하여 논리적 구조를 제공하는 데 유용합니다. 패턴 매칭을 사용하면 튜플 열거형 변종의 값을 안전하게 추출하고, 해당 값에 따라 다양한 작업을 수행할 수 있습니다.</li>
+</ul>
+<pre><code class="rust">// 튜플 구조체 (Tuple Struct)
+struct Point3D(f32, f32, f32);
+
+// 열거형에 튜플 변종 (Tuple Enum Variant) 포함
+enum Shape {
+    Circle(f32),
+    Rectangle(f32, f32),
 }
+
 fn main() {
-let point = Point3D(1.0, 2.0, 3.0);
-let circle = Shape::Circle(5.0);
-let rectangle = Shape::Rectangle(4.0, 6.0);</p>
-<p>// 튜플 구조체의 값에 접근
-println!("x 좌표: {}", point.0);
-println!("y 좌표: {}", point.1);
-println!("z 좌표: {}", point.2);</p>
-<p>// 튜플 열거형 변종의 값에 접근
-match circle {
-    Shape::Circle(radius) =&gt; println!("원의 반지름: {}", radius),
-    _ =&gt; (),
-}</p></li>
-</ul>
-<h2 id="-1">} ```</h2>
-<h2 id="nested">Nested</h2>
-<p>중첩된 Struct과 Enum을 만들고 싶다면?
-<code>rust // 중첩된 구조체 (Nested Struct) struct Address {
+    let point = Point3D(1.0, 2.0, 3.0);
+    let circle = Shape::Circle(5.0);
+    let rectangle = Shape::Rectangle(4.0, 6.0);
+
+    // 튜플 구조체의 값에 접근
+    println!("x 좌표: {}", point.0);
+    println!("y 좌표: {}", point.1);
+    println!("z 좌표: {}", point.2);
+
+    // 튜플 열거형 변종의 값에 접근
+    match circle {
+        Shape::Circle(radius) => println!("원의 반지름: {}", radius),
+        _ => (),
+    }
+} </code></pre>
+<hr />
+<p><strong>Nested</strong>
+중첩된 Struct과 Enum을 만들고 싶다면?</p>
+<pre><code class="rust">// 중첩된 구조체 (Nested Struct)
+struct Address {
     street: String,
     city: String,
 }
+
 struct Person {
     name: String,
     address: Address,
 }
-// 중첩된 열거형 (Nested Enum) enum Animal {
+// 중첩된 열거형 (Nested Enum)
+enum Animal {
     Mammal {
         species: String,
         is_domestic: bool,
@@ -116,6 +130,7 @@ struct Person {
         is_poisonous: bool,
     },
 }
+
 fn main() {
     let person = Person {
         name: String::from("지훈"),
@@ -128,7 +143,7 @@ fn main() {
         species: String::from("개"),
         is_domestic: true,
     };
-}</code></p>
+} </code></pre>
             <div class="bottomnav">
                 <span class="back"><a href="15_ko.html" rel="prev">❮ 이전</a></span>
                 <span class="next"><a href="17_ko.html" rel="next">다음 ❯</a></span>
diff --git a/docs/tour.css b/docs/tour.css
index 2d1212e..fd04673 100644
--- a/docs/tour.css
+++ b/docs/tour.css
@@ -90,6 +90,7 @@ code {
 }
 
 h1,
+h2,
 p,
 pre {
   margin-left: 40px;
diff --git a/frontend/lessons/ko/chapter_1.yaml b/frontend/lessons/ko/chapter_1.yaml
index f72bd37..401dd8b 100644
--- a/frontend/lessons/ko/chapter_1.yaml
+++ b/frontend/lessons/ko/chapter_1.yaml
@@ -199,16 +199,18 @@
     우리는 더 많은 형태로 볼 것이며, 이를 통해 데이터 구조의 하위 요소를 직관적으로 추출할 수 있습니다.
 - title: match
   code: >-
-    https://
+    https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20swap(x%3A%20i32%2C%20y%3A%20i32)%20-%3E%20(i32%2C%20i32)%20%7B%0A%20%20%20%20return%20(y%2C%20x)%3B%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20%2F%2F%20return%20a%20tuple%20of%20return%20values%0A%20%20%20%20let%20result%20%3D%20swap(123%2C%20321)%3B%0A%20%20%20%20println!(%22%7B%7D%20%7B%7D%22%2C%20result.0%2C%20result.1)%3B%0A%0A%20%20%20%20%2F%2F%20destructure%20the%20tuple%20into%20two%20variables%20names%0A%20%20%20%20let%20(a%2C%20b)%20%3D%20swap(result.0%2C%20result.1)%3B%0A%20%20%20%20println!(%22%7B%7D%20%7B%7D%22%2C%20a%2C%20b)%3B%0A%7D%0A
   content_markdown: >
     Rust에서 match 키워드는 패턴 매칭을 위해 사용하고
 
+
     값과 일련의 패턴을 비교할 수 있게 해줍니다.
 
+
     그리고 첫 번째 일치하는 패턴에 해당하는 코드 블록을 실행합니다.
 
-    ```rust
-    fn main() {
+
+    <pre><code class="rust">fn main() {
         let number = 42;
 
         match number {
@@ -218,14 +220,15 @@
             _ => println!("숫자는 다른 것입니다"),
         }
     }
-    ```
+    </code></pre>
 
     여기서는 number 변수의 값을 여러 패턴과 비교합니다.
 
+
     `_` 패턴은 이전 패턴에서 명시적으로 다루지 않은 모든 값을 매치하는 `catch-all` 패턴입니다.
 
-    ```rust
-    fn classify_age(age: u8) {
+
+    <pre><code class="rust">fn classify_age(age: u8) {
         match age {
             0..=12 => println!("어린이"),
             13..=19 => println!("청소년"),
@@ -238,75 +241,75 @@
         let age = 25;
         classify_age(age);
     }
-    ```
+    </code></pre>
 
 
-    이 예제에서는 match 표현식을 사용하여 나이를 그룹으로 분류합니다.
+    이 예제에서는 match 표현식을 사용하여 나이를 그룹으로 분류하고,
+
 
     나이 변수와 매치하기 위해 범위를 패턴으로 사용합니다.
 - title: Struct and Enum
   code: >-
     https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&code=%2F%2F+%ED%8A%B9%EC%84%B1+%28Trait%29+%EC%A0%95%EC%9D%98%0D%0Atrait+Greet+%7B%0D%0A++++fn+greet%28%26self%29+-%3E+String%3B%0D%0A%7D%0D%0A%0D%0A%2F%2F+%EA%B5%AC%EC%A1%B0%EC%B2%B4+%28Struct%29+%EC%A0%95%EC%9D%98%0D%0Astruct+Person+%7B%0D%0A++++name%3A+String%2C%0D%0A%7D%0D%0A%0D%0A%2F%2F+%EA%B5%AC%EC%A1%B0%EC%B2%B4%EC%97%90+%EB%8C%80%ED%95%9C+%ED%8A%B9%EC%84%B1+%EA%B5%AC%ED%98%84%0D%0Aimpl+Greet+for+Person+%7B%0D%0A++++fn+greet%28%26self%29+-%3E+String+%7B%0D%0A++++++++format%21%28%22%EC%95%88%EB%85%95%ED%95%98%EC%84%B8%EC%9A%94%2C+%7B%7D%EB%8B%98%21%22%2C+self.name%29%0D%0A++++%7D%0D%0A%7D%0D%0A%0D%0A%2F%2F+%EC%97%B4%EA%B1%B0%ED%98%95+%28Enum%29+%EC%A0%95%EC%9D%98%0D%0Aenum+Animal+%7B%0D%0A++++Dog%2C%0D%0A++++Cat%2C%0D%0A%7D%0D%0A%0D%0A%2F%2F+%EC%97%B4%EA%B1%B0%ED%98%95%EC%97%90+%EB%8C%80%ED%95%9C+%ED%8A%B9%EC%84%B1+%EA%B5%AC%ED%98%84%0D%0Aimpl+Greet+for+Animal+%7B%0D%0A++++fn+greet%28%26self%29+-%3E+String+%7B%0D%0A++++++++match+self+%7B%0D%0A++++++++++++Animal%3A%3ADog+%3D%3E+String%3A%3Afrom%28%22%EB%A9%8D%EB%A9%8D%21%22%29%2C%0D%0A++++++++++++Animal%3A%3ACat+%3D%3E+String%3A%3Afrom%28%22%EC%95%BC%EC%98%B9%7E%22%29%2C%0D%0A++++++++%7D%0D%0A++++%7D%0D%0A%7D%0D%0A%0D%0Afn+main%28%29+%7B%0D%0A++++let+person+%3D+Person+%7B%0D%0A++++++++name%3A+String%3A%3Afrom%28%22%EA%B9%80%EC%95%84%EC%A3%BC%22%29%2C%0D%0A++++%7D%3B%0D%0A++++let+dog+%3D+Animal%3A%3ADog%3B%0D%0A%0D%0A++++%2F%2F+%EA%B5%AC%EC%A1%B0%EC%B2%B4%EC%99%80+%EC%97%B4%EA%B1%B0%ED%98%95+%EC%9D%B8%EC%8A%A4%ED%84%B4%EC%8A%A4%EC%97%90+greet+%EB%A9%94%EC%84%9C%EB%93%9C+%EC%82%AC%EC%9A%A9%0D%0A++++println%21%28%22%7B%7D%22%2C+person.greet%28%29%29%3B%0D%0A++++println%21%28%22%7B%7D%22%2C+dog.greet%28%29%29%3B%0D%0A%7D%0D%0A
   content_markdown: >
-    ## 구조체 (Struct)
+    **구조체 (Struct)**
 
 
     구조체는 struct 키워드를 사용하여 정의하며, 이름과 중괄호로 묶인 명명된 필드 집합이 뒤따릅니다.
 
+
     다음은 Person 구조체의 예입니다:
 
-    ```rust
-    struct Person {
+    <pre><code class="rust">struct Person {
       name: String,
       age: u8,
     }
-    ```
+    </code></pre>
 
     구조체의 인스턴스를 생성하려면, 구조체 이름 뒤에 중괄호를 사용하고 필드에 값을 할당합니다.
 
     예를 들면:
 
-    ```rust
-    let person = Person { name: String::from("Alice"), age: 30 };
-    ```
+    <pre><code class="rust">let person = Person { name: String::from("Alice"), age: 30 };
+    </code></pre>
 
     ---
 
-    ## 열거형 (Enum)
+    **열거형 (Enum)**
 
 
     열거형(enum, "enumeration"의 줄임말)은 고정된 명명된 값 집합인 "변종(variants)"을 가진 타입을 나타냅니다.
 
+
     열거형을 정의하려면, enum 키워드를 사용하고 이름과 중괄호로 묶인 명명된 변종 집합이 뒤따릅니다.
 
+
     다음은 Status 열거형의 예입니다:
 
-    ```rust
-    enum Status {
+    <pre><code class="rust">enum Status {
       Active,
       Inactive,
       Pending,
     }
-    ```
+    </code></pre>
+
 
     열거형의 인스턴스를 생성하려면, 열거형 이름 뒤에 두 개의 콜론(`::`)과 변종 이름을 사용합니다.
 
+
     예를 들면:
 
-    ```rust
-    let status = Status::Active;
-    ```
+    <pre><code class="rust">let status = Status::Active;
+    </code></pre>
 
     열거형 변종에 따라 다른 작업을 수행하려면 match 표현식을 사용할 수 있습니다:
 
-    ```rust
-    let user_status = Status::Active;
-    ```
+    <pre><code class="rust">let user_status = Status::Active;
+    </code></pre>
 
     열거형을 다루려면, 종종 match 표현식을 사용하며, 이를 통해 열거형 변종에 따라 다른 작업을 수행할 수 있습니다:
 
-    ```rust
-    fn print_status_message(status: Status) {
+    <pre><code class="rust">fn print_status_message(status: Status) {
         match status {
             Status::Active => println!("사용자가 활성 상태입니다."),
             Status::Inactive => println!("사용자가 비활성 상태입니다."),
@@ -318,29 +321,35 @@
         let user_status = Status::Active;
         print_status_message(user_status);
     }
-    ```
+    </code></pre>
 
     ---
 
-    ## Tuple Struct, Enum
+    **Tuple Struct, Enum**
 
 
     주로 간결한 표현, 타입 안전성 및 논리적 구조를 위해 사용됩니다.
 
+
     - 튜플 구조체 (Tuple Struct): 튜플 구조체는 필드에 이름이 없는 구조체로, 간단한 데이터 구조를 표현할 때 유용합니다. 튜플 구조체를 사용하면, 구조체의 의미를 명확하게 나타낼 수 있으며, 일반 튜플보다 더 강력한 타입 안전성을 제공합니다. 예를 들어, 두 개의 float 값을 나타내는 Point2D와 Vector2D를 구별하기 위해 튜플 구조체를 사용할 수 있습니다. 이렇게 하면 코드의 가독성과 정확성이 향상됩니다.
+
     - 열거형 (Enum): 열거형은 서로 관련된 값의 집합을 표현하기 위해 사용됩니다. 열거형은 여러 변종(variants)을 가질 수 있으며, 각 변종은 고유한 타입입니다. 열거형은 논리적으로 관련된 여러 값을 그룹화하여 코드의 명확성과 구조를 개선하는 데 도움이 됩니다. 또한 열거형은 패턴 매칭을 사용하여 값에 따라 다양한 작업을 수행할 수 있어, 런타임에 오류가 발생하는 가능성이 줄어듭니다.
+
     - 튜플 열거형 변종 (Tuple Enum Variants): 튜플 열거형 변종은 열거형의 각 변종에 데이터를 연관시키는 데 사용됩니다. 튜플 열거형 변종은 각 변종에 서로 다른 타입과 수의 값을 저장할 수 있습니다. 이러한 변종은 열거형의 다양한 경우를 명확하게 구분하고, 관련 데이터를 함께 저장하여 논리적 구조를 제공하는 데 유용합니다. 패턴 매칭을 사용하면 튜플 열거형 변종의 값을 안전하게 추출하고, 해당 값에 따라 다양한 작업을 수행할 수 있습니다.
 
-    ```rust
-    // 튜플 구조체 (Tuple Struct)
+    <pre><code class="rust">// 튜플 구조체 (Tuple Struct)
+
     struct Point3D(f32, f32, f32);
 
+
     // 열거형에 튜플 변종 (Tuple Enum Variant) 포함
+
     enum Shape {
         Circle(f32),
         Rectangle(f32, f32),
     }
 
+
     fn main() {
         let point = Point3D(1.0, 2.0, 3.0);
         let circle = Shape::Circle(5.0);
@@ -357,27 +366,29 @@
             _ => (),
         }
     }
-    ```
+    </code></pre>
 
     ---
 
-    ## Nested
+    **Nested**
 
     중첩된 Struct과 Enum을 만들고 싶다면?
 
-    ```rust
-    // 중첩된 구조체 (Nested Struct)
+    <pre><code class="rust">// 중첩된 구조체 (Nested Struct)
+
     struct Address {
         street: String,
         city: String,
     }
 
+
     struct Person {
         name: String,
         address: Address,
     }
 
     // 중첩된 열거형 (Nested Enum)
+
     enum Animal {
         Mammal {
             species: String,
@@ -389,6 +400,7 @@
         },
     }
 
+
     fn main() {
         let person = Person {
             name: String::from("지훈"),
@@ -402,7 +414,7 @@
             is_domestic: true,
         };
     }
-    ```
+    </code></pre>
 
 - title: Returning Nothing
   code: >-
-- 
GitLab