0

在 scala 中使用上下文边界，您可以执行以下操作

trait HasBuild[T] {
  def build(buildable: T): Something
}

object Builders {
  implict object IntBuilder extends HasBuild[Int] {
    override def build(i: Int) = ??? // Construct a Something however appropriate
  }
}

import Builders._
def foo[T: HasBuild](input: T): Something = implicitly[HasBuild[T]].build(1)
val somethingFormInt = foo(1)

或者干脆

val somethingFromInt = implicitly[HasBuild[Int]].build(1)

我如何表达在范围内Seq具有适当隐式HasBuild对象的任何元素的类型？如果没有太多的魔法和外部库，这可能吗？

Seq[WhatTypeGoesHere]- 我应该能够HasBuild为每个元素找到合适的

这显然不能编译：

val buildables: Seq[_: HasBuild] = ???
4

2 回答 2

1

基本上，我希望能够以一种常见的方式（例如：构建）处理不相关的类型，而无需用户手动将它们包装在某种适配器中 - 并由编译器强制执行，这些类型实际上可以被处理。不知道目的是否明确。

你可以做的事情：

case class HasHasBuild[A](value: A)(implicit val ev: HasBuild[A])
object HasHasBuild {
  implicit def removeEvidence[A](x: HasHasBuild[A]): A = x.value
  implicit def addEvidence[A: HasBuild](x: A): HasHasBuild[A] = HasHasBuild(x)
}

现在（假设您添加了一个HasBuild[String]用于演示）：

val buildables: Seq[HasHasBuild[_]] = Seq(1, "a")

编译，但是

val buildables1: Seq[HasHasBuild[_]] = Seq(1, "a", 1.0)

没有。HasBuild当您只有 a 时，您可以使用带有隐式参数的方法HasHasBuild：

def foo1[A](x: HasHasBuild[A]) = {
  import x.ev // now you have an implicit HasBuild[A] in scope
  foo(x.value)
}

val somethings: Seq[Something] = buildables.map(foo1(_))
于 2016-09-23T14:41:40.487 回答
0

首先，与某些评论相反，您依赖于上下文边界。为 a 请求一个隐式类型类实例T就是所谓的“上下文绑定”。

你想要的是可以实现的，但不是微不足道的，当然也不是没有其他库。

import shapeless.ops.hlist.ToList
import shapeless._
import shapeless.poly_

object builder extends Poly1 {
  implicit def caseGeneric[T : HasBuilder] = {
    at[T](obj => implicitly[HasBuilder[T]].build(obj))
  }
}

class Builder[L <: HList](mappings: L) {
  def build[HL <: HList]()(
    implicit fn: Mapper.Aux[builder.type, L, HL],
    lister: ToList[Something]
  ) = lister(mappings map fn)

  def and[T : HasBuilder](el: T) = new Builder[T :: L](el :: mappings)
}


object Builder {
  def apply[T : HasBuilder](el: T) = new Builder(el :: HNil)
}

现在您可能可以执行以下操作：

Builder(5).and("string").build()

这build将从所有单独的隐式类型类实例中调用方法，并为您提供结果列表，其中每个结果都有 type Something。它依赖于所有构建方法都有一个下限的事实Something，例如根据您的示例：

trait HasBuild[T] {
  def build(buildable: T): Something
}
于 2016-09-23T14:07:40.910 回答