The document provides definitions and implementations of functions to compute the length and sum of lists in Scala with generics. It emphasizes type safety and highlights type mismatches when using different data types. Examples are provided for lists of doubles, integers, and strings, demonstrating function application and error handling in functional programming.

5. Java
Scala

7. C++ swap
Scala length sum

8. length

9. length

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

12. val list = List(1.0, 3.14, 2.71)
length(list) // 3

14. val list = List(42, 99, 666)

15. length

16. error: type mismatch;
found : List[Int]
required: List[Double]
length(list)

18. List[Double] List[Int]

19. length
List[Double] => Double

20. length

21. Double Int
String Any

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

25. length
[A]

27. 1

28. new

29. def func[A, B, C](arga: A, argb: B): C = ...

30. length
length
[A]

31. length

32. length

33. val listDouble = List(1.0, 3.14, 2.71)
length[Double](listDouble) // 3
val listInt = List(1, 2, 3, 4, 5)
length[Int](listInt) // 5
val listString = List("hoge", "fuga", "piyo")
length[String](listString) // 3

35. Scala

36. val listDouble = List(1.0, 3.14, 2.71)
length(listDouble) // 3
val listInt = List(1, 2, 3, 4, 5)
length(listInt) // 5

38. length

39. length

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

41. A A

43. 2
2

45. def twoList[A, B, C](list1: List[A], list2: List[B], func: List[?
(func(list1), func(list2))

46. 3

47. List[A] List[B]

48. length

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

51. length
List [_]

52. A
A

53. def func(list: List[_ <: AnyVal]) = ...

54. A <: B A B

56. twoList(List(1,2,3,4,5), List("hoge","fuga","piyo"), length) // (

57. 8-1

58. sum

59. sum

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

61. Double List

62. val list = List(1.0, 3.14, 2.71)
sum(list) // 6.85

63. List(42, 99, 666)

64. val list = List(42, 99, 666)
sum(list)
// error: type mismatch;
// found : List[Int]
// required: List[Double]
// sum(list)

65. length

66. Double
Int

67. length
sum Int Double

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

69. ……

70. type mismatch;
found : Int(0)
required: A
case Nil => 0
^
type mismatch;
found : List[A]
required: List[String]
case head :: tail => head + sum(tail)
^

74. sum Scala

75. def sum[A](list: List[A]): A =

76. A A
A

77. case Nil => 0

78. A
Int

79. Scala

81. case head :: tail => head + sum(tail)

82. +
A +

83. sum
sum

84. 2
0

87. 2

88. <:

89. trait Addable {
def +(other: Addable): Addable
}
def add[T <: Addable](a: T, b: T) = a + b

90. T +
+

91. Addable

92. Scala Int
Double

93. Scala
Numeric

94. Haskell
Scala

95. implicit

98. Scala

99. def sum[A](list: List[A])(implicit ev: Numeric[A]): A =

100. 2 implicit
[A]

101. A
ev evidence

103. Ruby

104. Numeric

105. trait Numeric[T] extends Ordering[T] {
def plus(x: T, y: T): T
def minus(x: T, y: T): T
def times(x: T, y: T): T
def negate(x: T): T
def fromInt(x: Int): T
def toInt(x: T): Int
def toLong(x: T): Long
def toFloat(x: T): Float
def toDouble(x: T): Double
def zero = fromInt(0)
def one = fromInt(1)
def abs(x: T): T = if (lt(x, zero)) negate(x) else x

106. sum

107. 0

108. plus zero
Numeric

109. sum Numeric
Scala
Numeric

110. Numeric

111. def sum[A](list: List[A])(implicit ev: Numeric[A]): A =
list match {
case Nil => ev.zero
case head :: tail => ev.plus(head, sum(tail))
}

112. sum

113. ev

114. ev

115. val listDouble = List(1.0, 3.14, 2.71)
sum(listDouble) // 6.85
val listInt = List(1, 2, 3, 4, 5)
sum(listInt) // 15

116. sum

117. 9-1

118. 9-2
sum

119. def sum[A: Numeric](list: List[A]): A =
list match {
case Nil => implicitly[Numeric[A]].zero
case head :: tail => implicitly[Numeric[A]].plus(head, sum(ta
}

120. [A: Numeric]
context bound

122. implicitly

123. def implicitly[T](implicit e: T) = e

124. 9-3
Scala