Scalaを書いてみる

println({
  val sum = 20 + 14
  sum / 2
})

val numbers = Seq(100, 53, 133)
numbers.map(_ * 2)

val numbers = List(10, 30, 15)

// (初期値)(実行する関数)
numbers.foldLeft(0)((b, a) => a + b) // 55

numbers.sum // 55

numbers.foldLeft(0)(_ + _)

// 配列の合計を計算する、特に意味はない関数
// 合計するときに使う値を関数で指定できる
def calcListSum
(list: List[Double])
(func: Double => Double)
(implicit num: Numeric[Double]) = {
  list.foldLeft(num.zero)((sum, current) => {
    num.plus(sum, func(current))
  })
}

val calcSalarySum = calcListSum(List(200, 100, 150)) // 関数が入る

// 多分税金を計算してる
calcSalarySum(_ * 0.95) // 427.5

class Point(var x: Int = 0, var y: Int = 0) {
  def move(dx: Int, dy: Int): Unit = {
    x = x + dx
    y = y + dy
  }
}

class StringIterator(string: String) {
  type T = Char
  private var index: Int = 0

  def hasNext = index < string.length

  def next = {
    val char = string.charAt(index)
    index += 1
    char
  }
}

val iterator = new StringIterator("Hello World!")
iterator.next // H
iterator.next // e
iterator.hasNext // true

case class Book(title: String) // パラメーターの()は必須

val book1 = Book("The C Programming Language")
book1.title

val book1 = Book("book1")
val book2 = Book("book2")

book1 == book2 // true

abstract class Notification

case class SMS(caller: String, message: String) extends Notification {
  def send(): Unit = println(s"Success! (to $caller)")
}
case class Slack() extends Notification
case class Email() extends Notification

val notification: Notification = SMS("012-3456-7890", "This is a SMS message")

notification match {
  case n: SMS => {
    println(s"message: [${n.message}] to ${n.caller}")
    n.send()
  }
  case Slack() => ""
  case _ => "Not Found"
}

case SMS(caller, message) => println(s"message: [$message] to $caller")

package logging
object Logger {
  def log(message: String): Unit = println(s"LOG: $message")
  def info(message: String): Unit = println(s"INFO: $message")
}

import logging.Logger.info

info("This is an infomation message")

import scala.math._

case class Circle(radius: Double) {
  import Circle._ // コンパニオンからimport
  def area = calcArea(radius)
}

object Circle {
  private def calcArea(radius: Double): Double = Pi * pow(radius, 2.0)
}

val circle = Circle(10)
circle.area

case class Email(username: String, domainName: String)

object Email {
  // ファクトリーメソッド
  def fromString(emailString: String): Option[Email] = {
    emailString.split("@") match {
      case Array(a, b) => Some(Email(a, b))
      case _ => None
    }
  }
}

val email = Email.fromString("admin@example.com")
email match
  case Some(Email(username, domainName)) => 
    s"user: $username | domain: $domainName"
  case None => "Error: could not parse email"

// 配列のイメージ
trait List[T] {
  def map(func: T => T): List[T]
  // ...
}

abstract class BaseAbs {
  val message: String
}

class BaseClass extends BaseAbs {
  val message = "Hello World!"
}

// アッパーケースにするトレイト
trait UpperTrait extends BaseAbs  {
  def toUpper = message.toUpperCase()
}

// これだけでBaseClassにtoUpperを追加できる
class MyMessage extends BaseClass with UpperTrait

abstract class BaseIterator {
  type T
  def hasNext: Boolean
  def next: T
}

class StringIterator(string: String) extends BaseIterator {
  type T = Char
  private var index: Int = 0

  def hasNext = index < string.length

  def next = {
    val char = string.charAt(index)
    index += 1
    char
  }
}

trait IteratorForeach extends BaseIterator {
  def foreach(func: T => Unit): Unit = {
    while (hasNext) func(next)
  }
}

class RichStringIterator(string: String) 
  extends StringIterator(string) with IteratorForeach

val iterator = new RichStringIterator("Hello World!")
iterator.foreach(char => println("char: " + char))

import scala.math._

case class Circle(radius: Double) extends CircleCalculator {
  import Circle._
  def area = calcArea(radius)
}

trait CircleCalculator {
  protected def calcArea(radius: Double): Double = Pi * pow(radius, 2.0)
}

numbers
  .map(num => num * 2)
  .foreach(println)

numbers
  .map(num => num * 2)
  .forEach(num => console.log(num))

trait Animal {
  val name: String
}

class Dog(val name: String) extends Animal
class Cat(val name: String) extends Animal

val animals: List[Animal] = List(
  new Dog("ポチ"),
  new Cat("ねこ")
)

animals.foreach(animal => println(animal.name))

val animals = List(
  new Dog("ポチ"),
  new Cat("ねこ")
) // List[Animal]

val animals = List(
  new Dog("ポチ"),
  new Cat("ねこ"),
  "string"
) // List[Object]

val tuples: List[(String, Int)] = List(
  ("String", 349),
  ("MyStr", 12)
)

tuples
  .foreach((str, num) => println(str + num))

const [state, setState] = useState("init")

val (state, setState) = useState("init")

s"message: [${n.message}] to ${n.caller}"

if (10 > 9) {
  println("Yes")
}

val numberPattern = "[0-9]".r
val password = "hello-124"

if (numberPattern.findFirstMatchIn(password).isDefined)
  "OK"
else
  "Invalid"

val syntax = "(va[l|r]) ([a-zA-Z0-9]+) = ([a-zA-Z0-9 \\t!\"]+)".r

val code = "val str = \"Hello World!\""
syntax.findFirstMatchIn(code) match {
  case Some(pattern) => {
    s"""OK 略""".stripMargin
  }
  case None => "Invalid Syntax"
}

val code = """// code
  |val str = "Hello World!"
  |val num = 123
  """.stripMargin

for (pattern <- syntax.findAllMatchIn(code)) {
  output(pattern.group(1), pattern.group(2), pattern.group(3))
}

// outputメソッドは略

OK 
seg: val
variable-name: str
init: "Hello World!"

OK 
seg: val
variable-name: num
init: 123