将无形状 HList 转换为元组

Question

我在 Scala 中有这个版本的try-with-resources。我想知道是否可以使用无形和HList制作一个通用版本？

import scala.util.{Failure, Success, Try}
class Loan1[A <: AutoCloseable](resource: A) {
def to[B](block: A => B): B = {
Try(block(resource)) match {
case Success(result) =>
resource.close()
result
case Failure(e) =>
resource.close()
throw e
}
}
}
class Loan2[A <: AutoCloseable, B <: AutoCloseable](r1: A, r2: B){
def to[R](block: (A,B) => R): R = {
Try(block(r1,r2)) match {
case Success(result) =>
r1.close(); r2.close()
result
case Failure(e) =>
r1.close(); r2.close()
throw e
}
}
}
object Loan {
def apply[A <: AutoCloseable](resource: A): Loan1[A] = new Loan1(resource)
def apply[A <: AutoCloseable, B <: AutoCloseable] (r1: A, r2: B)= new Loan2(r1, r2)
}

我猜是具有相似签名的东西

def apply[L <: HList](list: L)(implicit con: LUBConstraint[L, AutoCloseable]) = ???

另一个问题是如何在block: (A,B) => R部分中以元组的形式提供元素？

这有可能实现吗？

Answer 1

这其实并不难。你需要一种从元组(Generic.Aux[Tup, L])获取HList的方法，以及一种从Hlist(ToList[L, AutoCloseable])获取List[AutoClosable]的方法。

除了ToList部分之外，可能还有其他方法可以做到这一点，但它很容易融合LUBConstraint[L, AutoCloseable]和能够调用每个资源close()的要求。

scala> :paste
// Entering paste mode (ctrl-D to finish)
import shapeless._, ops.hlist._
import scala.util.{Failure, Success, Try}
class Loan[Tup, L <: HList](resources: Tup)(
implicit 
gen: Generic.Aux[Tup, L],
con: ToList[L, AutoCloseable]
) {
def to[B](block: Tup => B): B = {
Try(block(resources)) match {
case Success(result) =>
gen.to(resources).toList.foreach { _.close() }
result
case Failure(e) =>
gen.to(resources).toList.foreach { _.close() }
throw e
}
}
}
object Loan {
def apply[Tup, L <: HList](resources: Tup)(
implicit 
gen: Generic.Aux[Tup, L],
con: ToList[L, AutoCloseable]
) = new Loan(resources)
}
// Exiting paste mode, now interpreting.

scala> class Bar() extends AutoCloseable { def close = println("close Bar"); def IAmBar = println("doing bar stuff") }
defined class Bar
scala> class Foo() extends AutoCloseable { def close = println("close Foo"); def IAmFoo = println("doing foo stuff") }
defined class Foo
scala> Loan(new Foo, new Bar).to{ case (f, b) => f.IAmFoo; b.IAmBar }
doing foo stuff
doing bar stuff
close Foo
close Bar

唯一的问题是，对于正好 1 个资源的情况，您需要像case Tuple1(f)一样编写Tuple1(new Foo)和模式匹配。最简单的解决方案是保留Loan1零件，并用无形实现并适用于每个 arity>1 的LoanN替换Loan2零件。因此，这几乎等于将我的解决方案复制粘贴到您的解决方案中并将我的Loan类重命名为LoanN：

import shapeless._, ops.hlist._, ops.nat._
import scala.util.{Failure, Success, Try}
class LoanN[Tup, L <: HList](resources: Tup)(
implicit 
gen: Generic.Aux[Tup, L],
con: ToList[L, AutoCloseable]
) {
def to[B](block: Tup => B): B = {
Try(block(resources)) match {
case Success(result) =>
gen.to(resources).toList.foreach { _.close() }
result
case Failure(e) =>
gen.to(resources).toList.foreach { _.close() }
throw e
}
}
}
class Loan1[A <: AutoCloseable](resource: A) {
def to[B](block: A => B): B = {
Try(block(resource)) match {
case Success(result) =>
resource.close()
result
case Failure(e) =>
resource.close()
throw e
}
}
}

object Loan {
def apply[A <: AutoCloseable](resource: A): Loan1[A] = new Loan1(resource)
def apply[Tup, L <: HList, Len <: Nat](resources: Tup)(
implicit 
gen: Generic.Aux[Tup, L],
con: ToList[L, AutoCloseable],
length: Length.Aux[L, Len],
gt: GT[Len, nat._1]
) = new LoanN(resources)
}

我还添加了输入长度必须大于 1 的约束。否则，您通过一个可以转换为List[Nothing]的case class Baz()存在漏洞，该是List[AutoClosable]的子类型。

毫无疑问，带有Loan1内容的额外样板仍然可以通过自己编写更复杂的类型类来消除，该类型类能够区分单个参数和参数元组。

---

您建议接受HList作为参数并将其转换为元组。这也是可能的，shapeless.ops.hlist.Tupler.然后，该API的用户当然必须自己构造HList，并且您仍然会遇到scala没有漂亮的语法来解开Tuple1的问题。第二个问题可以通过一个非常简单的自定义类型类来解决，该类型类将Tuple1[A]解包为A，并保留其他所有内容：

sealed trait Unwrap[In] { 
type Out
def apply(in: In): Out 
}
object Unwrap extends DefaultUnwrap {
type Aux[In, Out0] = Unwrap[In] { type Out = Out0 }
def apply[T](implicit unwrap: Unwrap[T]): Unwrap.Aux[T, unwrap.Out] = unwrap
implicit def unwrapTuple1[A]: Unwrap.Aux[Tuple1[A], A] = new Unwrap[Tuple1[A]] {
type Out = A
def apply(in: Tuple1[A]) = in._1
}
}
trait DefaultUnwrap {
implicit def dontUnwrapOthers[A]: Unwrap.Aux[A, A] = new Unwrap[A] {
type Out = A
def apply(in: A) = in
}
}

将其与Tupler相结合，您将得到一个相对简单的解决方案：

scala> :paste
// Entering paste mode (ctrl-D to finish)
import shapeless._, ops.hlist._
import scala.util.{Failure, Success, Try}
class LoanN[Tup, L <: HList, Res](resources: L)(
implicit 
tupler: Tupler.Aux[L, Tup],
con: ToList[L, AutoCloseable],
unwrap: Unwrap.Aux[Tup, Res]
) {
def to[B](block: Res => B): B = {
Try(block(unwrap(tupler(resources)))) match {
case Success(result) =>
resources.toList.foreach { _.close() }
result
case Failure(e) =>
resources.toList.foreach { _.close() }
throw e
}
}
}

object Loan {
def apply[Tup, L <: HList, Res](resources: L)(
implicit 
tupler: Tupler.Aux[L, Tup],
con: ToList[L, AutoCloseable],
unwrap: Unwrap.Aux[Tup, Res]
) = new LoanN(resources)
}
// Exiting paste mode, now interpreting.

scala> Loan(new Foo :: new Bar ::  HNil).to{ case (f,b) => f.IAmFoo; b.IAmBar }
doing foo stuff
doing bar stuff
close Foo
close Bar
scala> Loan(new Foo :: HNil).to{ case (f) => f.IAmFoo }
doing foo stuff
close Foo