<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kasama Chenkaow on Medium]]></title>
        <description><![CDATA[Stories by Kasama Chenkaow on Medium]]></description>
        <link>https://medium.com/@kasama-chenkaow?source=rss-1b77a272a4c9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*cnqZABBadRhAHS8Y.jpg</url>
            <title>Stories by Kasama Chenkaow on Medium</title>
            <link>https://medium.com/@kasama-chenkaow?source=rss-1b77a272a4c9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 15:06:55 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kasama-chenkaow/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Forward compatible? ความเข้ากันได้ล่วงหน้า?]]></title>
            <link>https://kasama-chenkaow.medium.com/forward-compatible-%E0%B8%84%E0%B8%A7%E0%B8%B2%E0%B8%A1%E0%B9%80%E0%B8%82%E0%B9%89%E0%B8%B2%E0%B8%81%E0%B8%B1%E0%B8%99%E0%B9%84%E0%B8%94%E0%B9%89%E0%B8%A5%E0%B9%88%E0%B8%A7%E0%B8%87%E0%B8%AB%E0%B8%99%E0%B9%89%E0%B8%B2-7ea666a6007c?source=rss-1b77a272a4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/7ea666a6007c</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[forward-compatibility]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Kasama Chenkaow]]></dc:creator>
            <pubDate>Fri, 04 Apr 2025 07:26:17 GMT</pubDate>
            <atom:updated>2025-04-06T06:03:56.965Z</atom:updated>
            <content:encoded><![CDATA[<h3>Forward compatibility ความเข้ากันได้ล่วงหน้า?</h3><p>ในวงการโปรแกรมเมอร์ หลายคนน่าจะคุ้นเคยกับคำว่า <strong>backward compatibility</strong> กันอยู่แล้วไม่มากก็น้อย</p><p>แต่เคยได้ยินคำว่า <strong>forward compatibility</strong> กันบ้างไหมครับ? แล้วสงสัยไหมว่ามันคืออะไร?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vuAH7I_RsCvBrWVW" /></figure><p><strong>เริ่มจาก Backward Compatibility</strong></p><p>แนวคิดของ <strong>backward compatibility</strong> คือ การที่เราเป็น <strong>provider</strong> ของบางสิ่งที่สามารถเปลี่ยนแปลงได้ และเราการันตีว่า <strong>consumer</strong> ของเราที่ใช้งานสิ่งนั้นอยู่จะไม่ได้รับผลกระทบเมื่อเกิดการเปลี่ยนแปลงใน context ที่เราการันตี backward compatibility ไว้</p><p><strong>ตัวอย่าง:</strong><br>สมมติว่าเราทำไลบรารีชื่อ <strong>ABC</strong> แล้วปล่อยเวอร์ชัน <strong>1.0</strong> ออกไป มีคนใช้งานอยู่จำนวนหนึ่ง<br>ต่อมา เราปล่อย <strong>ABC 1.1</strong> ซึ่งอาจมีฟีเจอร์ใหม่ๆ เพิ่มเข้ามา<br>หากเราบอกว่า <strong>ABC 1.1 is backward compatible กับ ABC 1.0</strong> หมายความว่า <strong>consumer</strong> ที่ใช้งานเวอร์ชัน <strong>1.0</strong> สามารถอัปเกรดเป็น <strong>1.1</strong> ได้โดยไม่ต้องแก้ไขโค้ดเดิม และยังทำงานได้เป็นปกติ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oZP8qfbSbIC88GS3m4O0qw.png" /></figure><h4>แล้ว Forward Compatibility คืออะไร?</h4><p>จากรูปด้านบน เราจะเห็นว่า <strong>backward compatibility</strong> คือการการันตีจากฝั่ง <strong>provider</strong><br>แต่ <strong>forward compatibility</strong> คือการการันตีจากฝั่ง <strong>consumer</strong> ว่า แม้ว่า <strong>provider</strong> จะเปลี่ยนแปลงไป <strong>consumer</strong> ก็ยังสามารถทำงานต่อไปได้ใน context ที่การันตีไว้</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9bMakrsyA3TSeHI-aE_TVw.png" /></figure><p><strong>ตัวอย่าง:</strong></p><pre>const eventReducer = (event) =&gt; {<br>   switch(event.type) {<br>     case &#39;type1&#39;: {...} break; // do something<br>     case &#39;type2&#39;: {...} break; // do something<br>     default: throw new Error(&#39;unknown event&#39;)<br>   }<br>}<br><br>// somewhere that uses eventReducer<br><br>const reduce = async () =&gt; {<br>   const events = await getEventsFromProvider();<br>   <br>   events.map(eventReducer);<br>}</pre><p>โค้ดในตัวอย่างนี้ <strong>ไม่ forward compatible</strong> เพราะถ้า <strong>provider</strong> เพิ่ม <strong>event type</strong> ใหม่เข้ามา แม้ว่าเราจะสนใจแค่ type1 กับ type2 ก็ตาม โค้ดก็ยังคง break</p><p>หากต้องการให้ <strong>forward compatible</strong> สามารถแก้ไขโค้ดดังนี้:</p><pre>const eventReducer = (event) =&gt; {<br>   switch(event.type) {<br>     case &#39;type1&#39;: {...} break; // do something<br>     case &#39;type2&#39;: {...} break; // do something<br>     default: {<br>        logger.warn(`unknown event: ${event.type}`)<br>        return;<br>     }<br>   }<br>}</pre><p>อีกตัวอย่างหนึ่งที่ forward compatible</p><p>หากเรามี <strong>JSON schema</strong> ที่กำหนด &quot;additionalProperties&quot;: true หมายความว่า JSON object นั้นจะรองรับการเพิ่ม <strong>properties</strong> ใหม่ๆ ได้ (ลองนึกภาพว่าเราเป็น <strong>consumer</strong> ของ <strong>topic</strong> ในระบบ <strong>pub/sub</strong> หรือ <strong>message queue</strong>)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sl9xNa3WhEHe3u4t6uf_HA.png" /></figure><h4>สรุป</h4><p>ไม่จำเป็นว่าเราจะต้องทำให้ทุกอย่าง <strong>forward compatible</strong> เสมอไป ขึ้นอยู่กับว่าเราต้องการให้พฤติกรรมของซอฟต์แวร์หรือโปรแกรมเป็นแบบไหน</p><p>หวังว่าจะมีประโยชน์ครับ!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7ea666a6007c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[สรุป The Rust Programming Language ฉบับมือเก่า ตอนที่ 12.5]]></title>
            <link>https://kasama-chenkaow.medium.com/%E0%B8%AA%E0%B8%A3%E0%B8%B8%E0%B8%9B-the-rust-programming-language-%E0%B8%89%E0%B8%9A%E0%B8%B1%E0%B8%9A%E0%B8%A1%E0%B8%B7%E0%B8%AD%E0%B9%80%E0%B8%81%E0%B9%88%E0%B8%B2-%E0%B8%95%E0%B8%AD%E0%B8%99%E0%B8%97%E0%B8%B5%E0%B9%88-12-5-53b9a7841e48?source=rss-1b77a272a4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/53b9a7841e48</guid>
            <category><![CDATA[intermediate]]></category>
            <category><![CDATA[สรุป]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[guide]]></category>
            <category><![CDATA[rust]]></category>
            <dc:creator><![CDATA[Kasama Chenkaow]]></dc:creator>
            <pubDate>Mon, 27 Jan 2025 15:29:50 GMT</pubDate>
            <atom:updated>2025-01-27T15:29:50.178Z</atom:updated>
            <content:encoded><![CDATA[<p>บทความนี้สรุปจากหนังสือ <a href="https://doc.rust-lang.org/book/ch12-05-working-with-environment-variables.html">The Rust Programming Language chapter 12.5</a> ด้วยความคิดเห็นของผมเอง อาจมีการตีความที่มีโอกาสผิดพลาดได้ ทางที่ดีถ้าอยากได้ reference จริงๆแนะนำต้นทางครับ</p><p>(<a href="https://kasama-chenkaow.medium.com/%E0%B8%AA%E0%B8%A3%E0%B8%B8%E0%B8%9B-the-rust-programming-language-%E0%B8%89%E0%B8%9A%E0%B8%B1%E0%B8%9A%E0%B8%A1%E0%B8%B7%E0%B8%AD%E0%B9%80%E0%B8%81%E0%B9%88%E0%B8%B2-%E0%B8%95%E0%B8%AD%E0%B8%99%E0%B8%97%E0%B8%B5%E0%B9%88-12-4-e85681e10315">Link ตอนที่แล้ว</a>)</p><p>บทนี้จะเป็นเรื่องเกี่ยวกับการใช้ Environment variables ในโปรแกรมของเรา</p><h4>Working with Environment Variables</h4><p>โดยทั่วไปเราก็จะใช้ Environment variables เพื่อ control behavior ของโปรแกรมเรา</p><p>ถ้าจะเอาแบบตัดจบเลย จริงๆวิธีใช้ก็คือ</p><pre>env::var(&quot;ENV_VAR&quot;).is_ok();</pre><p>ตัว env::var จะ return Result ออกมาให้ ซึ่งแปลว่าเราสามารถใช้ is_ok() เพื่อเช็คได้ว่าตัว env var ถูก set ไหม</p><p>เอาจริงๆ core ของตอนนี้ก็แค่นี้แหล่ะ แต่ในหนังสือจะเป็นการถือโอกาสสอนแบบมีตัวอย่างไปด้วยเลย</p><p>เค้าพยายามเพิ่ม feature ให้ search แบบ case insensitive ได้, controlled by environment variable ชื่อ IGNORE_CASE</p><p>จบแล้ว 12.5</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=53b9a7841e48" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[สรุป The Rust Programming Language ฉบับมือเก่า ตอนที่ 12.4]]></title>
            <link>https://kasama-chenkaow.medium.com/%E0%B8%AA%E0%B8%A3%E0%B8%B8%E0%B8%9B-the-rust-programming-language-%E0%B8%89%E0%B8%9A%E0%B8%B1%E0%B8%9A%E0%B8%A1%E0%B8%B7%E0%B8%AD%E0%B9%80%E0%B8%81%E0%B9%88%E0%B8%B2-%E0%B8%95%E0%B8%AD%E0%B8%99%E0%B8%97%E0%B8%B5%E0%B9%88-12-4-e85681e10315?source=rss-1b77a272a4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/e85681e10315</guid>
            <category><![CDATA[rust]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[สรุป]]></category>
            <category><![CDATA[intermediate]]></category>
            <category><![CDATA[guide]]></category>
            <dc:creator><![CDATA[Kasama Chenkaow]]></dc:creator>
            <pubDate>Wed, 15 Jan 2025 15:22:26 GMT</pubDate>
            <atom:updated>2025-01-15T15:22:26.593Z</atom:updated>
            <content:encoded><![CDATA[<p>บทความนี้สรุปจากหนังสือ <a href="https://doc.rust-lang.org/book/ch12-04-testing-the-librarys-functionality.html">The Rust Programming Language chapter 12.4 </a>ด้วยความคิดเห็นของผมเอง อาจมีการตีความที่มีโอกาสผิดพลาดได้ ทางที่ดีถ้าอยากได้ reference จริงๆแนะนำต้นทางครับ</p><p>(<a href="https://doc.rust-lang.org/book/ch12-04-testing-the-librarys-functionality.html">Link ตอนที่แล้ว</a>)</p><p>บทนี้จะเป็นการสอนเขียน test แถมสอน TDD ซะด้วย 😅จากบทที่แล้วที่เรา refactor code ไปแล้วจะทำให้บทนี้การเขียน test ง่ายขึ้นเยอะ</p><p>ส่วนของ definition of TDD ขอข้ามละกัน น่าจะพอรู้ๆกันอยู่ละ red -&gt; green -&gt; clean</p><h4>Make it red</h4><p>เราสามารถเริ่มเขียน test ได้ดังนี้</p><pre>#[cfg(test)]<br>mod tests {<br>    use super::*;<br><br>    #[test]<br>    fn one_result() {<br>        let query = &quot;duct&quot;;<br>        let contents = &quot;\<br>Rust:<br>safe, fast, productive.<br>Pick three.&quot;;<br><br>        assert_eq!(vec![&quot;safe, fast, productive.&quot;], search(query, contents));<br>    }<br>}</pre><p>code ด้านบนคือเราต้องการทดสอบว่าถ้าเราหา lines ที่ matched กับ query duct เราต้องได้แถว safe, fast, productive</p><p>ซึ่งแน่นอนว่า test นี้มันต้อง fail (อย่างที่เราต้องการ) เพราะ function search เรายังไม่ได้แม้แต่ define เลย</p><p>ทีนี้เราก็ define search() ขึ้นมาแค่ให้มัน runnable ไปก่อนแบบนี้</p><pre>pub fn search&lt;&#39;a&gt;(query: &amp;str, contents: &amp;&#39;a str) -&gt; Vec&lt;&amp;&#39;a str&gt; {<br>    vec![]<br>}</pre><p>function ข้างต้นคืนค่า vec![] ซึ่งแน่นอนว่าไม่ match กับ expected result ที่เราต้องการ</p><p>ข้อสังเกตุเล็กๆคือเราต้องมี &#39;a เพื่อบอกว่า return value lifetime เป็นของ query หรือ contents กันแน่และแน่นอนว่ามันต้องเป็นของอันหลัง</p><p>Make it green</p><p>ทีนี้เราก็เริ่มมาเขียน implementation ของ search() ได้เพื่อให้ test เราเขียวได้</p><p>ซึ่งเราสามารถเขียนได้แบบนี้</p><pre>pub fn search&lt;&#39;a&gt;(query: &amp;str, contents: &amp;&#39;a str) -&gt; Vec&lt;&amp;&#39;a str&gt; {<br>    let mut results = Vec::new();<br><br>    for line in contents.lines() {<br>        if line.contains(query) {<br>            results.push(line);<br>        }<br>    }<br><br>    results<br>}</pre><p>โค้ดข้างบนทำตามนี้</p><ul><li>iterate over each line</li><li>check ว่าแต่ละ line contains query ไหม</li><li>ถ้าใช่ให้ push เข้าไปใน result vector</li><li>return result vector หลังจบ loop</li></ul><p>เท่านี้ test เราก็จะเขียวขจี</p><p>หลังจากนั้นเราก็เอา search function ไปใช้ใน run แบบนี้</p><pre>pub fn run(config: Config) -&gt; Result&lt;(), Box&lt;dyn Error&gt;&gt; {<br>    let contents = fs::read_to_string(config.file_path)?;<br><br>    for line in search(&amp;config.query, &amp;contents) {<br>        println!(&quot;{line}&quot;);<br>    }<br><br>    Ok(())<br>}</pre><p>เท่านี้เราก็ได้ minigrep มาใช้เล่นๆกันแล้ว!</p><p>ในบทนี้เค้าจะไม่ได้ทำ make it clean ที่เป็นส่วนสุดท้ายของ TDD เพราะ code มันน่าจะ simple enough หรือไม่ก็ TDD ไม่ได้เป็นใจความหลักของบทนี้ แค่เอามา demonstrate เฉยๆ</p><p>ส่วนบทหน้าเค้าจะสอนเรื่อง working with environment variables เพื่อ control behaviour ของ CLI เรา</p><p>จบแล้วครับ 12.4</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e85681e10315" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[สรุป The Rust Programming Language ฉบับมือเก่า ตอนที่ 12.3]]></title>
            <link>https://kasama-chenkaow.medium.com/%E0%B8%AA%E0%B8%A3%E0%B8%B8%E0%B8%9B-the-rust-programming-language-%E0%B8%89%E0%B8%9A%E0%B8%B1%E0%B8%9A%E0%B8%A1%E0%B8%B7%E0%B8%AD%E0%B9%80%E0%B8%81%E0%B9%88%E0%B8%B2-%E0%B8%95%E0%B8%AD%E0%B8%99%E0%B8%97%E0%B8%B5%E0%B9%88-12-3-17e6bdeb35a0?source=rss-1b77a272a4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/17e6bdeb35a0</guid>
            <category><![CDATA[guide]]></category>
            <category><![CDATA[intermediate]]></category>
            <category><![CDATA[rust]]></category>
            <category><![CDATA[สรุป]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Kasama Chenkaow]]></dc:creator>
            <pubDate>Fri, 10 Jan 2025 22:36:34 GMT</pubDate>
            <atom:updated>2025-01-11T07:58:11.341Z</atom:updated>
            <content:encoded><![CDATA[<p>บทความนี้สรุปจากหนังสือ <a href="https://doc.rust-lang.org/book/ch12-03-improving-error-handling-and-modularity.html">The Rust Programming Language chapter 12.3</a> ด้วยความคิดเห็นของผมเอง อาจมีการตีความที่มีโอกาสผิดพลาดได้ ทางที่ดีถ้าอยากได้ reference จริงๆแนะนำต้นทางครับ</p><p>(<a href="https://kasama-chenkaow.medium.com/%E0%B8%AA%E0%B8%A3%E0%B8%B8%E0%B8%9B-the-rust-programming-language-%E0%B8%89%E0%B8%9A%E0%B8%B1%E0%B8%9A%E0%B8%A1%E0%B8%B7%E0%B8%AD%E0%B9%80%E0%B8%81%E0%B9%88%E0%B8%B2-%E0%B8%95%E0%B8%AD%E0%B8%99%E0%B8%97%E0%B8%B5%E0%B9%88-12-2-fb4ba2d46d0a">Link ตอนที่แล้ว</a>)</p><p>บทนี้เอาจริงๆนะ ไม่ได้ specific กับ Rust เท่าไหร่เลย เป็นการ refactor code ตามปกติในทุกๆภาษา แต่บังเอิญว่ามาอยู่ในหนังสือของ Rust ทางหนังสือก็เลยถือโอกาส revisit พวกสิ่งที่เคยบอกไปแล้วในบทก่อนๆ รวมถึงพวก community practices/convention ไปในตัว</p><p>โดยทางหนังสือแบ่งออกเป็น 4 problems ที่ควรถูก addressed</p><ol><li>Separation of Concern — ส่วนนี้จะเป็นเกี่ยวกับการ extract functions เพื่อ serve SRP รวมไปถึงการแยกโค้ดใน binary crate และ library crate</li><li>Grouping Configuration Values — จริงๆเรื่องนี้มันก็เรื่องใกล้ๆกับข้อที่หนึ่งแหล่ะ แต่มันจะออกแนวคิดถึงพวกเรื่อง coupling หรือ cohesiveness มากกว่า</li><li>Detailed Error handling — ตรงนี้เป็นเรื่องของการ handle error ให้ละเอียดขึ้นด้วยการใช้ Result</li><li>One place for error handling — ควรมีที่ๆเดียวที่ handle error ทั้งหมด</li></ol><h4>Separation of Concern</h4><p>ใน context ของบทน้ีจะพูดถึงแนวคิดที่ว่า core logic ทั้งหมดควรไปอยู่ที่ lib.rs และ main.rs ควรจะทำหน้าที่เป็นแค่ entry point เพื่อเรียกใช้ functions ต่างๆใน lib รวมถึง handle errors ที่ lib พ่นออกมาด้วย</p><p>เค้ามีพูดถึงเรื่อง input parsing logic ที่ arguably ว่าควรอยู่ใน lib หรือ main ซึ่งเค้าก็ให้แนวคิดแบบง่ายๆคือถ้ามัน simple ก็อยู่ใน main ได้ แต่ถ้าเริ่ม complicated ก็ควรพลักไปอยู่ใน lib</p><h4>Grouping Configuration Values</h4><p>โค้ดที่เราเห็นในบทที่แล้ว อาจจะดูเหมือนโอเค แต่ถ้าเราจะเริ่มแยก function ย่อยๆออกไป แล้วเราไม่ทำ struct ไว้ group พวก configuration values เราก็ต้องค่อย pass arguments เหล่านั้นไปยัง functions ต่างๆ ซึ่งตอนนี้มันอาจจะมีแค่ 2 values แต่ลองคิดว่ามันเพิ่มเป็นซัก 4–5 values ตัว function parameters ของเราก็ยาวเหยียดแล้ว</p><p>แถมพอแต่ละ value ของ config มันกระจัดกระจาย ถ้า project เราใหญ่มากๆ มันก็ยากที่จะทำความเข้าใจว่า config ไปถูกใช้ที่ส่วนไหนบ้าง ถ้าเราแก้จะกระทบอะไร บลาๆๆ</p><p>อย่างที่เกริ่นไปด้านบนว่ามันคือปัญหาทั่วๆไปที่มือเก่าอย่างเราเจอมาตลอดนั่นแหล่ะในภาษาอื่นๆ มันคือเรื่อง coupling กับ cohesiveness นั่นเอง</p><p>เราสามารถสร้าง struct ได้ดังนี้</p><pre>struct Config {<br>    query: String,<br>    file_path: String,<br>}</pre><p>เราจะสร้าง function มา parse logic โดยรับ Config เป็น argument ก็ได้ แต่มีท่าที่สวยกว่านั้นคือเรา associate ตัว parsing function กับ Config ให้เหมือนกันว่าเป็น constructor ของ struct นั้น</p><pre>impl Config {<br>    fn build(args: &amp;[String]) -&gt; Config {<br>        if args.len() &lt; 3 {<br>            panic!(&quot;not enough arguments&quot;);<br>        }<br><br>        let query = args[1].clone();<br>        let file_path = args[2].clone();<br><br>        Config { query, file_path }<br>    }<br>}</pre><p>ทีนี้เราก็จะสามารถสร้าง Config ได้แบบนี้</p><pre>fn main() {<br>    let args: Vec&lt;String&gt; = env::args().collect();<br><br>    let config = Config::build(&amp;args);<br><br>    // --snip--<br>}</pre><h4>Detailed Error handling</h4><p>จาก Code ด้านบนจะเป็นว่าใน function build เรามี check ว่าถ้า arguments มี length น้อยกว่า 3 เราจะ panic ทันที ซึ่งเราไม่ leave any other option ให้กับ caller หรือ user ของ library เราเลย</p><p>อีกปัญหานึงก็คือในกรณีนี้ถึงแม้ว่า error message ของเรามันจะ clear enough แต่ panic macro มันดันให้ information ที่มากเกินไปนี่สิ เช่นมันพ่นออกมาด้วยว่า thread &#39;main&#39; panicked at src/main.rs:26:13: ซึ่งมันอาจจะ noisy เกินไป</p><p>เรื่องนี้แก้ง่ายๆเลยด้วยการ return Result ไปแทนแบบนี้</p><pre>impl Config {<br>    fn build(args: &amp;[String]) -&gt; Result&lt;Config, &amp;&#39;static str&gt; {<br>        if args.len() &lt; 3 {<br>            return Err(&quot;not enough arguments&quot;);<br>        }<br><br>        let query = args[1].clone();<br>        let file_path = args[2].clone();<br><br>        Ok(Config { query, file_path })<br>    }<br>}</pre><p>ทีนี้ caller ก็สามารถเลือกได้ตามใจเลยว่าจะต้มยำทำแกงอะไรกับ Err ดี เช่นสามารถ print error แล้ว exit เลยโดยไม่ต้อง panic ได้แบบนี้</p><pre>use std::process;<br><br>fn main() {<br>    let args: Vec&lt;String&gt; = env::args().collect();<br><br>    let config = Config::build(&amp;args).unwrap_or_else(|err| {<br>        println!(&quot;Problem parsing arguments: {err}&quot;);<br>        process::exit(1);<br>    });<br><br>    // --snip--</pre><h4>One place for error handling</h4><p>พอเรา move ทุกอย่างไปไว้ใน lib.rs แล้วตัว main.rs ก็จะเป็นที่ๆเดียวที่ handle errors ซึ่ง code final ก็จะราวๆนี้</p><p>src/lib.rs</p><pre>use std::error::Error;<br>use std::fs;<br><br>pub struct Config {<br>    pub query: String,<br>    pub file_path: String,<br>}<br><br>impl Config {<br>    pub fn build(args: &amp;[String]) -&gt; Result&lt;Config, &amp;&#39;static str&gt; {<br>        // --snip--<br>    }<br>}<br><br>pub fn run(config: Config) -&gt; Result&lt;(), Box&lt;dyn Error&gt;&gt; {<br>    // --snip--<br>}</pre><p>src/main.rs</p><pre>use std::env;<br>use std::process;<br><br>use minigrep::Config;<br><br>fn main() {<br>    // --snip--<br>    if let Err(e) = minigrep::run(config) {<br>        // --snip--<br>    }<br>}</pre><p>จบแล้วครับบทที่ 12.3</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=17e6bdeb35a0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[สรุป The Rust Programming Language ฉบับมือเก่า ตอนที่ 12.2]]></title>
            <link>https://kasama-chenkaow.medium.com/%E0%B8%AA%E0%B8%A3%E0%B8%B8%E0%B8%9B-the-rust-programming-language-%E0%B8%89%E0%B8%9A%E0%B8%B1%E0%B8%9A%E0%B8%A1%E0%B8%B7%E0%B8%AD%E0%B9%80%E0%B8%81%E0%B9%88%E0%B8%B2-%E0%B8%95%E0%B8%AD%E0%B8%99%E0%B8%97%E0%B8%B5%E0%B9%88-12-2-fb4ba2d46d0a?source=rss-1b77a272a4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/fb4ba2d46d0a</guid>
            <category><![CDATA[rust]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[สรุป]]></category>
            <category><![CDATA[intermediate]]></category>
            <category><![CDATA[guide]]></category>
            <dc:creator><![CDATA[Kasama Chenkaow]]></dc:creator>
            <pubDate>Thu, 02 Jan 2025 13:43:07 GMT</pubDate>
            <atom:updated>2025-01-02T13:43:49.810Z</atom:updated>
            <content:encoded><![CDATA[<p>บทความนี้สรุปจากหนังสือ <a href="https://doc.rust-lang.org/book/ch12-02-reading-a-file.html">The Rust Programming Language chapter 12.2</a> ด้วยความคิดเห็นของผมเอง อาจมีการตีความที่มีโอกาสผิดพลาดได้ ทางที่ดีถ้าอยากได้ reference จริงๆแนะนำต้นทางครับ</p><p>(<a href="http://บทความนี้สรุปจากหนังสือ The Rust Programming Language chapter 12.1 ด้วยความคิดเห็นของผมเอง อาจมีการตีความที่มีโอกาสผิดพลาดได้ ทางที่ดีถ้าอยากได้ reference จริงๆแนะนำต้นทางครับ  (Link ตอนที่แล้ว)">Link ตอนที่แล้ว</a>)</p><h4>12.2 Reading a File</h4><p>สามารถใช้ fs::read_to_string() ได้แบบนี้</p><pre>use std::env;<br>use std::fs;<br><br>fn main() {<br>    // --snip--<br>    println!(&quot;In file {file_path}&quot;);<br><br>    let contents = fs::read_to_string(file_path)<br>        .expect(&quot;Should have been able to read the file&quot;);<br><br>    println!(&quot;With text:\n{contents}&quot;);<br>}</pre><p>run แล้วได้ output ตามนี้</p><pre>$ cargo run -- the poem.txt<br>   Compiling minigrep v0.1.0 (file:///projects/minigrep)<br>    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.0s<br>     Running `target/debug/minigrep the poem.txt`<br>Searching for the<br>In file poem.txt<br>With text:<br>I&#39;m nobody! Who are you?<br>Are you nobody, too?<br>Then there&#39;s a pair of us - don&#39;t tell!<br>They&#39;d banish us, you know.<br><br>How dreary to be somebody!<br>How public, like a frog<br>To tell your name the livelong day<br>To an admiring bog!</pre><p>เค้าบอกว่าบทหน้าจะ refactor เพื่อน split มันให้กลายเป็นหลายๆ function เพื่อ SRP (single-responsibility principle) รวมไปถึง handle พวก error ต่างๆ</p><p>จบแล้ว 12.2</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fb4ba2d46d0a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[สรุป The Rust Programming Language ฉบับมือเก่า ตอนที่ 12.1]]></title>
            <link>https://kasama-chenkaow.medium.com/%E0%B8%AA%E0%B8%A3%E0%B8%B8%E0%B8%9B-the-rust-programming-language-%E0%B8%89%E0%B8%9A%E0%B8%B1%E0%B8%9A%E0%B8%A1%E0%B8%B7%E0%B8%AD%E0%B9%80%E0%B8%81%E0%B9%88%E0%B8%B2-%E0%B8%95%E0%B8%AD%E0%B8%99%E0%B8%97%E0%B8%B5%E0%B9%88-12-1-717832adae1b?source=rss-1b77a272a4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/717832adae1b</guid>
            <category><![CDATA[intermediate]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[guide]]></category>
            <category><![CDATA[rust]]></category>
            <category><![CDATA[สรุป]]></category>
            <dc:creator><![CDATA[Kasama Chenkaow]]></dc:creator>
            <pubDate>Fri, 27 Dec 2024 21:51:32 GMT</pubDate>
            <atom:updated>2024-12-27T23:26:47.168Z</atom:updated>
            <content:encoded><![CDATA[<p>บทความนี้สรุปจากหนังสือ <a href="https://doc.rust-lang.org/book/ch12-00-an-io-project.html">The Rust Programming Language chapter 12.1</a> ด้วยความคิดเห็นของผมเอง อาจมีการตีความที่มีโอกาสผิดพลาดได้ ทางที่ดีถ้าอยากได้ reference จริงๆแนะนำต้นทางครับ</p><p>(<a href="https://kasama-chenkaow.medium.com/%E0%B8%AA%E0%B8%A3%E0%B8%B8%E0%B8%9B-the-rust-programming-language-%E0%B8%89%E0%B8%9A%E0%B8%B1%E0%B8%9A%E0%B8%A1%E0%B8%B7%E0%B8%AD%E0%B9%80%E0%B8%81%E0%B9%88%E0%B8%B2-%E0%B8%95%E0%B8%AD%E0%B8%99%E0%B8%97%E0%B8%B5%E0%B9%88-11-fac4638bd41d">Link ตอนที่แล้ว</a>)</p><p>บทที่ 12 นี้จะเป็นเหมือน hands-on เผื่อทบทวนสิ่งที่เราเรียนมา โดยเค้าจะให้เขียน CLI ขึ้นมาแทน grep (เค้าบอกด้วยว่าของจริงมีแล้วชื่อ ripgrep )</p><p>ทางหนังสือแบ่งเป็น 6 บทย่อย เพราะงั้นสายขี้เกียจอย่างผมก็ขอแบ่งตามนั้นด้วยละกัน 555</p><h4>12.1 Accepting Command Line Arguments</h4><p>ถ้า CLI ของเราไม่สามารถรับ arguments ได้มันก็คงไม่ค่อยจะมีประโยชน์ซักเท่าไหร่เนอะ 😅 บทนี้ก็จะพูดถึง step ในการรับ arguments ดังนี้</p><ul><li>ตัว guinea pig เอ้ย demo นี้จะเรียกว่า minigrep</li><li>ว่าแล้วก็ cargo new minigrep</li><li>เราต้องการให้ user ใช้ tool ของเราดังนี้ minigrep [search_term] [file_name.ext]</li><li>เราสามารถใช้ std::env::args() เพื่อ access arguments ของ executable เราได้</li><li>std::env::args() จะ panic ถ้าเจอ invalid unicode ถ้าอยากปวดหัวแล้ว handle เองใช้ std::env::args_os()</li><li>std:env::args() returns iterator ซึ่งเค้าบอกจะอธิบายใน chapter 13 แต่ให้รู้ว่าถ้าเรียก .collect() จะ return vector ของ String</li><li>โดยรวมๆ code ก็จะประมาณนี้</li></ul><pre>use std::env;<br><br>fn main() {<br>    let args: Vec&lt;String&gt; = env::args().collect();<br><br>    let query = &amp;args[1];<br>    let file_path = &amp;args[2];<br><br>    println!(&quot;Searching for {query}&quot;);<br>    println!(&quot;In file {file_path}&quot;);<br>}</pre><p>รันแล้วจะได้ output ตามนี้</p><pre>$ cargo run -- test sample.txt<br>   Compiling minigrep v0.1.0 (file:///projects/minigrep)<br>    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.0s<br>     Running `target/debug/minigrep test sample.txt`<br>Searching for test<br>In file sample.txt</pre><p>จบแล้วครับบทที่ 12.1 ไว้มาต่อบทหน้าครับ</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=717832adae1b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[สรุป The Rust Programming Language ฉบับมือเก่า ตอนที่ 11]]></title>
            <link>https://kasama-chenkaow.medium.com/%E0%B8%AA%E0%B8%A3%E0%B8%B8%E0%B8%9B-the-rust-programming-language-%E0%B8%89%E0%B8%9A%E0%B8%B1%E0%B8%9A%E0%B8%A1%E0%B8%B7%E0%B8%AD%E0%B9%80%E0%B8%81%E0%B9%88%E0%B8%B2-%E0%B8%95%E0%B8%AD%E0%B8%99%E0%B8%97%E0%B8%B5%E0%B9%88-11-fac4638bd41d?source=rss-1b77a272a4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/fac4638bd41d</guid>
            <category><![CDATA[สรุป]]></category>
            <category><![CDATA[rust]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[intermediate]]></category>
            <category><![CDATA[guide]]></category>
            <dc:creator><![CDATA[Kasama Chenkaow]]></dc:creator>
            <pubDate>Mon, 23 Dec 2024 21:27:20 GMT</pubDate>
            <atom:updated>2024-12-23T21:27:20.358Z</atom:updated>
            <content:encoded><![CDATA[<p>บทความนี้สรุปจากหนังสือ <a href="https://doc.rust-lang.org/book/ch11-00-testing.html">The Rust Programming Language chapter 11</a> ด้วยความคิดเห็นของผมเอง อาจมีการตีความที่มีโอกาสผิดพลาดได้ ทางที่ดีถ้าอยากได้ reference จริงๆแนะนำต้นทางครับ</p><p>(<a href="https://medium.com/@kasama-chenkaow/%E0%B8%AA%E0%B8%A3%E0%B8%B8%E0%B8%9B-the-rust-programming-language-%E0%B8%89%E0%B8%9A%E0%B8%B1%E0%B8%9A%E0%B8%A1%E0%B8%B7%E0%B8%AD%E0%B9%80%E0%B8%81%E0%B9%88%E0%B8%B2-%E0%B8%95%E0%B8%AD%E0%B8%99%E0%B8%97%E0%B8%B5%E0%B9%88-10-3-335c9f9dafed">Link ตอนที่แล้ว</a>)</p><p>บทแรกของครึ่งหลังนี้จะเริ่มต้นด้วยการเขียน test ใน Rust ซึ่งเค้าจะเกริ่นเกี่ยวกับพื้นฐานความคิดในการ test ทั่วๆไปด้วย</p><p>แต่มือเก่าอย่างเราน่าจะมีพื้นฐานพวกนี้อยู่แล้ว (ไหมนะ? 😅) เพราะงั้นผมจะ note เป็น bullet points น่าจะง่ายกว่า</p><ul><li>Anatomy ของ test ใน Rust</li></ul><p>จะเริ่มด้วยการติด attribute#[test] ให้กับ function แล้ว Rust จะถือว่าเป็น test function พอเรารัน test ทุกๆ test functions ก็จะถูก run ใน thread ของตัวเอง โดยมี main thread เป็นตัว track execution ของแต่ละ test</p><p>ตัวอย่างโค้ดก็จะประมาณนี้</p><pre>#[cfg(test)]<br>mod tests {<br>    use super::*;<br><br>    #[test]<br>    fn test_case1() {<br>       // body<br>    }<br>}</pre><ul><li>รันได้ด้วยการสั่ง cargo test</li><li>assert ด้วย macro assert!(boolean), assert_eq!(value1, value2), assert_ne!(value1, value2)</li><li>macro ทั้ง 3 ตัวจะ panic ถ้า assertion ไม่ได้ตามที่ expect</li><li>ซึ่งถ้า test function panic ก็จะ failed (เราสามารถ manually panic เองก็ได้)</li><li>ทั้ง 3 macro ยังสามารถรับ optional custom message เป็น param ตัวสุดท้ายได้ด้วย เช่น assert!(value1, &quot;expected true but got {value1}&quot;)</li><li>ในกรณีที่เรา expect ว่า test subject ควรที่จะ panic เราสามารถใช้ attribute#[should_panic(expected = &quot;your panic messasge here&quot;)]</li><li>หรือแทนที่จะให้ผลของ test ขึ้นอยู่กับ panic เราสามารถใช้ Result&lt;T, E&gt; เป็น return type ของ test ได้แบบนี้</li></ul><pre>    #[test]<br>    fn it_works() -&gt; Result&lt;(), String&gt; {<br>        let result = add(2, 2);<br><br>        if result == 4 {<br>            Ok(())<br>        } else {<br>            Err(String::from(&quot;two plus two does not equal four&quot;))<br>        }<br>    }</pre><ul><li>ข้อดีคือเราสามารถใช้พวก question mark operator ได้ (คือ ?. ) เพราะตัว operator จะ return Err() ให้</li><li>แต่เราไม่สามารถใช้ #[should_panic] ได้แต่เราควรใช้ assert!(value.is_err()) แทน</li><li>กำหนดจำนวน threads ได้ด้วย cargo test -- --test-threads=1</li><li>ปกติ test ที่ผ่านจะไม่แสดง stdout แต่เราสามารถเปิดให้มันแสดงได้ด้วย cargo test -- --show-output</li><li>run filtered tests ได้ด้วย cargo test [path_of_the_test_name] (full test name มี test module อยู่ด้วย เพราะงั้นถ้าจะรันทั้ง module ก็ใส่แค่ module name)</li><li>ignore ได้ด้วย #[ignore]</li><li>run เฉพาะ ignored tests cargo test -- --ignored</li><li>run หมดไม่สนลูกใคร cargo test -- --include-ignored</li></ul><p>ตอนท้ายๆของบทจะพูดถึง</p><h4>Test Organization (ในมุมมองของ Rust Community)</h4><p>ในหนังสือแบ่ง test ออกเป็น 2 แบบคือ Unit Tests กับ Integration Tests</p><p>หลังจากอ่านจบ ผมมีความรู้สึกว่า Rust community มีแนวคิดเรื่องการ test คล้ายๆ mindset ที่ผมใช้เลย คือผมเขียนแค่ unit กับ integration tests เท่านั้น</p><p>แล้ววิธีการ categorize unit กับ integration ก็ยังคล้ายกันอีก แต่ของ Rust จะ specific กว่านิดนึง แต่มี note ได้เป็นข้อๆตามนี้</p><h4>Unit Tests</h4><ul><li>Unit test เป็น isolation test ส่วนใหญ่เป็นการ test ระดับการทำงานของ function ย่อยๆ</li><li>convention คือเขียน test ใน file เดียวกับ function เลย โดยใช้ attribute #[cfg(test)] เป็นตัวบอกว่า compile and run เฉพาะตอน run cargo test เพื่อที่จะไม่ไป build ตอนเรา compile code เราปกติ</li><li>ด้วยความที่ test module ประกาศใน file เดียวกันเลยนับว่าเป็น child module ซึ่งสามารถ access private functions ของ root module ได้หมด</li><li>แต่ test private function เป็น debatable ตัว Rust เองแค่บอกว่าทำได้ ถ้า ideology เราคือไม่ test private function ก็คือไม่ต้อง test</li></ul><h4>Integration Tests</h4><ul><li>Integration test ใน Rust คือการ test library ของเราเหมือนมุมมองของ user ที่จะใช้ library เรา</li><li>ไม่สามารถใช้ test binary crate ได้ (เค้าเลย recommend ให้เวลาเขียน binary project ให้เอา src/main.rs เป็นแค่ entry point แล้วเรียก core logic ใน src/lib.rs เอา จะทำให้เรา test library crate ที่เป็น logic ของเราได้)</li><li>สร้าง integration test crate ได้ใน tests/ folder</li><li>แต่ละ file ใน tests/ folder จะถือว่าเป็น individual crate</li><li>มีประเด็นเรื่อง sub module นิดนึง เพราะใน library code ปกติเราสามารถสร้าง sub module ได้ใน src เลย เช่น src/a_module.rs แล้วใน crate เราประกาศ mod a_module เป็นอันจบ แต่ถ้าเราทำแบบนั้นใน tests/ จะทำให้ a_module ถูกมองว่าเป็น integration test crate ไปด้วย</li><li>วิธีแก้ก็คือการใช้ old naming convention สำหรับ submode แบบ tests/a_module/mod.rs มาช่วย</li><li>ซึ่งการสร้าง sub module ก็อาจจะเป็นในกรณีที่เราต้องการมี common/helper code ที่ช่วยในการ setup หรือทำอะไรต่างๆใน tests</li></ul><p>จบแล้วครับบทที่ 11</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fac4638bd41d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ทำไม BTreeMap ถึงมี cache locality ที่ดีกว่า HashMap?]]></title>
            <link>https://kasama-chenkaow.medium.com/%E0%B8%97%E0%B8%B3%E0%B9%84%E0%B8%A1-btreemap-%E0%B8%96%E0%B8%B6%E0%B8%87%E0%B8%A1%E0%B8%B5-cache-locality-%E0%B8%97%E0%B8%B5%E0%B9%88%E0%B8%94%E0%B8%B5%E0%B8%81%E0%B8%A7%E0%B9%88%E0%B8%B2-hashmap-18080c163fb9?source=rss-1b77a272a4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/18080c163fb9</guid>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[hashmap]]></category>
            <category><![CDATA[cache-memory]]></category>
            <category><![CDATA[b-tree]]></category>
            <category><![CDATA[memory-improvement]]></category>
            <dc:creator><![CDATA[Kasama Chenkaow]]></dc:creator>
            <pubDate>Sun, 22 Dec 2024 22:34:25 GMT</pubDate>
            <atom:updated>2025-01-10T11:56:20.267Z</atom:updated>
            <content:encoded><![CDATA[<p>เรื่องนี้เกิดจากที่ผมไปเจอ blog นึงที่เขียนเกี่ยวกับการ optimize performance ระบบๆหนึ่ง แล้วหนึ่งในนั้นคือการที่เค้าเปลี่ยน data structure จาก HashMap เป็น BTreeMap ซึ่งผมแปลกใจนิดหน่อยเพราะปกติในหัวของผมคือ HashMap = O(1) และ BTreeMap = O(log n) (พูดถึง search time complexity) โดยเค้าบอกไว้แค่ว่าช่วย improve memory locality</p><p>ผมเลยเกิดข้อสงสัยว่ามันช่วยยังไงกันนะ เลยไปนั่งอ่านๆ รวมถึงถาม ChatGPT ไปด้วยแล้วได้ข้อสรุปมาประมาณนึงที่ผมเห็นว่าน่าสนใจดี เลยเอามาเขียน blog ซะเลย</p><h4>Memory Cache Locality คืออะไร?</h4><p>CPU มีหน่วยความจำที่เรียกว่า <strong>Cache</strong> ซึ่งทำหน้าที่เก็บข้อมูลสำคัญที่ต้องใช้บ่อยไว้ใกล้ CPU ที่สุด เพื่อลดเวลาที่เสียไปกับการดึงข้อมูลจาก RAM ปกติ (ซึ่งช้ากว่า) โดยแนวคิด <strong>cache locality</strong> หรือ <strong>memory locality</strong> ช่วยให้การดึงข้อมูลมีประสิทธิภาพมากขึ้น ซึ่งแบ่งออกเป็น 2 ประเภทหลัก:</p><ol><li><strong>Spatial Locality</strong> (ความใกล้เชิงพื้นที่):</li></ol><ul><li>การที่ข้อมูลที่เข้าถึงอยู่ติดกันในหน่วยความจำ เช่น การวนลูปในอาเรย์ จะช่วยลดการดึงข้อมูลจาก RAM หลายรอบ เพราะข้อมูลที่อยู่ใกล้ ๆ กันถูกโหลดเข้ามาใน Cache พร้อมกัน</li></ul><p><strong>2. Temporal Locality</strong> (ความใกล้เชิงเวลา):</p><ul><li>การที่ข้อมูลเดิมถูกเรียกใช้ซ้ำในช่วงเวลาสั้น ๆ เช่น ตัวแปรที่ใช้งานบ่อย ๆ จะยังคงอยู่ใน Cache ทำให้ไม่ต้องดึงจาก RAM ซ้ำ</li></ul><p>ผมลองให้ ChatGPT ช่วยเขียน analogy ไว้แบบนี้</p><ul><li><strong>Cache</strong>: เหมือนวัตถุดิบที่อยู่ใกล้มือ เช่น ขวดน้ำมันหรือเขียง</li><li><strong>Spatial Locality</strong>: การที่ทุกอย่างที่ต้องใช้ เช่น หม้อ, กระทะ, และจาน วางอยู่ในครัวเดียวกัน (ข้อมูลอยู่ใกล้กันในหน่วยความจำ)</li><li><strong>Temporal Locality</strong>: การที่คุณต้องหยิบน้ำมันใช้ซ้ำหลายครั้ง จึงวางขวดน้ำมันไว้ใกล้ตัว (ข้อมูลที่ถูกใช้งานซ้ำอยู่ใน Cache)</li></ul><p>ถ้าข้อมูลอยู่ใน Cache การประมวลผลจะเร็วขึ้นมาก แต่ถ้าข้อมูลที่ต้องการ <strong>ไม่อยู่ใน Cache</strong> ระบบต้องไปดึงจากหน่วยความจำที่ไกลกว่า เช่น RAM หรือแม้กระทั่ง Disk ซึ่งช้ากว่าหลายเท่าตัว สิ่งนี้เรียกว่า <strong>Cache Miss</strong></p><p>งั้นเรามา refresh เรื่องการเก็บข้อมูลแบบ HashMap และ BTreeMap คร่าวๆหน่อยว่ามีผลกับ cache locality ยังไง (ผมออกตัวก่อนว่าไม่ได้ลงลึก เพราะกลัวจะยาวและลึกมากๆผมก็ไม่รู้ 😅 ถ้าอยากได้แบบละเอียดจัดๆ ผมแนะนำให้ไปอ่านพวก definition เต็มๆ ส่วน implementation ก็อ่าน doc ของแต่ละภาษาเอาเลยจะดีกว่าครับ)</p><h4>HashMap</h4><p>ในชั้นแรกสุด HashMap จะเป็น Array ที่แต่ละ slot คือ bucket ที่เอาไว้เก็บ values</p><p>จากนั้นพอมีการ add (key, value) เข้ามา เราก็จะเอา key มาเข้า hash function เพื่อที่จะหาว่าจะได้อยู่ที่ bucket ไหน เสร็จแล้วก็เอา value ไปเก็บไว้ที่ bucket นั้น</p><pre>+---+---+---+---+<br>[<br>  bucket1,<br>  bucket2,<br>]<br>+---+---+---+---+</pre><p>เช่น ถ้าเราพยายาม add (“a_key”, “value”) แล้วเรา hash “a_key” ได้ index 0 เราก็จะเอา value ไปเก็บไว้ที่ bucket1</p><p>ถึงตรงนี้เราก็อาจจะคิดว่า อ้าวในเมื่อ behind the scenes ตัว data structure เป็น array มันก็น่าจะ friendly กับ cache locality สิ</p><p>ปัญหาคือ HashMap มีโอกาสเกิด collision ครับ ลองคิดว่าถ้าเราพยายาม add (“another_key”, “another_value”) แล้ว “another_key” เข้า hash function ดันได้ index 0 เหมือนกัน ทีนี้เราจะเก็บข้อมูลยังไง?</p><p>จริงๆมันมีวิธีแก้หลายวิธี (ซึ่งจะไม่พูดถึงในบทความนี้ ถ้าอยากรู้ลึกๆลอง google/llm ดูครับ) แต่เท่าที่เห็นส่วนใหญ่ก็จะปรับให้ bucket เป็น data structure อีกแบบนึง ซึ่งก็คือ linked list</p><p>แล้วตัว linked list เองจะถูกเก็บใน heap ซึ่งแปลว่าถึงแม้ว่า reference ของแต่ละ bucket ที่อยู่ใน array จะถูก cache แต่พอ dereference ออกมาแล้วอาจจะได้ address ที่ไม่ได้อยู่ใน cache ก็ได้</p><p>ข้อดีของ HashMap ที่เรารู้ๆกันคือมัน O(1) ส่วน keys ก็จะไม่ sorted (จริงๆประเด็นเรื่อง performance ของ HashMap ก็น่าสนใจ แต่ขอข้ามไปก่อน 555)</p><h4>BTreeMap</h4><p>ส่วน BTreeMap ก็ตามชื่อเลยว่าเป็นการเก็บข้อมูลแบบ balanced tree ซึ่งก็จะเก็บ values เป็น node ที่ link กันด้วย reference ของ left หรือ right</p><pre>+---+---+---+---+<br>       node1<br>     /       \<br> [left]   [right]<br>    |        |<br>  node2    node3<br>+---+---+---+---+</pre><p>พอเห็นแบบนี้ เราก็น่าจะสงสัยว่า แล้วมันดีกับ cache locality ยังไงในเมื่อแต่ละ node มันน่าจะเก็บอยู่ใน heap</p><p>คำตอบก็คือ node นึงมันไม่ได้เก็บแค่ value เดียว แต่มันจะเก็บเป็น range ของ values เช่นเก็บ values ของ key ตั้งแต่ 0–100 เป็นต้น</p><p>แปลว่า data structure ในแต่ละ node คือ array</p><p>ทีนี้พอเรา query key นึงใน 0–100 ทั้ง node ก็จะถูก cache ใน RAM</p><p>ทำให้ BTreeMap นั้น friendly กับ cache locality กว่ามากๆ</p><p>แล้วชนิดข้อมูลของ key ต้อง orderable ด้วย ทำให้สามารถ range query ได้ (HashMap ทำไม่ได้)</p><p>แน่นอนว่า drawback หลักๆคือ searching time complexity เป็น O(log n)</p><p>อีกเรื่องนึงที่น่าสนใจก็คือ แล้วถ้าตัว value จริงๆเองก็ถูกเก็บอยู่ใน heap ละ?</p><p>แบบนั้น BTreeMap ก็ไม่ช่วยเท่าไหร่ เพราะต่อให้ทั้ง node ถูกเก็บอยู่ใน cache เหมือนกัน แต่ก็เก็บแค่ references ซึ่งการจะได้ value มาต้อง dereference อีกทีนึงอยู่ดี</p><p>พูดง่ายๆก็คือ เช่นเราต้องการดึงข้อมูลของ keys ที่ 10 กับ 11 ซึ่ง reference ของ value ของทั้งคู่น่ะอยู่ใน cache เพราะถูกเก็บอยู่ใกล้กันนั่นแหล่ะ แต่พอ dereference ออกมาแล้ว address จริงๆของ value อาจจะอยู่ห่างกันคนละทิศ ซึ่งอาจจะเกิด cache miss ได้</p><p>สรุปก็คือ ถ้าเรามองเผินๆ เราอาจจะคิดว่า HashMap จะมี performance ในการ search ที่ดีกว่า BTreeMap เพราะด้วย Big O notation ที่อยู่คนละ order แต่พอเรามองลึกลงไป algorithm efficiency เพียวๆอย่างเดียวอาจจะไม่ใช่ทั้งหมด เหมือนกรณีของ cache locality ที่บางทีเราต้องดูองค์ประกอบอื่นๆร่วมด้วย</p><p>ยังไง data structure คนละแบบก็มีลักษณะเฉพาะของมัน เราก็เลือกใช้กันไป</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iS5aoL6MaeEoep6k" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=18080c163fb9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[สรุป The Rust Programming Language ฉบับมือเก่า ตอนที่ 10.3]]></title>
            <link>https://kasama-chenkaow.medium.com/%E0%B8%AA%E0%B8%A3%E0%B8%B8%E0%B8%9B-the-rust-programming-language-%E0%B8%89%E0%B8%9A%E0%B8%B1%E0%B8%9A%E0%B8%A1%E0%B8%B7%E0%B8%AD%E0%B9%80%E0%B8%81%E0%B9%88%E0%B8%B2-%E0%B8%95%E0%B8%AD%E0%B8%99%E0%B8%97%E0%B8%B5%E0%B9%88-10-3-335c9f9dafed?source=rss-1b77a272a4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/335c9f9dafed</guid>
            <category><![CDATA[guide]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[intermediate]]></category>
            <category><![CDATA[สรุป]]></category>
            <category><![CDATA[rust]]></category>
            <dc:creator><![CDATA[Kasama Chenkaow]]></dc:creator>
            <pubDate>Thu, 19 Dec 2024 20:32:07 GMT</pubDate>
            <atom:updated>2024-12-20T06:42:59.808Z</atom:updated>
            <content:encoded><![CDATA[<p>บทความนี้สรุปจากหนังสือ <a href="https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html">The Rust Programming Language chapter 10.3</a> ด้วยความคิดเห็นของผมเอง อาจมีการตีความที่มีโอกาสผิดพลาดได้ ทางที่ดีถ้าอยากได้ reference จริงๆแนะนำต้นทางครับ</p><p>(<a href="https://kasama-chenkaow.medium.com/%E0%B8%AA%E0%B8%A3%E0%B8%B8%E0%B8%9B-the-rust-programming-language-%E0%B8%89%E0%B8%9A%E0%B8%B1%E0%B8%9A%E0%B8%A1%E0%B8%B7%E0%B8%AD%E0%B9%80%E0%B8%81%E0%B9%88%E0%B8%B2-%E0%B8%95%E0%B8%AD%E0%B8%99%E0%B8%97%E0%B8%B5%E0%B9%88-10-2-a76cb3cb01a8">Link ตอนที่แล้ว</a>)</p><h4>10.3 Validating References with Lifetimes</h4><p>เรื่อง lifetimes นี้เป็นเรื่องใหม่พอสมควร เอาจริงๆผมเองยังไม่เคยเจอ concept นี้ในภาษาอื่นมาก่อน แต่ก็อาจจะเพราะ safe memory management เป็น key feature นึงของ Rust ละมั้ง ซึ่งเรื่อง Lifetimes เองก็เกี่ยวกับเรื่องนี้นั่นแหล่ะ</p><p>ให้อธิบายสั้นๆ lifetimes ก็เป็น type รูปแบบนึง แต่ type นี้แทนที่จะใช้บอก data structure หรือ behavioral structure มันกลับเป็นตัวบอก property นึงของ reference ว่า lifetime scope ของมันคืออะไร (พูดอย่างง่ายก็คือ value ที่ไปยืมเค้ามา จะโดน pop ออกจาก stack จนทำให้ reference ไม่ valid เมื่อไหร่)</p><p>และด้วยความที่มันเป็น type มันก็เลยไม่ได้เป็นตัวกำหนด lifetime จริงๆ ของ reference นั้นใน runtime แต่เป็น annotation ที่ช่วยบอก compiler มากกว่าว่า lifetime คืออะไร (แบบเดียวกับ type อื่นๆ คือมันไม่ได้เปลี่ยนแปลงอะไรที่ runtime แต่เป็นตัวช่วยใน compile time มากกว่า)</p><blockquote>เรื่องนึงที่น่าจำก็คือ `ทุก reference จะต้องมี lifetime กำกับ` (แต่จะ implicitly หรือ explicitly นั้นอีกเรื่อง)</blockquote><p>เพราะว่า Borrow Checker จะต้องรู้ว่า lifetime ของ reference เรามันอายุไม่เกินอายุของตัวต้นฉบับที่เราไปยืมมา</p><p>ยกตัวอย่างเช่น code ด้านล่างนี้ (copy มาจาก code ในหนังสือเลย 555)</p><pre>fn main() {<br>    let r;                // ---------+-- &#39;a<br>                          //          |<br>    {                     //          |<br>        let x = 5;        // -+-- &#39;b  |<br>        r = &amp;x;           //  |       |<br>    }                     // -+       |<br>                          //          |<br>    println!(&quot;r: {r}&quot;);   //          |<br>}                         // ---------+</pre><p>อย่างที่เห็นว่าค่าต้นฉบับมัน let x = 5 มันมี lifetime อยู่แค่ &#39;b scope แต่คนที่ยืม r = &amp;x; กลับมี lifetime อยู่ที่ &#39;a scope ที่อายุนานกว่า &#39;b scope (ซึ่ง code ด้านบนก็จะได้ compile error มา)</p><p>ในขณะที่โค้ดนี้</p><pre>fn main() {<br>    let x = 5;            // ----------+-- &#39;b<br>                          //           |<br>    let r = &amp;x;           // --+-- &#39;a  |<br>                          //   |       |<br>    println!(&quot;r: {r}&quot;);   //   |       |<br>                          // --+       |<br>}                         // ----------+</pre><p>คราวนี้ let r = &amp;x อยู่ที่ &#39;a scope ที่จะถูก pop ของจาก stack เร็วกว่าตัว let x = 5; ก็เลยใช้ได้</p><p>แต่จะเห็นว่าตัวอย่างข้างบน เราไม่จำเป็นต้องมี lifetime annotation กำกับเพราะ compiler สามารถ infer เอาได้ไม่ยาก แต่บางกรณี compiler เองก็ยังไม่ฉลาดพอที่จะอนุมาน lifetime ของ references ทั้งหมด เราเลยจะต้องกำกับด้วย annotation</p><pre>fn longest(x: &amp;str, y: &amp;str) -&gt; &amp;str {<br>    if x.len() &gt; y.len() {<br>        x<br>    } else {<br>        y<br>    }<br>}</pre><p>เช่น code ด้านบนนี้ compiler รู้ lifetime ของ x: &amp;str และ y: &amp;str นะ แต่เค้าไม่รู้ว่า lifetime ของ return type -&gt; &amp;str คืออะไร (เอาจริงๆผมแอบรู้สึกว่าเคสแบบนี้ compiler ควรจะสามารถ infer ได้ เพราะมีการ return ทั้ง x และ y ไม่น่าจะต้องให้เรากำหนด annotation เอง ในหนังสือเค้าบอกว่า compiler จะค่อยๆฉลาดขึ้น แล้วจะสามารถ infer ได้เยอะขึ้นเรื่อยๆไปเอง)</p><p>โอเคงั้น case นี้เราก็ต้องใส่ lifetime annotation ไปด้วยแบบนี้</p><pre>fn longest&lt;&#39;a&gt;(x: &amp;&#39;a str, y: &amp;&#39;a str) -&gt; &amp;&#39;a str {<br>    if x.len() &gt; y.len() {<br>        x<br>    } else {<br>        y<br>    }<br>}</pre><p>สิ่งที่เพิ่มขึ้นมาก็คือ generic lifetime type param &lt;’a&gt; นั่นเอง คราวนี้ compiler รู้แล้วว่าจะต้องเอา lifetime ที่สั้นที่สุดระหว่าง x และ y มาเป็น lifetime ของ output</p><pre>fn main() {<br>    let string1 = String::from(&quot;long string is long&quot;);<br>    let result;<br>    {<br>        let string2 = String::from(&quot;xyz&quot;);<br>        result = longest(string1.as_str(), string2.as_str());<br>    }<br>    println!(&quot;The longest string is {result}&quot;);<br>}</pre><p>code ด้านบนนี้จะไม่ compiled เพราะ lifetime ของ result ที่ได้จาก longest() จะเป็น lifetime ของ string2 เพราะเป็น lifetime ที่สั้นที่สุดระหว่าง string1 และ string2 ถึงแม้ว่าเราจะเห็นอยู่ทนโท่ว่า reference ที่ return มามันเป็นของ string1 เพราะมันเป็น hardcoded string literal ที่ใน runtime มันควรจะรันผ่าน แต่อย่างที่บอกว่าในเมื่อ lifetime มันก็คือ type แบบนึงมันก็เลยจะถูก verify ที่ compile time มันก็เลบไม่สนว่าตอน rumtime จะเป็นยังไง</p><p>และแน่นอนในเมื่อ lifetime เป็น type มันเลยสามารถไปอยู่ใน generic type param ของ struct ได้ด้วยแบบนี้</p><pre>struct ImportantExcerpt&lt;&#39;a&gt; {<br>    part: &amp;&#39;a str,<br>}</pre><h4>Lifetime Elision</h4><p>เรื่องนี้คือ rules ที่ compiler จะ follow เพื่อ analyze lifetime relationship ทั้งหมดของเรา พูดแบบ overly simplified ก็คือมันเป็นกฎที่ถ้า code ของเราเข้ากันได้กับกฎพวกนี้เป๊ะๆ compiler มันก็จะแอบเติม lifetime ให้เราเองโดยที่เราไม่ต้องไปใส่ annotation ให้วุ่นวาย</p><p>กฎ lifetime elision ตอนนี้มี 3 ข้อ</p><ol><li><em>ทุกๆ function parameter จะถูก compiler assign lifetime ให้อัตโนมัติ</em></li></ol><p>เช่นสมมติ function ของเราคือ fn foo(x: &amp;i32, y: &amp;i32) แบบนี้ compiler จะแอบเติมให้เป็นfn foo&lt;&#39;a, &#39;b&gt;(x: &amp;&#39;a i32, y: &amp;&#39;b i32)</p><p>2. <em>ถ้า parameter มีแค่ตัวเดียว lifetime ของ paramter นั้นจะถูก assigned ให้เป็น lifetime ของ output ทั้งหมด</em></p><p>เช่น fn foo(x: &amp;i32) -&gt; &amp;i32 ด้านกฎข้อแรก compiler จะเติม lifetime ของ x: &amp;i32 ให้ และด้วยกฎข้อนี้จะทำให้ output ถูกเติม lifetime ไปด้วยเป็น fn foo&lt;&#39;a&gt;(x: &amp;&#39;a i32) -&gt; &amp;&#39;a i32</p><p>3. <em>ถ้า parameter มีหลายตัว (มากกว่า 1) และ หนึ่งในนั้นคือ </em><em>&amp;self (หรือ </em><em>&amp;mut self) compiler จะ assign lifetime ของมันให้กับ output ทั้งหมด</em></p><p>ข้อนี้คนอาจจะสงสัยว่า อ่าวแล้วถ้ามีแค่ parameter เดียวอย่าง func(&amp;self) -&gt; i32 แบบนี้ compiler จะไม่เติมให้หรอ</p><p>คำตอบคือเค้าแอบเติมให้ครับ เพราะไปตกข้อ 1 กับ 2</p><p>ทีนี้ถ้า compile run through กฎ 3 ข้อด้านบนแล้ว ยังมี references ที่ยังไม่สามารถกำหนด lifetime ที่ชัดเจนได้ เค้าก็จะพ่น error ออกมาให้เราไปใส่ annotation ให้เอง</p><h4>The Static Lifetime</h4><p>อันนี้ง่าย มันคือการกำหนดให้ reference นั้นๆมี lifetime จนถึง program exit 😅</p><pre>let s: &amp;&#39;static str = &quot;I have a static lifetime.&quot;;</pre><p>ซึ่งไม่ควรเอามาใช้ยกเว้นจำเป็นจริงๆ (string literals ทุกตัวจะมี lifetime เป็น &#39;static โดยที่เราไม่ต้องไปใส่ให้มัน)</p><p>บทนี้เป็นบทสุดท้ายของ chapter 10 แล้ว ทีนี้ถ้าเราเอาของใน chapter นี้มายำรวมกันก็จะได้ code ประมาณนี้</p><pre>use std::fmt::Display;<br><br>fn longest_with_an_announcement&lt;&#39;a, T&gt;(<br>    x: &amp;&#39;a str,<br>    y: &amp;&#39;a str,<br>    ann: T,<br>) -&gt; &amp;&#39;a str<br>where<br>    T: Display,<br>{<br>    println!(&quot;Announcement! {ann}&quot;);<br>    if x.len() &gt; y.len() {<br>        x<br>    } else {<br>        y<br>    }<br>}</pre><p>function longest_with_an_announcement รับ parameters x, y, ann โดยที่ lifetime ของ output จะเป็น shortest lifetime ระหว่าง string slicex และ y ส่วน ann คืออะไรก็ได้ที่ implement Display trait</p><p>จบแล้วครับบทที่ 10</p><p>ขอแอบปาดเหงื่อหน่อยครับ ในที่สุดก็ผ่านไปแล้วครึ่งทาง ผมรู้สึกว่าอ่านถึงตรงนี้ เราน่าจะพออ่านและเขียน code Rust ได้พอควรแล้ว เพราะน่าจะ cover basic concepts เกือบทั้งหมด</p><p>เท่าที่ผมแอบ peek ดูหัวข้อครึ่งหลัง ดูเหมือนจะเป็นพวก nice to know ซะมากกว่า แต่ผมอาจจะเดาผิดก็ได้</p><p>เจอกันใหม่บทหน้าครับ</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=335c9f9dafed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[สรุป The Rust Programming Language ฉบับมือเก่า ตอนที่ 10.2]]></title>
            <link>https://kasama-chenkaow.medium.com/%E0%B8%AA%E0%B8%A3%E0%B8%B8%E0%B8%9B-the-rust-programming-language-%E0%B8%89%E0%B8%9A%E0%B8%B1%E0%B8%9A%E0%B8%A1%E0%B8%B7%E0%B8%AD%E0%B9%80%E0%B8%81%E0%B9%88%E0%B8%B2-%E0%B8%95%E0%B8%AD%E0%B8%99%E0%B8%97%E0%B8%B5%E0%B9%88-10-2-a76cb3cb01a8?source=rss-1b77a272a4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/a76cb3cb01a8</guid>
            <category><![CDATA[สรุป]]></category>
            <category><![CDATA[gui̇de]]></category>
            <category><![CDATA[rust]]></category>
            <category><![CDATA[intermediate]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Kasama Chenkaow]]></dc:creator>
            <pubDate>Tue, 17 Dec 2024 20:43:53 GMT</pubDate>
            <atom:updated>2024-12-17T20:43:53.522Z</atom:updated>
            <content:encoded><![CDATA[<p>บทความนี้สรุปจากหนังสือ <a href="https://doc.rust-lang.org/book/ch10-02-traits.html">The Rust Programming Language chapter 10.2</a> ด้วยความคิดเห็นของผมเอง อาจมีการตีความที่มีโอกาสผิดพลาดได้ ทางที่ดีถ้าอยากได้ reference จริงๆแนะนำต้นทางครับ</p><p>(<a href="https://kasama-chenkaow.medium.com/%E0%B8%AA%E0%B8%A3%E0%B8%B8%E0%B8%9B-the-rust-programming-language-%E0%B8%89%E0%B8%9A%E0%B8%B1%E0%B8%9A%E0%B8%A1%E0%B8%B7%E0%B8%AD%E0%B9%80%E0%B8%81%E0%B9%88%E0%B8%B2-%E0%B8%95%E0%B8%AD%E0%B8%99%E0%B8%97%E0%B8%B5%E0%B9%88-10-1-3ebdae57bdfe">Link ตอนที่แล้ว</a>)</p><h4>Traits: Defining Shared Behavior</h4><p>บทที่ 10.2 นี้เป็นเรื่อง traits ที่ผมเองก็มีภาพในหัวของมันมาก่อนอ่านแล้วล่ะ เพราะก็คุ้นเคยกับ pattern แนวนี้มาพอสมควร ครั้งแรกที่เห็นคำนี้ใน Rust ผมก็นึกถึง traits ใน scala ที่ผมคิดว่าก็คงจะไม่ต่างกันมากนัก (ในเชิง concept)</p><p>ผมสรุปได้ตามนี้แล้วกัน</p><ul><li>traits จะคล้ายๆ interfaces ในภาษา OOP แต่จะไม่เชิงเหมือนซะทีเดียว</li><li>ผมคิดว่ามือเก่าหลายๆคนน่าจะคุ้นกับ interfaces กันอยู่แล้ว งั้นผมขอสรุปแบบสั้นๆ (ซึ่งไม่ถูก 100%) ว่ามันคือ interface ที่สามารถมี default implementation ได้ก็แล้วกัน 555 (ซึ่งจริงๆ interface บางภาษาก็ทำอย่างนั้นได้อยู่แล้ว)</li><li>define trait ง่ายมาก</li></ul><pre>pub trait TraitName {<br>    fn a_method(&amp;self) -&gt; String;<br>}</pre><ul><li>แล้วก็ implement trait ให้กับ type ใดๆได้ง่ายเหมือนกัน</li></ul><pre>impl TraitName for AType {<br>    fn a_method(&amp;self) -&gt; String {<br>        // body<br>    }<br>}</pre><ul><li>สามารถ define with default implementation ได้</li></ul><pre>pub trait TraitName {<br>    fn a_method(&amp;self) -&gt; String {<br>        // defuaul code<br>    }<br>}</pre><ul><li>ตอนรับเป็น param ใน function ก็ทำได้แบบนี้</li></ul><pre>pub fn a_func(item: &amp;impl TraitName) {}</pre><ul><li>หรือจะใช้เป็น constraint สำหรับ generic type param ก็ได้ (Rust เรียกว่า Trait Bound Syntax)</li></ul><pre>pub fn a_func&lt;T: TraitName&gt;(item: &amp;T) {}</pre><ul><li>อยากใส่ constraints มากกว่า 1 trait ก็สามารถใช้ + operator ได้ง่ายๆเลย</li></ul><pre>pub fn a_func(item: &amp;(impl TraitName + TraitName2)) {}<br><br>// หรือแบบ Trait Bound<br><br>pub fn a_func&lt;T: TraitName + TraitName2&gt;(item: &amp;T) {}</pre><ul><li>มีอีก alternative way คือการใช้ where clauses เพื่อ readability ในกรณีที่ตัว trait bounds เริ่มเยอะ</li></ul><pre>fn a_func&lt;T, U&gt;(t: &amp;T, u: &amp;U) -&gt; i32<br>where<br>    T: Display + Clone,<br>    U: Clone + Debug,<br>{</pre><ul><li>แน่นอนว่าใช้ใน return type ก็ได้</li></ul><pre>fn a_func() -&gt; impl TraitName {}</pre><ul><li>อีกเรื่องที่น่าสนใจ ถ้ายังจำกันได้ตอนเรา associate function ให้กับ type เช่น Pair&lt;T&gt; สมมติเราบอกว่า impl Pair&lt;i32&gt; แบบนี้ method ในนั้นก็จะ available แค่กับ Pair&lt;i32&gt; เท่านั้น เพราะเรา narrow down type ลงไปตรงนั้นแล้ว</li><li>ทีนี้เราสามารถใช้ Trait มาช่วย narrow down ได้เหมือนกัน</li></ul><pre><br>struct Pair&lt;T&gt; {<br>    x: T,<br>    y: T,<br>}<br><br>impl&lt;T: TraitName&gt; Pair&lt;T&gt; {<br>    fn a_func(&amp;self) -&gt; Self {<br>        //<br>    }<br>}</pre><ul><li>ในกรณีนี้ a_func ก็จะ available แค่ Pair&lt;T&gt; ถ้า T implements TraitName เท่านั้น</li><li>หรือเราจะใช้ narrow down type ที่เราจะ implement trait ก็ยังได้!</li></ul><pre>impl&lt;T: AnotherTrait&gt; TraitName for T {<br>    fn a_method(&amp;self) -&gt; String {<br>        // body<br>    }<br>}</pre><ul><li>แบบนี้ code ข้างบนก็จะ implement TraitName ให้กับทุกๆ type ที่ implement AnotherTrait :)</li></ul><p>จบแล้วครับ 10.2</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a76cb3cb01a8" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>