### Author:  [@tk-fuse](https://forum.ficusonline.com/u/tk-fuse)
#### Post date: [2020 年 10 月 20 日午前 7:39 UTC](https://forum.ficusonline.com/t/topic/385/15 "2020-10-20T07:39:38Z")
### Types
> **[Unified Types](https://docs.scala-lang.org/tour/unified-types.html)**
**Type hierarchy**
* * *
### List Members(Class)
> **[List](https://www.scala-lang.org/api/current/scala/collection/immutable/List.html)**
**型(Type)が混合したリスト(List)例**
```auto
val list: List[Any] = List(
"a string",
732, // an integer
'c', // a character
true, // a boolean value
() => "an anonymous function returning a string"
)
list.foreach(element => println(element))
```
**出力**
```auto
a string
732
c
true
```
**構成要素に型Tを指定したList: List[T]**
**例）**
```auto
val fruit: List[String] = List("apples", "oranges", "pears")
val nums : List[Int] = List(1, 2, 3, 4)
val diag3: List[List[Int]] = List(List(1, 0, 0), List(0, 1, 0), List(0, 0, 1))
val empty: List[Nothing] = List()
```
### Constructors of Lists
Actually, all lists are constructed from:
the empty list Nil, and
the construction operation **:: (pronounced cons)**: **x :: xs** gives a new list with the **first element x** , followed by the elements of **xs (which is a list itself)**.
**For example:**
```auto
val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))
val empty = Nil
```
### Nil == List.empty[A] == List()
```auto
scala> Nil
res15: scala.collection.immutable.Nil.type = List()
scala> List.empty[Int]
res16: List[Int] = List()
scala> List()
res17: List[Nothing] = List()
```
### Manipulating Lists
It is possible to decompose lists with pattern matching:
Nil: the Nil constant,
**p :: ps** : A pattern that matches a list with a **head** matching **p** and a **tail** matching **ps**.
```auto
nums match {
// Lists of `Int` that starts with `1` and then `2`
case 1 :: 2 :: xs => …
// Lists of length 1
case x :: Nil => …
// Same as `x :: Nil`
case List(x) => …
// The empty list, same as `Nil`
case List() =>
// A list that contains as only element another list that starts with `2`
case List(2 :: xs) => …
}
```
**例）リストへのインサート**
```auto
object StandardLibrary{
val cond: (Int, Int) => Boolean = (_: Int) < (_: Int)/*insert the correct condition for evaluating if the list is sorted*/
def insert(x: Int, xs: List[Int]): List[Int] =
xs match {
case List() => x :: List.empty[Int]// TODO
case y :: ys =>
if (cond(x, y)) x :: y :: ys
else y :: insert(x, ys)
}
def main(args: Array[String]): Unit = {
println(insert(4, 1::8::Nil))
}
}
Output
> List(1, 4, 8)
```
---
### Author:  [@tk-fuse](https://forum.ficusonline.com/u/tk-fuse)
#### Post date: [2020 年 10 月 21 日午前 5:41 UTC](https://forum.ficusonline.com/t/topic/385/16 "2020-10-21T05:41:34Z")
### Option
> **[Option](https://www.scala-lang.org/api/current/scala/Option.html)**
インスタンスである **Some[A]** か **None** を返す。
**例）**
```auto
import org.scalatest.{FlatSpec, Matchers}
object StandardLibrary extends FlatSpec with Matchers {
def optionMap(x: Option[Int]) : Option[Int]= {
x.map(x => x + 1)
}
def optionFilter(x: Option[Int]): Option[Int] = {
x.filter(x => x % 2 == 0)
}
def optionFlatMap(x: Option[Int]): Option[Int] = {
x.flatMap(x => Some(x + 1))
}
def main(args: Array[String]): Unit = {
println(optionMap(Some(7)))
println(optionMap(None))
println(optionFilter(Some(5)))
println(optionFilter(Some(6)))
println(optionFlatMap(Some(4)))
println(optionFlatMap(None))
}
}
```
**出力**
```auto
Some(8)
None
None
Some(6)
Some(5)
None
```
---
### Author:  [@tk-fuse](https://forum.ficusonline.com/u/tk-fuse)
#### Post date: [2020 年 10 月 21 日午前 8:00 UTC](https://forum.ficusonline.com/t/topic/385/17 "2020-10-21T08:00:12Z")
### Either
> **[Either](https://www.scala-lang.org/api/current/scala/util/Either.html)**
```auto
object StandardLibrary{
def triple(x: Int): Int = 3 * x
def tripleEither(x: Either[String, Int]): Either[String, Int] =
x.map(triple)
def main(args: Array[String]): Unit = {
println(tripleEither(Right(1)))
println(tripleEither(Left("not a number")))
}
}
```
**Note)**
**x.right.map(triple)** でも良いが、 **right** は **map** で統一
**出力**
```auto
Right(3)
Left(not a number)
```
---
### Author:  [@tk-fuse](https://forum.ficusonline.com/u/tk-fuse)
#### Post date: [2020 年 10 月 23 日午前 8:31 UTC](https://forum.ficusonline.com/t/topic/385/18 "2020-10-23T08:31:05Z")
### Expansion of Function Values
An anonymous function such as
```auto
(x: Int) => x * x
```
is expanded to:
```auto
class AnonFun extends Function1[Int, Int] {
def apply(x: Int) = x * x
}
new AnonFun
```
or, shorter, using anonymous class syntax:
```auto
new Function1[Int, Int] {
def apply(x: Int) = x * x
}
```
### Expansion of Function Calls
A function call, such as f(a, b), where f is a value of some class type, is expanded to:
```auto
f.apply(a, b)
```
So the OO-translation of:
```auto
val f = (x: Int) => x * x
f(7)
```
would be:
```auto
val f = new Function1[Int, Int] {
def apply(x: Int) = x * x
}
f.apply(7)
```
### map
Thus, instead of writing the following:
```auto
xs.map(x => x + 1)
```
You can write:
```auto
for (x <- xs) yield x + 1
```
You can read it as **“for every value, that I name ‘x’, in ‘xs’, return ‘x + 1’”**.
### filter
Also, instead of writing the following:
```auto
xs.filter(x => x % 2 == 0)
```
You can write:
```auto
for (x <- xs if x % 2 == 0) yield x
```
The benefit of this syntax becomes more apparent when it is combined with the previous one:
```auto
for (x <- xs if x % 2 == 0) yield x + 1
```
Equivalent to the following:
```auto
xs.filter(x => x % 2 == 0).map(x => x + 1)
```
### flatMap
Finally, instead of writing the following:
```auto
xs.flatMap(x => ys.map(y => (x, y)))
```
You can write:
```auto
for (x <- xs; y <- ys) yield (x, y)
```
You can read it as **“for every value ‘x’ in ‘xs’, and then for every value ‘y’ in ‘ys’, return ‘(x, y)’”**.
---
### Author:  [@tk-fuse](https://forum.ficusonline.com/u/tk-fuse)
#### Post date: [2020 年 10 月 25 日午前 3:02 UTC](https://forum.ficusonline.com/t/topic/385/19 "2020-10-25T03:02:04Z")
### Variances: Covariance [+A], Contravariance [-A]
* * *
### Definition of Variance
Roughly speaking, a type that **accepts mutations** of its elements **should not be covariant**.
But **immutable types** can be **covariant** , if some conditions on methods are met.
Say **C[T]** is a **parameterized type** and **A, B** are types such that **A \<: B**.
In general, there are three possible relationships between **C[A]** and **C[B]**:
**C[A] \<: C[B], C is covariant**,
**C[A] \>: C[B], C is contravariant**,
neither C[A] nor C[B] is a subtype of the other, C is nonvariant.
Scala lets you declare the variance of a type by annotating the type parameter:
**class C[+A]** { … }, **C is covariant** ,
**class C[-A]** { … }, **C is contravariant** ,
class C[A] { … }, C is nonvariant.
* * *
和訳すると統計学の共分散と反共分散となりますが、 **Scala** での意味は以下の具体例で理解した方がいいでしょう。
> **[Variances](https://docs.scala-lang.org/tour/variances.html)**
**Covariant C[+A]** と **Contravariant C[-A]** の例を以下に記述。
**C, A** 共に **任意のクラス（型）** を示す。
**A** を **B** の派生クラス **(A \<: B)** とした場合。
### Covariant C[+A]
**C[A]** が **C[B]** の派生クラスと定義される。**C[A] \<: C[B]**
クラス **Cat, Dog（Aに該当）** は、クラス **Animal（Bに該当）** の派生クラスなので、 **List[Cat], List[Dog]** も**List[Animal]** の派生クラスと定義される。 この場合、 **List（Cに該当）** が **Covariant** となる。
### Contravariant C[-A]
**C[B]** が **C[A]** の派生クラスと定義される。**C[A] \>: C[B]**
**Printer[-A]** により、クラス **Printer[Animal]** が **Printer[Cat]** の派生クラスとして定義される。この場合、 **Printer（Cに該当）** が **Contravariant** となる。
```java
package example
object CoAndContravariant extends App {
// ここからCovariant [+A]の例
abstract class Animal {
def name: String
}
case class Cat(name: String) extends Animal
case class Dog(name: String) extends Animal
// List[Animal] AnimalがCovariant
def printAnimalNames(animals: List[Animal]): Unit =
animals.foreach {
animal => println(animal.name)
}
val cats: List[Cat] = List(Cat("Whiskers"), Cat("Tom"))
val dogs: List[Dog] = List(Dog("Fido"), Dog("Rex"))
// prints: Whiskers, Tom
printAnimalNames(cats)
// prints: Fido, Rex
printAnimalNames(dogs)
//ここまでがConvariant [+A]の例
//ここからContravariant [-A] の例
abstract class Printer[-A] {
def print(value: A): Unit
}
class AnimalPrinter extends Printer[Animal] {
def print(animal: Animal): Unit =
println("The animal's name is: " + animal.name)
}
class CatPrinter extends Printer[Cat] {
def print(cat: Cat): Unit =
println("The cat's name is: " + cat.name)
}
def printMyCat(printer: Printer[Cat], cat: Cat): Unit =
printer.print(cat)
val catPrinter: Printer[Cat] = new CatPrinter
val animalPrinter: Printer[Animal] = new AnimalPrinter
printMyCat(catPrinter, Cat("Boots"))
printMyCat(animalPrinter, Cat("Boots"))
//ここまでContravariant [-A] の例
}
```
出力
```auto
Whiskers
Tom
Fido
Rex
The cat's name is: Boots
The animal's name is: Boots
```
---
### Author:  [@tk-fuse](https://forum.ficusonline.com/u/tk-fuse)
#### Post date: [2020 年 10 月 25 日午前 3:07 UTC](https://forum.ficusonline.com/t/topic/385/20 "2020-10-25T03:07:31Z")
### Upper Type Bounds, Lower Type Bounds
**[T \<: A]** : Tは、Aとその派生クラス（サブタイプ）のみ許容するクラスとして定義。
> **[Upper Type Bounds](https://docs.scala-lang.org/tour/upper-type-bounds.html)**
> **[Scala | Upper bound - GeeksforGeeks](https://www.geeksforgeeks.org/scala/scala-upper-bound/)**
>
> Your All-in-One Learning Portal: GeeksforGeeks is a comprehensive educational platform that empowers learners across domains-spanning computer science and programming, school education, upskilling, commerce, software tools, competitive exams, and...
**Ex)**
```auto
// Scala Program To Demonstrate Scala Upper Bound
class Principal
class Teacher extends Principal
class Student extends Teacher
class School
{
// Declaration of upper bound
def display [T <: Teacher](t: T)
{
println(t)
}
}
// Object created
object ScalaUpperBounds
{
// Driver code
def main(args: Array[String])
{
// Defined new variable
val principal = new Principal
val teacher = new Teacher
val student = new Student
val school = new School
// school.display(principal) --->コンパイルエラー
school.display(teacher)
school.display(student)
}
}
```
**出力**
```auto
Teacher@506e1b77
Student@4fca772d
```
**[T \>: A]** : Tは、Aとその派生クラス（サブタイプ）だけでなく、Aの元クラスからの派生クラスも許容するクラスとして定義。
> **[Lower Type Bounds](https://docs.scala-lang.org/tour/lower-type-bounds.html)**
> **[Scala | Lower Bound - GeeksforGeeks](https://www.geeksforgeeks.org/scala/scala-lower-bound/)**
>
> Your All-in-One Learning Portal: GeeksforGeeks is a comprehensive educational platform that empowers learners across domains-spanning computer science and programming, school education, upskilling, commerce, software tools, competitive exams, and...
**Ex)**
```auto
class Principal
class Teacher extends Principal
class Student extends Teacher
class School
{
// Declaration of lower bound
def display [T >: Teacher](t: T)
{
println(t)
}
}
// Object created
object ScalaUpperBounds
{
// Driver code
def main(args: Array[String])
{
// Defined new variable
val principal = new Principal
val teacher = new Teacher
val student = new Student
val school = new School
school.display(principal)
school.display(teacher)
school.display(student)
}
}
```
**出力**
```auto
Principal@506e1b77
Teacher@4fca772d
Student@9807454
```
>
[次のページ](https://forum.ficusonline.com/t/topic/385.md?page=2)