上下文绑定上的Lambda类型和类型别名的作用

问题描述

我必须写一个与Ordering [Option [T]]绑定的上下文

事实证明解决方案是

def test[T: ({type L[x] = Ordering[Option[x]]})#L](value1: Option[T],value2: Option[T]) = {
  val e = implicitly(Ordering[Option[T]].compare(value1,value2))
}

请参阅How to define a context bound with a higher kinded Type (Type Constructor)

所以对lambda类型玩了一点，以便更好地理解，导致我写了不带lambda类型的版本：

type L[x] = Ordering[Option[x]]

def testN[T: L](value1: Option[T],value2: Option[T]) = {
  implicitly[L[T]].compare(value1,value2)
}

使用lambda类型的许多示例都是针对带有2个参数的类型构造函数，例如MAP [K，V]。

在这种情况下，我们没有这个问题。

所以我只是想知道为什么不拥有这样的东西

def test[T: Ordering[Option]](value1: Option[T],value2))
}

显然它不起作用。我想我已经了解了所有内容，没有定义类型构造函数Ordering[Option[_]]。

我们订购的商品是：

trait OptionOrdering[T] extends Ordering[Option[T]] {
    def optionOrdering: Ordering[T]
    def compare(x: Option[T],y: Option[T]) = (x,y) match {
      case (None,None)       => 0
      case (None,_)          => -1
      case (_,None)          => 1
      case (Some(x),Some(y)) => optionOrdering.compare(x,y)
    }
  }
  implicit def Option[T](implicit ord: Ordering[T]): Ordering[Option[T]] =
    new OptionOrdering[T] { val optionOrdering = ord }

在上面的定义中，Ordering[Option[T]]表示Ordering[Option[T]] forSome {type T}是akka存在的，因此是适当的类型，而不是类型构造函数。

所以，如果我是对的，我们在这里做什么：

({type L[x] = Ordering[Option[x]]})#L

或此处：

type L[x] = Ordering[Option[x]]

正在定义类型构造器Ordering[Option[_]]。

问题1：

1-我的理解正确吗？那是Lambda类型在这里做什么？

2-我在这里有点困惑，因此类型别名使您可以从其他类型构造函数的组成中创建类型构造函数。从某种意义上说，我试图理解具有类型变量的类型别名的正式作用。

scala> type e0 = Ordering[Option[_]]
defined type alias e0

scala> :kind -v e0
e0's kind is A
*
This is a proper type.

scala> type e1[w] = Ordering[Option[w]]
defined type alias e1

scala> :kind -v e1
e1's kind is F[A]
* -> *
This is a type constructor: a 1st-order-kinded type.

scala> 

解决方法

匿名类型构造函数

curl --location --request GET 'http://localhost:3000/api/v2/storefront/account/addresses' \
--header 'Authorization: Bearer your-token'

是命名类型构造函数

({type L[x] = Ordering[Option[x]]})#L

什么是匿名（值）构造函数

type L[x] = Ordering[Option[x]]

是命名（值）构造函数

(x: Int) => x + 1

例如

val f = (x: Int) => x + 1

在Scala 3（Dotty）中，您将可以替换"atrocity"

无论如何，对点状投影仪的需求很少，因为我们拥有 原生类型的lambda，而不是涉及结构性的残暴行为 类型。

具有优美的lambda类型语法

scala> lazy val v: (({type L[x] = Ordering[Option[x]]})#L)[Int] = ???
lazy val v: scala.math.Ordering[Option[Int]] // unevaluated

scala> lazy val v: L[Int] = ???
lazy val v: L[Int] // unevaluated

scala> lazy val v = ((x: Int) => x + 1)(41)
lazy val v: Int // unevaluated

scala> lazy val v = f(41)
lazy val v: Int // unevaluated

上下文绑定语法

Starting dotty REPL...
scala> lazy val v: (({type L[x] = Ordering[Option[x]]})#L)[Int] = ???
lazy val v: Ordering[Option[Int]]

scala> lazy val v: ([x] =>> Ordering[Option[x]])[Int] = ???
lazy val v: Ordering[Option[Int]]

等同于

def test[T: ({type L[x] = Ordering[Option[x]]})#L](value1: Option[T],value2: Option[T]) = ???

简化为

def test[T](value1: Option[T],value2: Option[T])(implicit ev: (({type L[x] = Ordering[Option[x]]})#L)[T]) = ???