ScalaMatsuri 2016

1 日目振り返り

@lyrical_logical

私です

病人

重症難治化頸肩腕症候群

一年半程療養に専念してた

界隈が色々と変わってた

コンパイルの遅さ

変わらない価値

明日から Scala の仕事

社会は厳しい

働きたくない

細かいことが

気になってしまうのが、

僕の悪い癖

（相棒より、杉下右京）

というわけで

1 日目を振り返る

（全部は無理なので一部）

Refactoring in Scala

  • 型について色々な話があった
    • Type Aliases(aka Type Members)
      • ​値表現も、可能な操作も同じ、単なる別名
    • ​Tagged Types(not language features!)
      • 値表現は同じ、けど可能な操作は異なる型
    • Value Classes
      • 値表現は同じ、けど可能な操作は異なる型
      • 本来の motivation は performance
    • ​Value Classes with Phanom Types​
      • Type-Indexed
      • Tagged Types と理屈は同じ

大事なものを忘れている！

  • Abstract Type Members(aka Abstract Types)
trait Models {
  type Id[Model] // Abstract Type Members
  type Name[Model] // Abstract Type Members
  case class Board(id: Id[Board],
                   name: Name[Board],
                   ownerId: Id[User])
  case class User(id: Id[User],
                  name: Name[User],
                  groupId: Id[Group])
}

trait ForSomeLayer extends Models {
  type Id[Model] = Long
  type Name[Model] = String
}
  • More code examples
trait ForSomeLayer extends Models {
  type Id[Model] = Long
  type Name[Model] = String
}

trait FooLayer extends Models {
  type Id[Model] = Option[Long]
  type Name[Model] = String
}

trait BarLayer extends Models {
  type Id[Model] = Long @@ Model
  type Name[Model] = String @@ Model
}
  • Abstract Type Members(aka Abstract Types)
    • 値表現の「分からない」型
      • ​実装詳細の隠蔽（Encapsulation）
    • 値表現の「差し替え可能な」型
      • 実装詳細の差し替え(Injection) 
    • ​Parametric Polymorphism でも代替可能
      • ​表現力はほぼ同じ
    • Odersky 先生の論文を読もう！

まとめ

Thinking in Cats

  • 何故、抽象化するのだろうか？
    • 色々な理由、見方がある…その内の一つ
    • 型パラメタ A について、何も分からない
      • 何も分からないのは、悪いこと？
        • ​そうとも限らない
    • ​何も分からない＝考えることが少なくて済む
      • ​（例外や副作用を除けば）一意に定まることも
      • 今回の場合は "foo = Identity" 恒等関数
        • ​再帰でひたすらループもできる
        • 値返ってこないのだから実質 ⊥(Nothing)
def foo[A](a: A): A
  • 「分からない」について、分かろう
    • 関数のシグネチャから、実装が推測しやすくなる​
    • 型が具象的であるほど、分かることが増える
      • ​できることも増える
      • シグネチャを満たす実装も増える…
    • 型が抽象的であるほど、分からないことが増える
      • できることは減る
      • シグネチャを満たす実装は減る、推測可能！
    • ​勿論、型システムの表現力も絡んでくる
      • ​依存型、セッション型、その他諸々...

まとめ

  • Why Abstraction Matter
    • ​これだけで一時間は喋れる…
  • 色々あるけど、一つの見方を紹介
  • 抽象化は「分からない」にすること
  • 「分からない」から「分かる」こともある

How Scala code is expressed in the JVM

聞けてない

スライドは見た

話してた内容ならすいません

  • match expression が tableswitch 命令に
    • Scala コンパイラが可能ならそうしてくれる​
    • 確認するのためにバイトコード毎回見る？
      • ​だるい
    • Annotation を使おう！
      • ​scala.annotation.switch
        • scala.annotation.tailrec みたいなもの
(x: @scala.annotation.switch) match {
  case 1 => "one"
  case 2 => "two"
  case _ => "other"
}
  • そもそも何でバイトコードを見るのか
    • まあぶっちゃけ色々ありますよね
    • 一つに、Java との Interoperation
    • Java から Scala の object を扱うには？

この情報、古いです

  • ボクが療養してる間に Scala はよくなっていた！
    • SomeObject.MODULE$.member
      • もう古い
    • SomeObject.member
      • こう書ける（はず）
        • 何時からこうなのか誰か教えて下さい…
    • object のメンバが同名クラスの static メンバに
      • ​static メンバなので衝突する事は無いはず
    • ​ウェブで情報探しても見当たらない（何故だ）

まとめ

  • 処理系に任せられるものは任そう
  • コンパイラは日々改良されている
    • ​2.12 はまだですか
  • ​javap はサイコー

Scala technology supporting the

Dwango account system

Minimal Cake Pattern

続きは Web で

Any questions?

がっこうぐらし！三巻より引用

書いてる今 5:00 で眠い

  • 時間余ったら何か話すかもリスト（not 振り返り）
    • Scala 処理系への Contribution の話
    • Scala の typing の話
      • ​コードがどのように型推論されるか
    • ​Scala の spec とかのドキュメントの話
    • Scala コミュニティのこれから
    • HK と (G)ADTs の型推論のバグの話
      • ​skolem, 自由型変数のスコープ（だと思う）
      • 型の Equality は実は難しい
def f(a: { type T })(b: a.T): Unit // valid
def g(a: { type T }, b: a.T): Unit // invalid

def h(n: Int): Int = ???
def h(n: Int): String = ??? // Overload
val num: Int = h(1) // resolved
val str: String = h(1) // resolved

implicit def foo(n: { def f(n: Int): Int ) = new {
  def f(n: Int): String = ???
}
val hasF = new { def f(n: Int) = n }
val str: String = hasF.f(1) // invalid
import scala.language.higherKinds

sealed trait Base[F[_]] {
  def a: String
}
case class Ctor[F[_]](a: String) extends Base[F]
abstract class Etor[F[_]] extends Base[F] {
  def f(q: Base[F]): String = q match {
    case Ctor(fa) => fa
    case Etor(fa) => fa // invalid, type error
    //  case _: Etor[F, this.T] => () // valid
  }
}
object Etor {
  def unapply[F[_]](node: Etor[F]): Option[String] = {
    if (node eq null) None else Some(node.a)
  }
}
  • Pattern は割と難しい
    • Extractor Patterns
    • Constructor Patterns
    • 実は Case Classes の unapply は使われない
      • ​GADTs と variance による型の回復とか
        • ​relaxing the value restriction 的な
      • 色々あるねん…
      • 「現実に耐え切れない人間もいる」
      • 「世界は美しいだけじゃない」

ScalaMatsuri2016

By りりろじ

Made with Slides.com

ScalaMatsuri2016

  • 3,392

More from りりろじ