This document provides an overview of the Scala programming language. It discusses Scala's JVM compatibility, basic data types like Int, Double, String, collections like List and Map, control flow structures like if/else and for loops, functions using def and =>, pattern matching, and common functions on collections like sum, length, and mean. It also shows examples of using Scala from the command line and with SBT.

1. Scala

2. Scala

3. Scala JVM

4. JVM

5. OS

6. VM OS
VM
1

8. Scala

11. Scala

12. Scala

13. // 1
/*
*
*/
println("Hello, world!") //

16. 42 // Int
3.14 // Double
"hogehoge" // String
true // Boolean
() // Unit

17. Array(1, 2, 3) //
List(1, 2, 3) //
Map("a" -> 1, "b" -> 2) //
Set(1, 2, 3) //

18. 1 :: 2 :: 3 :: Nil
// :: Nil
// List(1, 2, 3)

19. (42, "string", 3.14) //
s"$value ${value2}" // $ ${}

21. val i = 42 // val
// i = 99 // val
val j: Int = 100 //
// k: String = 100 //
var x = 42 //
x = 99 //

23. Scala if for match while

25. // if (cond) cond Boolean
if (cond) {
...
} else {
...
}

26. for (i <- seq) {
...
}

28. // Scala if for
val ret = if (false) {
"aaa"
} else if (true) {
"bbb"
} else {
"ccc"
}
ret // => "bbb"

29. val list = 1 :: 2 :: 3 :: Nil
val ret = for (i <- list) { i * 2 }
ret //=> Unit
// for
// list.foreach { i => ... }
val list = for (i <- list) yield { i * 2 }
list //=> List(2, 4, 6)
// yield yield
// list.map { i => ... }

30. val num = 42
// match
num match {
case n if n > 40 => println("over 40.")
case _ => println("less than or equal to 40.") // _
}

32. val tuple = (42, "answer")
val (i, s) = tuple
i // 42
s // tuple
// match
tuple match {
case (40, s) => println(s"40 is $s")
case (i, "universe") => println(s"$i is universe")
case (i, s) => println(s"$i is $s")
}

33. val tuple = (42, "hogefuga", 3.14)
tuple match {
case (40, "foobar", 2.718) => //
case (Num, Str, Point) => //
case (`num`, `str`, `p`) => //
case (n: Int, s: String, p: Int) => //
case tup @ (n, s, p) => //
}

34. val list = 1 :: 2 :: 3 :: Nil
// head tail
val head :: tail = list
head // 1
tail // List(2, 3)
list match {
case 42 :: tail => // 42
case head :: Nil => // Nil 1
case e1 :: e2 :: _ => // 2
case Nil => //
}

35. //
val tuple = (42, "answer", 1 :: 2 :: 3 :: Nil)
tuple match {
case (40, str, head :: Nil) =>
case (i, "answer", x :: xs) =>
case (_, _, list @ (head :: tail)) => // list List
case _ => //
}

37. Scala
def

38. def func(x: Int, y: Int): Int = {
x + y
}
//
// 1
def func2(x: Int, y: Int) = x + y

39. Scala

40. //
val fun = (x: Int, y: Int) => x + y
//
fun(1, 2) //=> 3

41. =>

43. // x y Int
val fun: (Int, Int) => Int = (x, y) => x + y

44. =>

45. match =>
=>

46. // =>
val fun: Int => String = (i: Int) => i match {
case 42 => "correct"
}

48. val fun = (x: Int, y: Int) = x + y
//
def fortytwo(num: Int, f: (Int, Int) => Int) = f(num, 42)
//
fortytwo(99, fun) // 141
//
fortytwo(2, (x, y) => x * y) // 84
// fortytwo x y

49. map

51. map
map

52. Scala List map

53. val list = 1 :: 2 :: 3 :: Nil
// 2
val fun = i: Int => i * 2
// map
list.map(fun) //=> List(2, 4, 6)
// List fun
//
list.map(i => i + 2) // List(3, 4, 5)

54. CLI

56. $ scala cli.scala 74 76 81 89 92 87 79 85
mean: 82

59. object Main {
def main(args: Array[String]): Unit = {
println("Hello, world!")
}
}

60. cli.scala
Hello, world!
$ scala cli.scala

61. Scala

62. sbt

63. Scala sbt

64. sbt
$ sbt

65. compile
run main

66. sbt
sbt target

67. 1-1

70. Scala main

71. object Main {
def main(args: Array[String]): Unit = {
for (arg <- args) {
println(arg)
}
}
}

72. args.scala

73. $ scala args.scala hoge fuga
hoge
fuga
$ scala args.scala 42 99
42
99

75. 2-1

77. Scala 2.11 scala.io.StdIn

78. object Main {
def main(args: Array[String]): Unit = {
val input = scala.io.StdIn.readLine
println(input)
}
}

79. stdin.scala

80. $ scala stdin.scala

82. $ scala stdin.scala
Hello, world!
Hello, world!

84. split

85. object Main {
def main(args: Array[String]): Unit = {
val input = scala.io.StdIn.readLine.split(" ")
for (word <- input) println(word)
}
}

87. $ scala stdin.scala
hoge fuga piyo
hoge
fuga
piyo

88. 2-2

90. Scala
……

91. 42 + "99" // toString "4299"

92. Ruby JavaScript

93. Ruby
irb(main):001:0> 42 + "99"
TypeError: String can't be coerced into Fixnum
from (irb):1:in `+'
from (irb):1

94. JavaScript
> 42 + '99'
'4299'
> '7' * 9
63
> 42 * 'hoge'
NaN

95. Scala
NaN

96. Scala
implicit

97. toInt
toDouble

98. 42 + "99".toInt // 141
3 * 3 * "3.14".toDouble // 28.26

99. 2

100. object Main {
def main(args: Array[String]): Unit = {
for (arg <- args) {
println(arg.toInt * 2)
}
}
}

101. number.scala
$ scala number.scala 42 99 1
84
198
2

103. 3-1
"hoge" toInt
toDouble

104. Array[String] ->
List[Double]

105. Array
Array List
toDouble

106. toList
Array toList List

107. args.toList

108. map
map

109. map
Double

110. args.map(_.toDouble)

112. Array[String] List[Double]
args.map(_.toDouble).toList

113. 4-1
Array[String] List[Double]

114. Array List
val arr = Array("1", "2", "3")
val list = List(1.0, 2.0, 3.0)

116. CLI
/

118. sum

119. sum
Scala sum

121. sum

123. 0

124. Scala Nil
Nil sum(Nil) 0

125. 1 2
3 ……
n
n

126. n n n-1
n = 1 n-1

127. n n
1..n
1..n 1..n-1 n

128. 1 + 2 + ... + n - 2 + n - 1 + n = (1 +
2 + ... n - 2 + n - 1) + n

129. 3 :: 2 :: 7 :: 5 :: Nil
1 4 17 1 3
12 4 5
17

130. n
1

131. n - 1 = 0 0
n - 1 > 0

132. 0
0

133. sum

134. 0
n n 1..n-1

135. Scala

136. sum( 3 :: 2 :: 7 :: 5 :: Nil )
3 + sum( 2 :: 7 :: 5 :: Nil )
3 + 2 + sum( 7 :: 5 :: Nil)
3 + 2 + 7 + sum( 5 :: Nil)
3 + 2 + 7 + 5 + sum( Nil )
3 + 2 + 7 + 5 + 0
3 + 2 + 7 + 5
3 + 2 + 12
3 + 14
17

137. Scala

138. Scala

139. def sum(list: List[Double]): Double = ???

140. List[Double]
Double

142. if
match

143. def sum(list: List[Double]): Double =
list match {
case Nil => ???
case head :: tail => ???
}

144. 0

145. def sum(list: List[Double]): Double =
list match {
case Nil => 0
case head :: tail => ???
}

147. def sum(list: List[Double]): Double =
list match {
case Nil => 0
case head :: tail => head + sum(tail)
}

149. 5-1

150. 1 :: 2 :: 3 :: Nil match {
case a :: b :: rest =>
println(a) // 1
println(b) // 2
println(rest) // List(3)
}

151. 1

152. length

153. sum
length

154. sum 0
length

155. sum
0

156. n
n n-1

157. 1 1
n-1 1 n

158. n
n-1

159. sum 3 :: 2 :: 7
:: 5 :: Nil

160. length( 3 :: 2 :: 7 :: 5 :: Nil )
1 + length( 2 :: 7 :: 5 :: Nil )
1 + 1 + length( 7 :: 5 :: Nil )
1 + 1 + 1 + length( 5 :: Nil )
1 + 1 + 1 + 1 + length( Nil )
1 + 1 + 1 + 1 + 0
1 + 1 + 1 + 1
1 + 1 + 2
1 + 3
4

161. Scala

162. def length(list: List[Double]): Double =
list match {
case Nil => 0
case _ :: tail => 1 + length(tail)
}

163. _ Scala

164. _

165. 6-1
_

166. _

167. mean

168. /

170. def mean(list: List[Double]): Double = sum(list) / length(list)

172. CLI

173. CLI

174. object Main {
def sum(list: List[Double]): Double =
list match {
case Nil => 0
case head :: tail => head + sum(tail)
}
def length(list: List[Double]): Double =
list match {
case Nil => 0
case _ :: tail => 1 + length(tail)
}
def mean(list: List[Double]): Double = sum(list) / length(list)
def main(args: Array[String]): Unit = {

176. $ scala cli.scala
mean: 82.875

179. 2

180. def sum(list: List[Double]): Double =
list match {
case Nil => 0
case head :: tail => head + sum(tail)
}
def length(list: List[Double]): Double =
list match {
case Nil => 0
case _ :: tail => 1 + length(tail)
}

182. def common(list: List[Double]): Double =
list match {
case Nil => 0
case head :: tail => ??? + common(tail)
}

183. ???

186. def common(list: List[Double], f: Double => Double): Double =
list match {
case Nil => 0
case head :: tail => f(head) + common(tail, f)
}

187. 1

188. sum length

189. def sum(list: List[Double]): Double = common(list, head => head)
def length(list: List[Double]): Double = common(list, _ => 1)

191. head => head _ => 1

192. head => head 1

193. _ => 1 1 1

194. 7-1
_ => 1 head => 1
_

195. match _

196. 7-2

197. def test(fun: Double => Double) = fun(3.14)
test(_ => 1) // 1.0

198. 1

199. val fun = _: Double => 1
test(fun) //

201. :

202. 7-3
identity

203. fold

204. fold

205. common

206. fold

207. fold sum length
map filter

208. def foldr[A, B](f: (A, B) => B, ini: B, list: List[A]): B =
list match {
case Nil => ini
case head :: tail => f(head, foldr(f, ini, tail))
}

209. Double
length sum foldr

210. def length(list: List[Double]): Double =
foldr[Double, Double]((_, i) => i + 1, 0, list)
def sum(list: List[Double]): Double =
foldr[Double, Double]((a, i) => a + i, 0, list)

211. 7-4
foldr

212. max
min
reverse
filter
map