使用Scalaz.ListW键入推理问题。<^&燃气轮机；

我在玩弄，其定义如下：

def <^>[B: Zero](f: NonEmptyList[A] => B): B = value match {
  case Nil => ∅
  case h :: t => f(Scalaz.nel(h, t))
}

现在我有了这些东西的清单。我的目标是为

posns

的最小/最大值返回一个

选项[CC]

，如果没有小于零的值和与最大值类似的值，我将为最小值返回一个

None

scala> import scalaz._; import Scalaz._
import scalaz._
import Scalaz._

scala> implicit val CCOrder = new Order[CC] { 
       | def order(v1 : CC, v2 : CC) = orderBy( (v : CC) => v.v ).order(v1, v2) 
       | }
CCOrder: java.lang.Object with scalaz.Order[CC] = $anon$1@1e48d65

scala> posns.filter(_.v < 0) <^> (_.min)
res0: Option[CC] = None

scala> posns.filter(_.v > 0) <^> (_.max)
res1: Option[CC] = Some(CC(5))

scala>导入scalaz.\uuz；进口Scalaz_
进口scalaz_
进口Scalaz_
scala>隐式val-CCOrder=新顺序[CC]{
|def order（v1:CC，v2:CC）=orderBy（（v:CC）=>v.v.order（v1，v2）
| }
CCOrder:java.lang.Object，带scalaz.Order[CC]=$anon$1@1e48d65
scala>posns.filter（v<0）（v.min）
res0:选项[CC]=无
scala>posns.filter（v.v>0）（v.max）
res1：选项[CC]=Some（CC（5））

---

选项正好是我想要的

Zero

类型！有人能解释一下打字机是如何选择

选项的吗？我哪里都没有申报
 列表w#

和

MA#min

的定义：

sealed trait MA[M[_], A] extends PimpedType[M[A]] {
  def min(implicit r: Foldable[M], ord: Order[A]): Option[A] =
    foldl1((x: A, y: A) => if (x ≨ y) x else y)
}

sealed trait ListW[A] extends PimpedType[List[A]] {
  def <^>[B: Zero](f: NonEmptyList[A] => B): B = value match {
    case Nil => ∅
    case h :: t => f(Scalaz.nel(h, t))
  }
}

List@#

如果pimped列表非空，则从

NonEmptyList[A]=>B运行提供的函数，否则返回类型
B
的
0
MA#min
实际上返回
选项[B]
——它是容器的通用函数，而不是
非空列表的特定函数，可以返回a
B

实现这一点更直接的方法是直接调用
MA#min
。不幸的是，
List
已经有了一个
min
函数，这是Scala 2.8中新增的，因此在没有类型提示的情况下，
MA
的隐式视图不会被触发：

posns.filter(_.v < 0).min
<console>:16: error: could not find implicit value for parameter cmp: Ordering[CC]
   posns.filter(_.v < 0).min

(posns.filter(_.v < 0): MA[List, CC]).min
res7: Option[CC] = None

首先，您给出了
MA#max
的定义，而不是
MA#min
。啊。因此，我的下一个问题是——“为什么
min
来自
MA
而不是
Identity
？”@alexey:updated
x.min（y）
来自
Identity
，
xs.min
匹配
MA
。我当然可以立即回答——“因为
Identity#min
有一个完全不同的签名！”我真是个白痴。谢谢
object test {
  import scalaz._
  import Scalaz._

  case class CC(v: Int)
  val posns = List(CC(2), CC(5), CC(1))
  val filtered = posns.filter(((x$1: CC) => x$1.v.<(0)))
  val listw = Scalaz.ListTo[CC](posns.filter(((x$1: CC) => x$1.v.<(0))))
  listw.<^>[Option[CC]]{
    (x$2: scalaz.NonEmptyList[CC]) =>
      Scalaz.maImplicit[scalaz.NonEmptyList, CC](x$2).min(Foldable.NonEmptyListFoldable, CCOrder)
  }(Zero.OptionZero[CC]);
}

posns.filter(_.v < 0).min
<console>:16: error: could not find implicit value for parameter cmp: Ordering[CC]
   posns.filter(_.v < 0).min

(posns.filter(_.v < 0): MA[List, CC]).min
res7: Option[CC] = None

implicit val CCOrder: Order[CC] = orderBy(_.v)
CCOrder: scalaz.Order[CC] = scalaz.Orders$$anon$2@fc2528