diff --git a/_config.yml b/_config.yml
index b04fd8d4bd..b10d6d2d5d 100644
--- a/_config.yml
+++ b/_config.yml
@@ -69,6 +69,9 @@ collections:
fr: # French translations
output: true
permalink: /:collection/:path.html
+ th: # Thai translations
+ output: true
+ permalink: /:collection/:path.html
defaults:
-
diff --git a/_data/languages.yml b/_data/languages.yml
index 04f691d9d7..c299b1212a 100644
--- a/_data/languages.yml
+++ b/_data/languages.yml
@@ -87,3 +87,6 @@ uk:
"zh-tw":
name: "中文 (繁體)"
+
+th:
+ name: "ภาษาไทย"
diff --git a/_data/translations.yml b/_data/translations.yml
index 900441d0f0..3641a04203 100644
--- a/_data/translations.yml
+++ b/_data/translations.yml
@@ -1,2 +1,2 @@
tour:
- languages: [ba, es, ko, pt-br, pl, zh-cn]
+ languages: [ba, es, ko, pt-br, pl, zh-cn, th]
diff --git a/_overviews/cheatsheets/index.md b/_overviews/cheatsheets/index.md
index 989e6af690..aa27d9e403 100644
--- a/_overviews/cheatsheets/index.md
+++ b/_overviews/cheatsheets/index.md
@@ -7,7 +7,7 @@ partof: cheatsheet
by: Brendan O'Connor
about: Thanks to Brendan O'Connor, this cheatsheet aims to be a quick reference of Scala syntactic constructions. Licensed by Brendan O'Connor under a CC-BY-SA 3.0 license.
-languages: [ba, fr, ja, pl, pt-br, zh-cn]
+languages: [ba, fr, ja, pl, pt-br, zh-cn, th]
permalink: /cheatsheets/index.html
---
diff --git a/_th/cheatsheets/index.md b/_th/cheatsheets/index.md
new file mode 100644
index 0000000000..0b2faca68b
--- /dev/null
+++ b/_th/cheatsheets/index.md
@@ -0,0 +1,90 @@
+---
+layout: cheatsheet
+title: Scalacheat
+
+partof: cheatsheet
+
+by: Brendan O'Connor
+about: ขอบคุณ Brendan O'Connor, สำหรับ cheatsheet นี้มีวัตถุประสงค์เพื่ออ้างอิงอย่างง่ายสำหรับโครงสร้างประโยคของ Scala, Licensed by Brendan O'Connor under a CC-BY-SA 3.0 license.
+
+language: "th"
+---
+
+###### Contributed by {{ page.by }}
+
+{{ page.about }}
+
+| ตัวแปร | |
+| `var x = 5` | ค่าตัวแปร |
+| Good
`val x = 5`
Bad
`x=6` | ค่าคงที่ |
+| `var x: Double = 5` | type ที่ชัดเจน |
+| ฟังก์ชัน | |
+| Good
`def f(x: Int) = { x*x }`
Bad
`def f(x: Int) { x*x }` | กำหนดฟังก์ชัน
ซ้อนความผิดพลาด : ไม่มีการ return Unit ของฟังก์ชัน;
เป็นสาเหตุให้เกิดข้อผิดพลาดได้ |
+| Good
`def f(x: Any) = println(x)`
Bad
`def f(x) = println(x)` | กำหนดฟังก์ชัน
ไวยกรณ์ผิดพลาด : จำเป็นต้องกำหนดค่าสำหรับทุกๆ arg |
+| `type R = Double` | นามแฝงของ type |
+| `def f(x: R)` vs.
`def f(x: => R)` | call-by-value
call-by-name (lazy parameters) |
+| `(x:R) => x*x` | ฟังก์ชันที่ไม่ระบุชื่อ |
+| `(1 to 5).map(_*2)` vs.
`(1 to 5).reduceLeft( _+_ )` | ฟังก์ชันที่ไม่ระบุชื่อ : ตำแหน่งของขีดล่างตรงกับตำแหน่งของ arg |
+| `(1 to 5).map( x => x*x )` | ฟังก์ชันที่ไม่ระบุชื่อ : เพื่อใช้ arg สองครั้งต้องตั้งชื่อ |
+| Good
`(1 to 5).map(2*)`
Bad
`(1 to 5).map(*2)` | ฟังก์ชันที่ไม่ระบุชื่อ : เชื่อม infix method ใช้ `2*_`. แทน |
+| `(1 to 5).map { x => val y=x*2; println(y); y }` | ฟังก์ชันที่ไม่ระบุชื่อ : block style จะ return ส่วนสุดท้าย |
+| `(1 to 5) filter {_%2 == 0} map {_*2}` | ฟังก์ชันที่ไม่ระบุชื่อ : pipeline style. (หรือวงเล็บด้วย). |
+| `def compose(g:R=>R, h:R=>R) = (x:R) => g(h(x))`
`val f = compose({_*2}, {_-1})` | ฟังก์ชันที่ไม่ระบุชื่อ : เพื่อส่งค่าหลาย block จะต้องใส่วงเล็บด้านนอก |
+| `val zscore = (mean:R, sd:R) => (x:R) => (x-mean)/sd` | currying, ไวยกรณ์ที่ชัดเจน |
+| `def zscore(mean:R, sd:R) = (x:R) => (x-mean)/sd` | currying, ไวยกรณ์ที่ชัดเจน |
+| `def zscore(mean:R, sd:R)(x:R) = (x-mean)/sd` | currying, ไวยกรณ์ sugar, แต่ในกรณีนี้ |
+| `val normer = zscore(7, 0.4) _` | จะต้องต่อท้ายด้วยขีดล่างเพื่อเอาบางส่วน, เวอร์ชัน sugar เท่านั้น |
+| `def mapmake[T](g:T=>T)(seq: List[T]) = seq.map(g)` | type ทั่วไป |
+| `5.+(3); 5 + 3`
`(1 to 5) map (_*2)` | ฝัง sugar |
+| `def sum(args: Int*) = args.reduceLeft(_+_)` | ตัวแปรที่มีความยาว |
+| แพคเกจ | |
+| `import scala.collection._` | import ทั้งหมด |
+| `import scala.collection.Vector`
`import scala.collection.{Vector, Sequence}` | เลือก import |
+| `import scala.collection.{Vector => Vec28}` | เปลี่ยนชื่อ import |
+| `import java.util.{Date => _, _}` | import ทั้งหมดจาก java.util ยกเว้น Date |
+| `package pkg` ที่เริ่มต้นของไฟล์
`package pkg { ... }` | ประกาศแพคเกจ |
+| โครงสร้างข้อมูล | |
+| `(1,2,3)` | การเขียน tuple |
+| `var (x,y,z) = (1,2,3)` | การผูกโครงสร้างข้อมูลใหม่ : ด้วยรูปแบบการจับคู่ |
+| Bad
`var x,y,z = (1,2,3)` | ซ้อนความผิดพลาด : เป็นการแทนค่าทั้ง tuple |
+| `var xs = List(1,2,3)` | list (แก้ไขไม่ได้) |
+| `xs(2)` | ระบุตำแหน่งด้วยวงเล็บ |
+| `1 :: List(2,3)` | |
+| `1 to 5` _เหมือนกับ_ `1 until 6`
`1 to 10 by 2` | ระยะ sugar |
+| `()` _(วงเล็บว่าง)_ | สมาชิกเดียวของ Unit type (เหมือน void ใน C++/Java) |
+| โครงสร้างควบคุม | |
+| `if (check) happy else sad` | เงื่อนไข |
+| `if (check) happy` _เหมือนกับ_
`if (check) happy else ()` | เงื่อนไข sugar |
+| `while (x < 5) { println(x); x += 1}` | ทำซ้ำ while |
+| `do { println(x); x += 1} while (x < 5)` | ทำซ้ำ do while |
+| `import scala.util.control.Breaks._`
`breakable {`
` for (x <- xs) {`
` if (Math.random < 0.1) break`
` }`
`}`| หยุด [(slides)](http://www.slideshare.net/Odersky/fosdem-2009-1013261/21) |
+| `for (x <- xs if x%2 == 0) yield x*10`
_เหมือนกับ_
`xs.filter(_%2 == 0).map(_*10)` | ทำความเข้าใจ for : filter/map |
+| `for ((x,y) <- xs zip ys) yield x*y`
_เหมือนกับ_
`(xs zip ys) map { case (x,y) => x*y }` | ทำความเข้าใจ for : การเชื่อมโยงโครงสร้างใหม่ |
+| `for (x <- xs; y <- ys) yield x*y`
_เหมือนกับ_
`xs flatMap {x => ys map {y => x*y}}` | ทำความเข้าใจ for : ข้ามผลคูณ |
+| `for (x <- xs; y <- ys) {`
`println("%d/%d = %.1f".format(x, y, x/y.toFloat))`
`}` | ทำความเข้าใจ for : คำอธิบายประเภทจำเป็น [sprintf-style](http://java.sun.com/javase/6/docs/api/java/util/Formatter.html#syntax) |
+| `for (i <- 1 to 5) {`
`println(i)`
`}` | ทำความเข้าใจ for : ทำซ้ำโดยรวมขอบเขตบน |
+| `for (i <- 1 until 5) {`
`println(i)`
`}` | ทำความเข้าใจ for : ทำซ้ำโดยละเว้นขอบเขตบน |
+| จับคู่รูปแบบ | |
+| Good
`(xs zip ys) map { case (x,y) => x*y }`
Bad
`(xs zip ys) map( (x,y) => x*y )` | ใช้ case ใน arg ของฟังก์ชันสำหรับ จับคู่รูปแบบ (pattern maching) |
+| Bad
`val v42 = 42`
`Some(3) match {`
` case Some(v42) => println("42")`
` case _ => println("Not 42")`
`}` | "v42" ถูกตีความว่าเป็นชื่อที่ตรงกับค่า Int และพิมพ์ "42" |
+| Good
`val v42 = 42`
`Some(3) match {`
`` case Some(`v42`) => println("42")``
`case _ => println("Not 42")`
`}` | "v42" กับ backticks ถูกตีความว่าเป็น v42 val ที่มีอยู่และ
พิมพ์ "Not 42" |
+| Good
`val UppercaseVal = 42`
`Some(3) match {`
` case Some(UppercaseVal) => println("42")`
` case _ => println("Not 42")`
`}` | UppercaseVal ถือว่าเป็น val ที่มีอยู่ไม่ใช่ตัวแปรรูปแบบใหม่
เพราะมันเริ่มต้นด้วยตัวอักษรตัวพิมพ์ใหญ่ ดังนั้นค่าที่มีอยู่ใน
UppercaseVal จะถูกตรวจสอบเทียบกับ 3 และพิมพ์ "Not 42" |
+| การใช้งาน object | |
+| `class C(x: R)` _เหมือนกับ_
`class C(private val x: R)`
`var c = new C(4)` | ตัวสร้างพารามิเตอร์ - x มีเฉพาะในคลาส body เท่านั้น |
+| `class C(val x: R)`
`var c = new C(4)`
`c.x` | ตัวสร้างพารามิเตอร์ - กำหนดสมาชิกสาธารณะโดยอัตโนมัติ |
+| `class C(var x: R) {`
`assert(x > 0, "positive please")`
`var y = x`
`val readonly = 5`
`private var secret = 1`
`def this = this(42)`
`}`| ตัวสร้างเป็นคลาส body
ประกาศเป็นสมาชิกสาธารณะ
ประกาศสมาชิก get ค่าได้ แต่ set ค่าไม่ได้
ประกาศเป็นสมาชิกส่วนตัว
ตัวสร้างอื่นๆ |
+| `new{ ... }` | คลาสที่ไม่ระบุตัวตน |
+| `abstract class D { ... }` | กำหนดคลาสนามธรรม (ไม่สามารถสร้างได้) |
+| `class C extends D { ... }` | กำหนดคลาสที่สืบทอดมา |
+| `class D(var x: R)`
`class C(x: R) extends D(x)` | การสืบทอดและตัวสร้างพารามิเตอร์ (สิ่งที่อยากได้:
โดยอัตโนมัติจะส่งพารามิเตอร์ขึ้นโดยอัตโนมัติ) |
+| `object O extends D { ... }` | กำหนด singleton (เหมือนโมดูล) |
+| `trait T { ... }`
`class C extends T { ... }`
`class C extends D with T { ... }` | traits
อินเตอร์เฟซที่มีการดำเนินการ ไม่มีพารามิเตอร์ของตัวสร้าง mixin-able |
+| `trait T1; trait T2`
`class C extends T1 with T2`
`class C extends D with T1 with T2` | หลาย traits |
+| `class C extends D { override def f = ...}` | ต้องประกาศ method override |
+| `new java.io.File("f")` | สร้าง object |
+| Bad
`new List[Int]`
Good
`List(1,2,3)` | ชนิดความผิดพลาด: ชนิดนามธรรม
แทนที่, ธรรมเนียม: factory ที่เรียกได้เงาสะท้อนของ type |
+| `classOf[String]` | ดูข้อมูลของคลาส |
+| `x.isInstanceOf[String]` | เช็ค type (ขณะ runtime) |
+| `x.asInstanceOf[String]` | แปลง type (ขณะ runtime) |
+| `x: String` | ascription (ขณะ compile time) |
+
diff --git a/_th/tour/tour-of-scala.md b/_th/tour/tour-of-scala.md
new file mode 100644
index 0000000000..592e77b4b4
--- /dev/null
+++ b/_th/tour/tour-of-scala.md
@@ -0,0 +1,63 @@
+---
+layout: tour
+title: บทนำ
+
+discourse: false
+
+partof: scala-tour
+
+num: 1
+
+language: th
+
+next-page: basics
+---
+
+## ยินดีต้อนรับสู่การเดินทาง
+การเดินทางครั้งนี้ประกอบด้วยการแนะนำแบบสั้นๆ สำหรับแต่ล่ะคุณสมบัติของ Scala ที่ใช้บ่อยที่สุด และมีมีความตั้งใจเพื่อสำหรับผู้ที่เรียนรู้ภาษา Scala ใหม่
+
+และนี่ก็เป็นเพียงบทความสั้นๆ ที่ไม่ใช้การสอนเต็มรูปแบบของภาษา Scala หากต้องการเรียนรู้มากขึ้นให้พิจารณา[หนังสือ](/books.html) หรือขอคำปรึกษาจาก[แหล่งอื่นๆ](/learn.html)
+
+## อะไรคือ Scala?
+ Scala เป็นภาษาเขียนโปรแกรมแบบหลากหลายกระบวนทัศน์ที่ทันสมัย ที่ออกแบบมาเพื่อแสดงรูปแบบการเขียนโปรแกรมโดยทั่วไปที่กระชับ สง่างาม และมีชนิดข้อมูลที่ปลอดภัย (type-safe) ซึ่งผสานคุณสมบัติของภาษาเชิงวัตถุและภาษาเชิงฟังก์ชัน
+
+## Scala เป็นภาษาเชิงวัตถุ ##
+Scala เป็นภาษาการเขียนโปรแกรมเชิงวัตถุที่แท้จริง ในแง่ที [่ทุกค่าเป็นวัตถุ](unified-types.html) ชนิดข้อมูลและพฤติกรรมของวัตถุอธิบายโดย[คลาส (classes)](classes.html) และ [ลักษณะ (traits)](traits.html) คลาสจะถูกขนายโดยการจัดชั้นย่อย (subclassing) และกลไล[องค์ประกอบแบบผสมผสาน (mixin-based composition)](mixin-class-composition.html) ที่มีความยืดหยุ่นเพื่อทดแทนสำหรับการสืบทอดหลายแบบ
+
+## Scala เป็นภาษาเชิงฟังก์ชัน ##
+Scala ยังเป็นภาษาเชิงฟังก์ชันในแง่ที่ [ทุกฟังก์ชันเป็นค่า](unified-types.html) Scala มี[ไวยกรณ์แบบง่าย](basics.html#functions)สำหรับกำหนดฟังก์ชันที่ไม่ระบุตัวตน รองรับ [ฟังก์ชันที่มีลำดับสูงขึ้น (higher-order functions)](higher-order-functions.html) ทำให้ฟังก์ชันสามารถ [ซ้อนกันได้ (nested)](nested-functions.html) และรองรับ [currying](multiple-parameter-lists.html), [เคสคลาส (case class)](case-classes.html) ของ Scala สนับสนุน [รูปแบบการจับคู่ (pattern-matching)](pattern-matching.html) เป็นการจำลองชนิดข้อมูลแบบพีชคณิตที่ใช้ในภาษาเชิงฟังก์ชันหลายภาษา, [วัตถุ Singleton](singleton-objects.html) ทำให้มีวิธีที่สะดวกในการจัดกลุ่มฟังก์ชันที่ไม่ใช้สมาชิกของคลาส
+
+นอกจากนี้ Scala มีแนวคิดของรูปแบบการจับคู่โดยธรรมชาติซึ่งสามารถขยายเป็น [การประมวลผลข้อมูลด้วย XML](https://github.com/scala/scala-xml/wiki/XML-Processing) ด้วยความช่วยเหลือของ [รูปแบบลำดับที่ถูกละเลย (right-ignoring sequence patterns)](regular-expression-patterns.html), โดยวิธีของการขยายทั่วไปผ่านทาง [วัตถุตัวดึงข้อมูล (extractor object)](extractor-objects.html) ในบริบทนี้ การ[ทำความเข้าใจ for](for-comprehensions.html) มีประโยชน์สำหรับการคิดสูตรคิวรี่ข้อมูล คุณลักษณะเหล่านี้ทำให้ Scala เหมาะสำหรับการพัฒนาแอพพลิเคชันแบบเช่นเว็บเซอร์วิส
+
+## Scala มีชนิดข้อมูลแบบคงที่ ##
+Scala เป็นระบบที่มีลักษณะของชนิดข้อมูลบังคับให้เป็นแบบคงที่ (statically) ว่าสิ่งที่เป็นนามธรรม (abstraction) ถูกใช้อย่างปลอดภัยและสอดคล้องกัน โดยเฉพาะอย่างยิ่ง ระบบชนิดข้อมูลสนับสนุนข้อมูลหลายประเภท ดังนี้:
+
+* [คลาสทั่วไป](generic-classes.html)
+* [คำอธิบายประกอบผันแปร](variances.html)
+* ขอบเขตชนิดข้อมูล [ข้างบน](upper-type-bounds.html) และ [ข้างล่าง](lower-type-bounds.html)
+* [คลาสภายใน](inner-classes.html) และ [ชนิดข้อมูลนามธรรม](abstract-types.html) เป็นสมาชิกของวัตถุ
+* [ชนิดข้อมูลผสม](compound-types.html)
+* [อ้างอิงตัวเองของชนิดข้อมูลอย่างชัดเจน](self-types.html)
+* [พารามิเตอร์ปริยาย](implicit-parameters.html) และ [การเปลี่ยนปริยาย](implicit-conversions.html)
+* [เมธอดหลายรูปแบบ)](polymorphic-methods.html)
+
+[ชนิดข้อมูลอนุมาน (Type inferrence)](type-inference.html) หมายถึงผู้ใช้ไม่จำเป็นต้องใส่โค้ดคำอธิบายประกอบที่มีข้อมูลซ้ำซ้อน ในการรวม คุณสมบัติเหล่านี้จะเป็นคุณสมบัติพื้นฐานที่มีประสิทธิภาพสำหรับการนำส่วนของโปรแกรมที่เป็นนามธรรม มาใช้ใหม่ได้อย่างปลอดภัยและเพื่อให้สามารถขยาย ชนิดข้อมูลที่ปลอดภัยของซอฟต์แวร์
+
+## Scala สามารถขยายออกได้ ##
+
+ในทางปฏิบัต การพัฒนาแอพพลิเคชันเฉพาะโดเมนมักต้องใช้ส่วนขยายของภาษาเฉพาะโดเมน ซึ่ง Scala มีการรวบรวมกลไกเฉพาะที่ทำให้ง่ายต่อการเพิ่มโครงสร้างภาษาใหม่ ในรูปแบบห้องสมุด
+
+ในหลายกรณีสามารถทำได้โดยไม่ปราศจากสิ่งอำนวยความสะดวกเมตาดาต้าโปรแกรม อย่างเช่น มาโคร, ตัวอย่างเช่น
+
+* [คลาสโดยปริยาย](http://docs.scala-lang.org/overviews/core/implicit-classes.html) อนุญาติให้เพิ่มขยายเมธอดกับชนิดข้อมูลที่มีอยู่
+* [สอดแทรกสตริงตัวอักษร](/overviews/core/string-interpolation.html) คือการขยายโดยผู้ใช้ด้วยตัวสอดแทรกที่กำหนดเอง.
+
+## Scala ทำงานร่วมกันได้
+
+Scala ออกแบบมาเพื่อให้ทำงานร่วมกันกับ Java Runtime Environment (JRE) โดยเฉพาะอย่างยิ่งปฏิสัมพันธ์กับหลักภาษาโปรแกรมเชิงวัตถุ Java อย่างราบรื่นไร้รอยต่อ คุณสมบัติใหม่ของภาษา Java อย่างเช่น SAMs, [Lambdas](higher-order-functions.html), [annotations](annotations.html) และ [generics](generic-classes.html) มีความคล้ายคลึงกับ Scala
+
+คุณสมบัติเหล่านี้ของ Scala ที่ไม่คล้ายคลึงกับ Java อย่างเช่น [default](default-parameter-values.html) และ [ชื่อพารามิเตอร์](named-arguments.html) จะถูกคอมไพล์ให้ใกล้เคียงกับ Java ตามที่สมควร ซึ่ง Scala มีการคอมไพล์แบบเดียวกันกับ Java (แยกการคอมไพล์, การโหลดคลาสแบบไดนามิก) ทำให้สามารถเข้าถึงไลบรารี่ที่มีคุณภาพสูงของ Java จำนวนมากได้
+
+## ขอให้สนุกกับการเดินทาง!
+
+ไปต่อได้ที่ [หน้าถัดไป](basics.html) ในเมนูของเนื้อหาเพื่ออ่านเพิ่มเติม