slides/day4.html

<!doctype html>
<html>
	<head>
		<meta charset="utf-8">
		<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">

		<title>Implicit значения и преобразования. Тайпклассы. Чтение и запись JSON в play-json.</title>

		<link rel="stylesheet" href="css/reveal.css">
		<link rel="stylesheet" href="css/theme/moon.css">

		<!-- Theme used for syntax highlighting of code -->
		<link rel="stylesheet" href="lib/css/zenburn.css">

		<!-- Printing and PDF exports -->
		<script>
			var link = document.createElement( 'link' );
			link.rel = 'stylesheet';
			link.type = 'text/css';
			link.href = window.location.search.match( /print-pdf/gi ) ? 'css/print/pdf.css' : 'css/print/paper.css';
			document.getElementsByTagName( 'head' )[0].appendChild( link );
		</script>
	</head>
	<body>
		<div class="reveal">
			<div class="slides">
				<section>
					<h3>Часть 4. Implicit значения и преобразования. Тайпклассы. Чтение и запись JSON в play-json.</h3>
					<p><small>Страничка курса: <a href="https://maxcom.github.io/scala-course-2022/">https://maxcom.github.io/scala-course-2022/</small></a>
				</section>

				<section>
					<h3>План</h3>
					<p>Последняя лекция про язык Scala
					<ol>
						<li>Implicit значения
						<li>Передача контекста и конфигурации
						<li>“pimp my library”
						<li>Тайпклассы (примеры из Cats)
						<li>Тайп классы на примере Play-JSON
					</ol>
				</section>

				<section>
					<p>"Неявные" значения и преобразования</p>
					<ul>
						<li>Уникальная конструкция, существующая только в Scala.
						<li class=fragment>Множество разных применений
						<li class=fragment>В Scala 3 многие применения получили свой синтаксис
					</ul>
				</section>

				<section>
					<h4>Неявные значения для передачи контекста</h4>
				</section>

				<section>
					<p>Дополнительный блок параметров функции
					<pre><code class="scala">
def getUser(id: Int)(implicit session: DatabaseSession): User
					</code></pre>
					<p>значения которого можно явно не задавать
				</section>

				<section>
					<p>Без implicit значения пришлось бы
					<ul>
						<li>Явно передавать значения
						<li>Передавать неявно через thread local и "магию" Java-фреймворков
					</ul>
				</section>

				<section>
					<p>Значение должно существовать в области видимости
					<pre><code class="scala">
DB localTx { implicit session =&gt;
  getUser(10)
}					
					</code></pre>
					<p>при необходимости можно передать явно
					<pre><code class="scala">// implicit тут не нужен, но не мешает
DB localTx { implicit session =&gt;
  getUser(10)(session)
}					
					</code></pre>

				</section>

				<section>
					<p>Где это применяется? <br>Для передачи контекста
					<ul>
						<li>сессии/транзакции БД
						<li>конфигурации
						<li>свойств запроса (права, язык, таймзона и т.п.)
						<li>...
					</ul>
				</section>

				<section>
					<p>for может использовать flatMap/map с<br> implicit параметром
				</section>

				<section>
					<p>implicit значения ищутся в
					<ul>
						<li>области видимости
						<li>import'ах - сначала в точных, потом в wildcard
						<li>companion object связанных типов
					</ul>
					<p>implicit контекст обычно в области видимости
				</section>

				<section>
					<p>Неоднозначности при поиске на одном уровне - ошибка компиляции
				</section>

				<section>
					<h4>Неявные классы</h4>
				</section>

				<section>
					<p>Преобразование одного класса в другой
					<pre><code class="scala">
implicit class RichString(str: String)
					</code></pre>
					<p>автоматическое преобразование там, где необходимо
				</section>

				<section>
					<p>"Pimp my library" - прием из динамических языков, например Ruby
				</section>

				<section>
					<p>В Ruby код может "улучшить" любой класс, даже стандартную библиотеку
					
					<p>"Monkey patching" - весьма опасная техника
				</section>

				<section>
					<p>Опасности:
					<ul>
						<li>Нарушение инкапсуляции
						<li class="fragment">Проблемы при обновлении - неявные зависимости на реализацию
						<li class="fragment">Конфликты разных "улучшателей"
						<li class="fragment">"Ад зависимостей" - даже минорное обновление
						может всё сломать
						<li class="fragment">Сложности отладки
					</ul>
				</section>

				<section>
					<p>Implicit class - безопасная замена этой техники
				</section>

				<section>
					<p>Пример - добавляем метод в String
					<pre><code class="scala">
// дальше будет более эффективная реализация
// название класса значения не имеет
implicit class RichString(str: String) {
  def letters = str.count(_.isLetter)
}

"scala 2.12".letters // = 5
					</code></pre>
					<ul>
						<li>для использования должен быть в области видимости
						<li>разрешается в процессе компиляции
						<li>не влияет на существующий код
					</ul>
				</section>

				<section>
					<p>Более правильная версия примера:
					<pre><code class="scala">
implicit class RichString(val str: String) extends AnyVal {
  def letters = str.count(_.isLetter)
}
					</code></pre>
					<p>класс существует только в compile time
					<p><small>AnyVal можно использовать для оптимизации, но осторожно.<br>
					Есть другие варианты, например tagged types</small>
				</section>

				<section>
					<p>Технику применяют для "красоты", например:
					<pre><code class="scala">
import scala.concurrent.duration._

val timeout: Duration = 5.minutes
// замена Duration(5, TimeUnit.MINUTES)
					</code></pre>
					<p><small>еще пример - DSL в scalatest/specs2 </small>
				</section>

				<section>
					<h4>Тайпклассы</h4>
					<p>Typeclass - шаблон проектирования, построенный на
					использовании implicit преобразований.
				</section>

				<section>
					<p>Рассмотрим реализацию .sum для List[Int]:
					<pre><code class="scala">
def sum(list: List[Int]): Int = list.foldLeft(0)(_ + _)
					</code></pre>
					<div class=fragment>
					<p>Как её обобщить для нашего типа значений?
					<pre><code class="scala">
// наш собственный тип значений
case class BusValue(amount: Int)
					</code></pre>
					</div>
				</section>

				<section>
					<p>Нужно два элемента:
					<ul>
						<li>Нулевой элемент
						<li>Функция "сложения"
					</ul>
				</section>

				<section>
					<p>Проблема с ООП:
					<ul>
						<li>нужно как-то из типа добраться до "нуля", но<br>
						нет общего механизма доступа к данным и методам типа
						<li class=fragment>trait для метода сложения, но
						trait можно добавить только к "нашим" типам.
						<li class=fragment>и еще trait'ов может быть много
					</ul>
				</section>

				<section>
					<pre><code class="scala">
//  упрощенная реализация на основе исходников Cats
def combineAll[A](fa: Seq[A])(implicit m: Monoid[A]): A =
  fa.foldLeft(m.empty) { (acc, a) =&gt;
    m.combine(acc, a)
  }
					</code></pre>
					<p><small>Monoid есть в Cats и др. библиотеках,<br> можете сделать свой</small>
				</section>

				<section>
					<pre><code class="scala">
implicit val busMonoid: Monoid[BusValue] =
  new Monoid[BusValue] {
    override val empty = BusValue(0)

    override def combine(x: BusValue, y: BusValue): BusValue =
      BusValue(x.amount + y.amount)
  }
					</code></pre>
					monoid может объявить для любого типа,<br> даже "чужого"
				</section>

				<section>
					Требования к моноиду:
					<pre><code class="scala">
 // ассоциативность
combine(x, combine(y, z)) = combine(combine(x, y), z)
					</code></pre>

					<pre><code class="scala">
combine(x, empty) = combine(empty, x) = x
					</code></pre>
					коммутативность не требуется!
				</section>

				<section>
					<p>Примеры:</p>
					<ul>
						<li>Числа и операция сложения, empty = 0
						<li class=fragment>Числа и операция умножения, empty = 1
						<li class=fragment>Конкатенация строк, empty = ""
						<li class=fragment>Коллекции, empty = пустая коллекция
					</ul>
				</section>

				<section>
					<p>Примеры:
					<pre><code class="scala">
import cats.implicits._

implicit val busMonoid: Monoid[BusValue] = ???

// pimp my library
Vector(BusValue(1), BusValue(9000)).combineAll
					</code></pre>
					<p><small>для Seq нужна новая версия Cats</small>
				</section>

				<section>
					<p>NonEmptyList - не моноид, а полугруппа (Semigroup)
					<p class=fragment>Обладает ассоциативным методом combine
				</section>

				<section>
					Красивая операция "сложения" для Semigroup:
					<pre><code class="scala">
BusValue(1) |+| BusValue(9000)

// Monoid - это наследник Semigroup,
// так что работает и для моноидов
					</code></pre>
				</section>

				<section>
					Более полезное применение:
					<pre><code class="scala">
val one = Map("first" -&gt; BusValue(1), "second" -&gt; BusValue(2))
val two = Map("second" -&gt; BusValue(3), "third" -&gt; BusValue(3))

one ++ two // "second" первого заменен на второй
one |+| two // "second" складывается

// Map("first" -&gt; BusValue(1), 
//   "second" -&gt; BusValue(5), 
//   "third" -&gt; BusValue(3))
					</code></pre>
				</section>

				<section>
					<p>Как это работает?
					<p>Еще один механизм - неявное преобразование
					<pre><code class="scala">
// неявное преобразование моноида для значения
// в моноид для Map
implicit def monoidForMap[K, V]
              (implicit ev: Monoid[V]): Monoid[Map[K, V]] =
                 new MapMonoid[K, V]
					</code></pre>
					<p>Если значение не Monoid, то и Map нет.
				</section>

				<section>
					<p>Вывод преобразований - рекурсивный
				</section>

				<section>
					<p>Еще раз посмотрим на этот код
					<pre><code class="scala">
// неявное преобразование моноида для значения
// в моноид для Map
implicit def monoidForMap[K, V]
              (implicit ev: Monoid[V]): Monoid[Map[K, V]] =
                 new MapMonoid[K, V]
					</code></pre>
					<p>ev не используем, а только передаем 

					<pre><code class="scala">
// context bounds
implicit def monoidForMap[K, V : Semigroup]: Monoid[Map[K, V]] =
  new MapMonoid[K, V]
					</code></pre>
				</section>

				<section>
					<p>Тайпклассы можно объявить для<br>более интересных конструкций.
					<p> 6-я лекция: Cats и Circe
				</section>

				<section>
					<h2>Конец первой части</h2>
					<p>далее работа с тайпклассами на примере play-json
				</section>

				<section>
					<p>Что же такое тайпклассы?
					<p>Способ реализации некой абстрактной функциональности вне данных, с которыми она связана.
				</section>

				<section>
					<h4>JSON</h4>
					<p>Текстовый формат обмена данными.
					<p>Пришел на замену XML, который оказался
					слишком сложным и слишком медленным.
				</section>

				<section>
					<p>Использует синтаксис объявления данных JavaScript
					<pre><code class="json">
{
   "firstName": "Иван",
   "lastName": "Иванов",
   "address": {
       "streetAddress": "Московское ш., 101, кв.101",
       "city": "Ленинград",
       "postalCode": 101101
   },
   "phoneNumbers": [
       "812 123-1234",
       "916 123-4567"
   ]
}					
					</code></pre>
				</section>

				<section>
					<p>Формально описан в <a target="_blank" href="https://trac.tools.ietf.org/html/rfc8259">rfc8259</a>

					<p>Весь стандарт - 16 страниц текста, включая оглавления, ссылки и т.п.
				</section>

				<section>
					<p>Json легко читается (если отформатировать)

					<p class="fragment">Библиотеки для работы с ним есть
					для большинства языков программирования.
				</section>

				<section>
					<p>Формат JSON был разработан<br>Дугласом Крокфордом.
					<p>Видео: <a target="_blank" href="https://www.youtube.com/watch?v=-C-JoyNuQJs">The JSON Saga</a>
					<p>"The Software shall be used for Good, not Evil."
				</section>

				<section>
					<p>Используем библиотеку Play JSON.

					<p>Часть play-framework; можно использовать отдельно.

					<p>Circe, другая библиотека, будет на лекции про Cats
				</section>

				<section>
					<p>Документация:
					<ul>
						<li><a target="_blank" href="https://www.playframework.com/documentation/2.8.x/ScalaJson">JSON Basics</a>
						<li><a target="_blank" href="https://www.playframework.com/documentation/2.8.x/ScalaJsonCombinators">JSON Reads/Writes/Format Combinators</a>
						<li><a target="_blank" href="https://www.playframework.com/documentation/2.8.x/ScalaJsonAutomated">JSON automated mapping</a>
					</ul>
				</section>

				<section>
					<p>Подключаем библиотеку в проект

					<pre><code class="scala">
libraryDependencies += 
  "com.typesafe.play" %% "play-json" % "2.8.2"
					</code></pre>
				</section>

				<section>
					<p>JsValue - алгебраический тип

					<ul>
						<li>JsArray
						<li>JsBoolean (JsTrue/JsFalse)
						<li>JsNumber
						<li>JsObject
						<li>JsString
						<li>JsNull
					</ul>
				</section>

				<section>
					<p>Запись JSON
					<pre><code class="scala">
import play.api.libs.json._

val v: JsValue = JsObject(Seq(
  "id" -&gt; JsNumber(1),
  "name" -&gt; JsString("Vasya"),
  "marks" -&gt; JsArray(Seq(JsNumber(2), JsNumber(3)))
))

Json.stringify(v) // компактный формат
Json.prettyPrint(v) // с форматированием			
					</code></pre>
					<p>pretty print используем только для отладки
				</section>

				<section>
					<p>Большие структуры так выводить не удобно. 
					<p>Хотим выводить JSON для наших case-классов, коллекций и т.п.
				</section>

				<section>
					<p>Какие есть варианты?
				</section>

				<section>
					<p>Pattern matching?

					<p class="fragment">Не походит - мало операций,<br> много вариаций данных.
				</section>

				<section>
					<p>Объектный полиморфизм? Возможно

					<pre><code class="scala">
trait Writable {
  def toJson: JsValue
}					
					</code></pre>

					<ul>
						<li class=fragment>trait не добавить к стандартным коллекциям
						<li class="fragment">trait не добавить к сторонним классам
						<li class="fragment">смешивается основная логика и доп. функции
					</ul>
				</section>

				<section>
					<p>Reflection? Да, это "Java-way".

					<p>В runtime запрашиваем структуру объекта средствами JVM и выводим её.
				</section>

				<section>
					<p>Однако:

					<ul>
						<li>Не типобезопасно: можно вывести что-то не то, например сессию БД или внутренний
						пароль
						<li class="fragment">Медленно
						<li class="fragment">Трудности с настройкой формата вывода
						<li class="fragment">Нельзя использовать контекст при выводе
				</section>

				<section>
					<p>Решение - тайпкласс, как еще один вариант полиморфизма.
				</section>

				<section>
					<pre><code class="scala">
// упрощенный код
trait Writes[A] {
  def writes(o: A): JsValue
}
					</code></pre>
					<p>использование
					<pre><code class="scala">
object Json {
  def toJson[T](o: T)(implicit tjs: Writes[T]): JsValue = 
    tjs.writes(o)

  ...
}
					</code></pre>
				</section>

				<section>
					<p>Для примитивных типов готовая реализация

					<pre><code class="scala">
Json.toJson("some string")					
					</code></pre>
					<p>реализация
					<pre><code class="scala">
// из play-json
implicit object StringWrites extends Writes[String] {
  def writes(o: String) = JsString(o)
}
					</code></pre>
				</section>

				<section>
					<p>Для Seq нужно преобразование
					<pre><code class="scala">// реализация из play-json
implicit def traversableWrites[A](implicit w: Writes[A]): 
    Writes[Traversable[A]] = {

  Writes[Traversable[A]] { as =&gt;
    val builder = mutable.ArrayBuilder.make[JsValue]()
    as.foreach { a =&gt;
      builder += w.writes(a)
    }
    JsArray(builder.result())
  }
}

Json.toJson(Seq("some string", "second string"))
// ["some string", "second string"]</code></pre>
					<small>Типобезопасно - работает только если для элементов есть Writes</small>
				</section>

				<section>
					<p>Выводим case-класс
					<pre><code class="scala">import play.api.libs.json._

case class User(id: UUID, name: String, title: Option[String])

object User { // объявляем в companion object
  // OWrites вместо Writes (возвращает JsObject)
  // используем Writes.apply
  implicit val writes: OWrites[User] = OWrites { user =&gt;
    Json.obj( // сам использует Writes для значений
      "id" -&gt; user.id,
      "name" -&gt; user.name,
      "title" -&gt; user.title 
    )
  }
} </code></pre>
				</section>

				<section>
					<p>Для простых случаев есть макрос
					<pre><code class="scala">
object User {
  implicit val writes: OWrites[User] = Json.writes[User]
}					
					</code></pre>
				</section>

				<section>
					<p>Writes может зависеть от контекста
					<pre><code class="scala">
// writes зависит от языка пользователя
implicit def writes(implicit lang: Lang): OWrites[User] = ???
					</code></pre>
				</section>

				<section>
					<p>Такой полиморфизм работает в компиляторе, типы должны быть точно известны.
					<p>Абстрактные типы записать не сможем.
				</section>

				<section>
					<p>Записываем выражение калькулятора<br>из первой лекции
					<pre><code class="scala">
// один Writes для всего ADT
object Expr {
  implicit val writes: Writes[Expr] = Writes {
    case Number(value) ⇒ 
      JsNumber(value)
    case Plus(lhs, rhs) ⇒ 
      Json.obj("op" -&gt; "plus", "left" -&gt; lhs, "right" -&gt; rhs)
    case Minus(lhs, rhs) ⇒ 
      Json.obj("op" -&gt; "minus", "left" -&gt; lhs, "right" -&gt; rhs)
  }
}
					</code></pre>
					(макрос из play умеет простые ADT)
				</section>

				<section>
					<p>Итого мы получили:
					<ul>
						<li>Эффективный скомпилированный код
						<li class="fragment">Типобезопасность
						<li class="fragment">Код записи JSON отделен от данных
						<li class="fragment">Возможности по кастомизации, использование контекста
					</ul>
				</section>

				<section>
					<h4>Чтение JSON и валидация</h4>
					<p>Тайпкласс Reads для чтения
					<pre><code class="scala">
trait Reads[A] {
  def reads(json: JsValue): JsResult[A]
}
					</code></pre>
					<p>есть макрос Json.writes[A]</p>
				</section>

				<section>
					<p>JsResult - алгебраический тип
					<ul>
						<li>JsSuccess - успех
						<li>JsError - ошибка; внутри список ошибок с путями
					</ul>
				</section>

				<section>
					<pre><code class="scala">
val v: JsValue = Json.arr("str1", "str2")

v.validate[Seq[String]] 
// JsSuccess(List("str1", "str2"))

v.as[Seq[String]] // значение или Exception
// List("str1", "str2")
					</code></pre>
				</section>

				<section>
					<p>Case class: плохой вариант
					<pre><code class="scala">
case class User(id: UUID, name: String, title: Option[String])

object User {
  implicit val reads: Reads[User] = Reads[User] { json ⇒
    JsSuccess(User(
      id = (json \ "id").as[UUID],
      name = (json \ "name").as[String],
      title = (json \ "title").asOpt[String]
    ))
  }
}
					</code></pre>

					<p>Exception вместо JsError;<br>
					диагностика только по номерам строк
				</section>

				<section>
					<p>JsResult - монада
					
					<pre><code class="scala">
implicit val reads: Reads[User] = Reads[User] { json ⇒
  for {
    id &lt;- (json \ "id").validate[UUID]
    name &lt;- (json \ "name").validate[String]
    title &lt;- (json \ "title").validateOpt[String]
  } yield {
    User(id, name, title)
  }
}
					</code></pre>
					<p>Исключений больше нет,<br> но потеряли пути ошибок
				</section>

				<section>
					<p>Вместо работы над значениями будем конструировать функцию
				</section>

				<section>
					<pre><code class="scala">
val v: JsValue = ???
val r: JsLookupResult = v \ "id" 
// результат поиска

val path: JsPath = __ \ "id"
// путь, не привязанный к значению
					</code></pre>
				</section>

				<section>
					<p>Строим Reads
					<pre><code class="scala">
// метод JsPath
def read[T](implicit r: Reads[T]): Reads[T]
					</code></pre>
					<p>Использование
					<pre><code class="scala">
val idReads: Reads[UUID] = (__ \ "id").read[UUID]
					</code></pre>
					<p>при ошибке путь будет добавлен в JsError
				</section>

				<section>
					<p>Reads - тоже монада
					<pre><code class="scala">
// тут мы уже не парсим значение, а собираем функцию парсинга
implicit val reads: Reads[User] = 
  for {
    id &lt;- (__ \ "id").read[UUID]
    name &lt;- (__ \ "name").read[String]
    title &lt;- (__ \ "title").readNullable[String]
  } yield {
    User(id, name, title)
  }
					</code></pre>
					JsError, никаких исключений.<br>
					В ошибке закодирован путь
					</ul>
				</section>

				<section>
					<p>Что не так?

					<p class="fragment">Монада - абстракция цепочки вычислений.<br>

					У нас же все вычисления независимые,<br>кроме шага сборки.
				</section>

				<section>
					<p>Еще плохо - ошибка только первая;<br> надо выдать все ошибки.

					<p class="fragment">Монада тут - плохая абстракция.
				</section>

				<section>
					<p>На помощь приходит<br>аппликативный функтор.
					<p>О нем поговорим на лекции про Cats.
				</section>

				<section>
					<p>Reads имеет операцию сборки: пару Reads можно собрать в
					Reads пары (аналогично для троек и т.д.).

					<p class="fragment">При сборке ошибки "складываются".
				</section>

				<section>
					<p>Синтаксис:
					<pre><code class="scala">
import play.api.libs.json._
import play.api.libs.functional.syntax._
					
val combined: Reads[(UUID, String, Option[String])] = (
  (__ \ "id").read[UUID] and
  (__ \ "name").read[String] and
  (__ \ "title").readNullable[String]).tupled

val userReads: Reads[User] = 
  combined.map((User.apply _).tupled)  
					</code></pre>
				</section>

				<section>
					<p>Более удобный синтаксис:
					<pre><code class="scala">
val userReads: Reads[User] = (
  (__ \ "id").read[UUID] and
  (__ \ "name").read[String] and
  (__ \ "title").readNullable[String])(User.apply _)
					</code></pre>
				</section>

				<section>
					<p>Итого что мы получили:
					<ul>
						<li>Удобный язык описания парсинга
						<li>JsError для ошибок, никаких исключений
						<li>Все ошибки с путями
						<li>Всё множество ошибок, а не только первая
					</ul>
				</section>

				<section>
					<p>Полезные инструменты:

					<p>Используем готовые Reads

					<pre><code class="scala">
Reads.of[Int].map(Number.apply)

// аналог
implicitly[Reads[Int]].map(Number.apply)
					</code></pre>
				</section>

				<section>
					<p>Валидация значений:
					<pre><code class="scala">
import play.api.libs.json.{JsonValidationError ⇒ JsErr}

Reads.of[Int].filter(JsErr("must be positive"))(_ &gt; 0)
					</code></pre>
				</section>

				<section>
					<p>Разбор алгебраического типа
					<pre><code class="scala">
import play.api.libs.json.{JsonValidationError ⇒ JsErr}

sealed trait Numbers
case object One extends Numbers
case object Two extends Numbers
case object Three extends Numbers

val reads: Reads[Numbers] = 
  Reads.of[String].collect(JsErr("bad number")) {
    case "one"   ⇒ One
    case "two"   ⇒ Two
    case "three" ⇒ Three  
}
					</code></pre>
				</section>

				<section>
					<p>Напоминаю:
					<ul>
						<li>Страничка курса: <a href="https://maxcom.github.io/scala-course-2022/">https://maxcom.github.io/scala-course-2022/</a>
					</ul>
				</section>
			</div>

		</div>

		<script src="lib/js/head.min.js"></script>
		<script src="js/reveal.js"></script>

		<script>
			// More info about config & dependencies:
			// - https://github.com/hakimel/reveal.js#configuration
			// - https://github.com/hakimel/reveal.js#dependencies
			Reveal.initialize({
                                controls: true,
                                progress: true,
                                history: true,
                                center: true,

                                transition: 'slide', // none/fade/slide/convex/concave/zoom

				dependencies: [
					{ src: 'plugin/markdown/marked.js' },
					{ src: 'plugin/markdown/markdown.js' },
					{ src: 'plugin/notes/notes.js', async: true },
					{ src: 'plugin/highlight/highlight.js', async: true, callback: function() { hljs.initHighlightingOnLoad(); } }
				]
			});
		</script>
	</body>
</html>