Aux Pattern для старших типов - PullRequest
Новая
       28

Aux Pattern для старших типов

0 голосов
/ 30 сентября 2018

РЕДАКТИРОВАТЬ: Вот гораздо более простая формулировка проблемы, используя Foo в качестве примера шаблона Aux, который работает работает: 

// Foo is a simple Aux-pattern type
trait Foo[A, B] { type Out }

object Foo {
  type Aux[A, B, C] = Foo[A, B] { type Out = C }
  // One instance, turning Int+String into Boolean
  implicit val instance: Foo.Aux[Int, String, Boolean] = null
}

// Wrapper is exactly the same but contains a higher-kinded type
trait Wrapper[A, B] { type Contract[_] }

object Wrapper {
  type Aux[A, B, C[_]] = Wrapper[A, B] { type Contract[_] = C[_] }
  // One instance, linking Int + String to Option
  implicit val instance: Wrapper.Aux[Int, String, Option] = null
}

// Same test for both
def fooTest[A, B, C](implicit ev: Foo.Aux[A, B, C]): C = ???
def wrapperTest[X[_]](implicit ev: Wrapper.Aux[Int, String, X]): X[Boolean] = ???

// Compiles as expected
fooTest: Boolean

// Does not compile: could not find implicit value for parameter ev: Wrapper.Aux[Int,String,X]
wrapperTest: Option[Boolean]

// Does compile:
wrapperTest(implicitly[Wrapper.Aux[Int, String, Option]]): Option[Boolean]

Старая формулировка вопроса:

Извинения за замысловатый пример ниже.По сути, я хочу продублировать шаблон Aux для типов с более высоким родом.

Scala: 

// Foo is a normal Aux pattern calculation
trait Foo[A, B] { type Out }

object Foo {
  type Aux[A, B, C] = Foo[A, B] { type Out = C }
  // Foo turns Int + String into Boolean
  implicit val intInstance: Foo.Aux[Int, String, Boolean] = null
}

// Wrapper is supposed to be a type-level computation across
// type-level functions
// It takes two types and binds them with a contract (a nested
// type-level function)
trait Wrapper[A, B] { type Contract[X] }

object Wrapper {
  type Aux[A, B, C[_]] = Wrapper[A, B] { type Contract[X] = C[X] }

  // It has one instance: It binds Int and String to the type-level
  // function Foo.
  implicit val fooWrapper: Wrapper.Aux[Int, String, Foo.Aux[Int, String, ?]] = null

}

object Testing {

  trait TestResult[X]

  // We summon a Contr, which is provided by Wrapper
  // The idea is we get the result of Foo's computation without summoning
  // Foo explicitly. This allows us to easily swap Foo out for another
  // Function if we desire
  implicit def testing[A, B, Contr[_], X](
    implicit wrapper: Wrapper.Aux[A, B, Contr],
    foo: Contr[X]
  ): TestResult[X] = ???


  // Compiles as expected
  implicitly[Wrapper.Aux[Int, String, Foo.Aux[Int, String, ?]]]
  implicitly[Wrapper[Int, String]]
  implicitly[Foo.Aux[Int, String, Boolean]]
  implicitly[Foo[Int, String]]
  val result1: TestResult[Boolean] = testing[Int, String, Foo.Aux[Int, String, ?], Boolean]

  // Does not compile
  val result2: TestResult[Boolean] = testing
  implicitly[TestResult[Boolean]]
}

Это то, что я ожидаю произойти в этой последней строке:

  • Мы ищем TestResult[Boolean]
  • testing говорит, что нам нужно Contr[Boolean] для некоторых Contr, предоставляемых Wrapper
  • Wrapper тодин экземпляр Contr[_] = Foo.Aux[Int, String, ?]
  • Таким образом, компилятор ищет Foo.Aux[Int, String, Boolean]
  • Существует один такой экземпляр, предоставленный Foo
  • Так что все компилируется

Вот мой build.sbt на случай, если я что-то упустил: 

scalaVersion := "2.12.6"

scalacOptions := Seq(
  "-language:existentials",
  "-language:higherKinds",
  "-Ypartial-unification",  // EDIT
)

addCompilerPlugin("org.spire-math" %% "kind-projector" % "0.9.8")

Ответы [ 2 ]

0 голосов
/ 04 октября 2018

Вы нашли интересный обходной путь, но исходная проблема действительно является ошибкой: scala / bug # 10849 , которая была исправлена ​​в Scala 2.13: scala / scala # 6573 .К сожалению, его нельзя перенести на 2.12, потому что он меняет способ работы с типами, и это деликатная часть компилятора, которая даже не определяется.Но вы можете попробовать это с Scala 2.13.0-M4 или 2.13.0-M5.

0 голосов
/ 01 октября 2018

Вот решение, которое я придумала: 

trait Wrapper[A, B] { type Contract[_] }

object Wrapper {
  type Aux[A, B, C[_]] = Wrapper[A, B] { type Contract[_] = C[_] }
  // One instance, linking Int + String to Option
  implicit def instance[A, B](implicit ev1: A =:= Int, ev2: B =:= String): Wrapper.Aux[A, B, Option] = null

}

object Testing {

  def wrapperTest[A, B, X[_]](implicit ev: Wrapper.Aux[A, B, X]): X[Boolean] = ???

  // These compile now!!
  wrapperTest
  wrapperTest: Option[Boolean]

  // Do NOT compile, as expected
  // wrapperTest[Boolean, Char, Option]: Option[Boolean]
  // wrapperTest[Int, String, List]: Option[Boolean]

}

Я не знаю почему работает точно, но похоже на свободу A и B позволяют компилятору сосредоточиться на правильном разрешении X[_], и тогда ограничения на A и B происходят на другом уровне, поэтому мы достигаем той же функциональности в конце.

...