Контравариантный функтор в Scala Cats

В этой статье мы поговорим о функторах. О функторах из библиотеки Cats, а не о классических функторах, которые мы все знаем и любим. Рассмотрим контравариантные функторы (Contravariant Functors), представленные в Cats в виде тайпкласса Contravariant.

Некоторые из вас, возможно, не знают, что классический функтор (Functor) с операцией map, который мы ежедневно используем в наших Scala Cats-проектах, на самом деле является ковариантным функтором (Covariant Functor). Также хочу отметить, что термин «Вариантность» (Variance) применительно к функторам не имеет ничего общего с различными видами вариативности, которые мы знаем, когда речь идет о типах и параметрическом полиморфизме.

Типичный функтор в терминах функционального программирования Scala представляет собой тайпкласс, оперирующий типами высших порядков (higher-kinded type), что оказывается весьма полезным, когда мы хотим абстрагироваться и обобщить наши API.

Для полноты картины, поскольку мы не будем говорить классических функторах, давайте посмотрим на простой пример:

  def reverseStringOption(opt: Option[String]): Option[String] = opt.map(_.reverse)   def reverseStringList(lst: List[String]): List[String] = lst.map(_.reverse)   def reverseStringTry(t: Try[String]): Try[String] = t.map(_.reverse)    //generalized version   def reverse[F[_]](container: F[String])(implicit functor: Functor[F]): F[String] =      functor.map(container)(_.reverse)

Обобщенная версия reverse не зависит от типа обертки, которую мы хотим использовать, если в области видимости есть экземпляр Functor. В Cats это обычно происходит при импорте, например, Option:

import cats.instances.option._

Итак, я уверен, что вы все это уже знали. Функторы повсюду, и мы часто их используем. Аппликативы (Applicative) — это функторы, монады (Monad) — это функторы, даже простая функция с одним параметром (Function1) — это тоже функтор. Суть функтора (Functor) в методе map, преобразующим обернутое значение типа A в тип B с сохранением обертки.

def map[A, B](fa: F[A])(f: A => B): F[B]

Но хотите верьте, хотите нет, бывают случаи, когда мы хотим поменять местами типы в функции Functor f, чтобы она принимала тип B и возвращала тип A, но сохранила возвращаемую обертку для типа B — запутались? Если да, то читайте дальше — эта статья как раз для вас :).

Представьте себе простой тайпкласс, преобразующий некоторый тип T в Boolean. Определим его как простой трейт Filter:

 trait Filter[T] {     def filter(value: T): Boolean   }

Для работы с нашим тайпклассом создадим очень простой экземпляр и интерфейс:

implicit object StringFilter extends Filter[String] {     override def filter(value: String): Boolean = value.length > 5   }    def filter[A](v: A)(implicit flt: Filter[A]) = flt.filter(v)    def main(args: Array[String]): Unit = {     println(filter("hello"))     println(filter("hello world!"))   }

Извините, что я не придумал здесь ничего более умного 🙂 — реализация здесь не важна. Конечно, первый println выведет false, а второй — true.

Теперь представьте, что вам нужна функциональность функтора для тайпкласса Filter, чтобы преобразовать его из Filter[String] в Filter[Int] с помощью метода map:

  val simpleFilterFunctor = new Functor[Filter] {     override def map[A, B](fa: Filter[A])(f: A => B): Filter[B] = new Filter[B] {       override def filter(value: B): Boolean = ??? //fa.filter(f(value))     }   }

Видите ли вы проблему, с которой мы здесь столкнулись? Мы не можем передать значение в функцию f, поскольку нельзя использовать тип B в качестве входных данных для функции f. Здесь нам нужен тип A.

Другими словами, мы хотим получить A => Boolean из B => Boolean, имея функцию A => B.

Как это сделать? Нужно использовать контравариантный функтор вместо ковариантного. В Cats тайпкласс, предназначенный для этого, называется просто Contravariant.

  implicit val simpleFilterContravariant = new Contravariant[Filter] {     override def contramap[A, B](fa: Filter[A])(f: B => A): Filter[B] = new Filter[B] {       override def filter(value: B): Boolean = fa.filter(f(value))     }   }

Как вы, вероятно, заметили, тип входного параметра и тип выходного поменялись местами:

def map[A, B](initialValue: F[A])(f: A => B): F[B] def contramap[A, B](fa: F[A])(f: B => A): F[B]

Композиция с контравариантным функтором (Contravariant) так же проста, как и с обычным ковариантным:

  //add companion object apply to easily instantiante filters   object Filter {     def apply[A](implicit instance: Filter[A]): Filter[A] = instance   }    //our existing filter (implicit defined earlier)   val filterString = Filter[String]    //our composed filter   implicit val filterInt: Filter[Int] = Contravariant[Filter].contramap[String, Int](filterString)(_.toString)    def main(args: Array[String]): Unit = {     println(filter(3))   }

Аналогично мы можем использовать Contravariant для работы с обернутыми значениями, например, в Option. Типичный пример с Show[_] из Cats:

  val showInts = Show[Int]   implicit val showOption: Show[Option[Int]] = Contravariant[Show].contramap(showInts)(_.getOrElse(0))    def main(args: Array[String]): Unit = {     import cats.syntax.show._     val x = Option(234)     x.show   }

или более кратко:

import cats.syntax.contravariant._ val showInts = Show[Int] implicit val showOption: Show[Option[Int]] = showInts.contramap(_.getOrElse(0))

Таким образом, для фильтров мы можем использовать любые типы, обернутые в Option:

  implicit def filterOption[T](implicit flt: Filter[T]): Filter[Option[T]] =      simpleFilterContravariant.contramap(flt)(_.get)    def main(args: Array[String]): Unit = {     println(filter(Option("some string")))   }

И избавиться от _.get:

  implicit def filterOption[T](implicit flt: Filter[T], m: Monoid[T]): Filter[Option[T]] =     simpleFilterContravariant.contramap(flt)(_.getOrElse(m.empty))    def main(args: Array[String]): Unit = {     import cats.instances.string._     println(filter(Option("some string")))   }

Это все, что касается контравариантных функторов. Надеюсь, что эта тема стала вам более понятна и вы добавили еще один тайпкласс в свой инструментарий. Конечно, в нашей любимой библиотеке Cats есть множество других интересных тайпклассов и даже еще один интересный Functor :), но это я оставлю на потом.

Материал подготовлен в рамках курса «Scala-разработчик».

Всех желающих приглашаем на открытый урок «Разработка простого REST API c помощью HTTP4S и ZIO». На примере построения простого веб сервиса с REST API, разберем основные компоненты (пути, бизнес логика, доступ к данным, документация), а также посмотрим как дружат такие функциональные библиотеки, как http4s, cats, zio в рамках одного приложения. РЕГИСТРАЦИЯ