可以在Scala HList上执行Map

时间:2011-03-18 08:13:13

标签: scala shapeless hlist

我现在已经完成了一些HList的实现。一个基于丹尼尔斯皮瓦克在斯卡拉之地的高级巫术讲话,另一个基于Apocalisp博客中的帖子。目标是有一个异类列表,其中主要类型不是异质的,而是更高类型。例如:

val requests = Request[String] :: Request[Int] :: HNil

我可以在列表中执行映射来执行请求,并生成更高类型的异类列表。所以:

requests.map(execute)

应该等于

String :: Int :: HNil

可悲的是,我的所有尝试都产生了任何HList。以下是最近尝试的代码:

class Request[+Out](o:Out) {
  type O = Out

  def v:O = o
}

object HList {
  trait Func[-Elem,Out] {
    type Apply[E <: Elem] <: Out
    def apply[N <: Elem](e:N):Apply[N]
  }
  sealed trait HList[Base] {
    type Head <: Base
    type Tail <: HList[Base]
    type Map[Out,F <: Func[Base,Out]] <: HList[Out]
    def head:Head
    def tail:Tail

    def ::[A <: Base](a:A):HList[Base]
    def map[Out,F <: Func[Base,Out]](f:F):Map[Out,F]
  }

  case class HNil[Base]() extends HList[Base] {
    type Head = Nothing
    type Tail = Nothing
    type Map[Out,F <: Func[Base,Out]] = HNil[Out]

    def head = error("Head of an empty HList")
    def tail = error("Head of an empty HList")

    def ::[A <: Base](a:A) = HCons(a,this)
    def map[Out,F <: Func[Base,Out]](f:F) = new HNil[Out]
  }

  case class HCons[Base,A <: Base,B <: HList[Base]](head: A, tail: B) extends HList[Base] {
    type Head = A
    type Tail = B    
    type Map[Out,F <: Func[Base,Out]] = HCons[Out,F#Apply[Head],Tail#Map[Out,F]]

    def ::[C <: Base](c:C) = HCons(c,this)
    def map[Out,F <: Func[Base,Out]](f:F) =
      HCons(f(head),tail.map(f))
  }

  val :: = HCons 
}

object Test extends Application {
  import HList._

  val HNil = new HNil[Request[_]]

  val list = new Request[Int](1) :: new Request[String]("1") :: HNil

  val (a :: b :: HNil) = list
  val y:Request[String] = b

  val results = list.map[Any,Unwrap.type](Unwrap)

  val i:Int = results.head
}

import HList._
object Unwrap extends Func[Request[Any],Any] {
  type Apply[I <: Request[Any]] = I#O
  def apply[N <: Request[Any]](e:N) = null.asInstanceOf[Apply[N]]
}

另一次尝试是基于Apocalisp版本,该版本使用fold创建一个新的HList,并且再次产生了任何类型的HList。任何提示将不胜感激。

3 个答案:

答案 0 :(得分:22)

shapeless中的HList实施非常丰富,可以包含HListKList功能。它提供了map操作,该操作在其元素中应用排名较高的函数(可能包含特定于类型的函数),从而产生适当类型的HList结果,

import shapeless.Poly._
import shapeless.HList._

// Define a higher-ranked function from Sets to Options
object choose extends (Set ~> Option) {
  def default[T](s : Set[T]) = s.headOption 
}

// An HList of Sets
val sets = Set(1) :: Set("foo") :: HNil

// Map our choose function across it ...
val opts = sets map choose

// The resulting value
opts == Option(1) :: Option("foo") :: HNil 

请注意,虽然在上面的示例中就是这种情况,但并不要求HList元素共享一个公共的外部类型构造函数,只需要将映射得越高的函数映射到所有类型的情况。 ,

// size is a higher-ranked function from values of arbitrary type to a 'size'
// which is defined as 1 by default but which has type specific cases for
// Strings and tuples
object size extends (Id ~> Const[Int]#λ) {
  def default[T](t : T) = 1
}
implicit def sizeString = size.λ[String](s => s.length)
implicit def sizeTuple[T, U](implicit st : size.λ[T], su : size.λ[U]) =
  size.λ[(T, U)](t => 1+size(t._1)+size(t._2))

size(23) == 1          // Default
size("foo") == 3       // Type specific case for Strings
size((23, "foo")) == 5 // Type specific case for tuples

现在让我们将其映射到HList

val l = 23 :: true :: "foo" :: ("bar", "wibble") :: HNil
val ls = l map size

ls == 1 :: 1 :: 3 :: 10 :: HNil

在这种情况下,被映射函数的结果类型是常量:无论参数类型是什么,它都是Int。因此,生成的HList具有所有相同类型的元素,这意味着它可以有用地转换为香草列表,

ls.toList == List(1, 1, 3, 10)

答案 1 :(得分:3)

您需要的是具有类型构造函数Request的Klist和自然转换execute: Request ~> Id。所有这一切都在Apocalisp的奇妙的类型级编程系列文章中详细介绍,特别是:

  1. Natural transformation literals
  2. Klist basics
  3. 您可以从Mark Harrah's up repo

    查看整个系列的代码

    在你的情况下,你需要像

    这样的东西
    val reqList = new Request[Int](1) :^: new Request[String]("1") :^: KNil    
    val exec = new (Request ~> Id) { def apply[T](reqs: Request[T]): T = reqs.execute }    
    val results = reqList down exec
    

    上述down方法在概念上与nat transf map的{​​{1}}相同;你还有一个更为通用的M ~> Id来自nat transf map和一个K类的K列表中有一个类型为N的K列。

答案 2 :(得分:0)

请注意,您在 Using shapeless' HLists for extra type safety (in Akka Streams) 中最近(2016年10月,OP后5年)文章“Mikołaj Koziarkiewicz”中有一个带有HList的地图示例。

  //glue for the ParserStageDefs
  specs.map(s => Flow[Data].map(s.parser).map(s.processor))
                    .foreach(broadcast ~> _ ~> merge)
  

问题在于我们的规格列表中​​的类型信息未被保留。或者更确切地说,不保留我们想要的方式 - List元素的类型是ParserStageDef[_ >: Int with String],因此我们的装饰器和增量器的最低常见超类型。

     

以上暗示,在解析器和处理器元素之间进行映射时,编译器无法提供在给定规范中使用的实际类型T

     

解决方案

     

这里是HLists救援的地方。因为它们保留了每个元素的完整类型信息,所以可以像上次尝试一样定义我们的流程。

     

首先,让我们用HList替换我们的列表:

import shapeless.ops.hlist._
import shapeless._
//...

val specs = decorator :: incrementer :: HNil
val specsSize = specs.length.toInt
  

现在,对于从ParserStageDefsFlows的映射,我们需要采用不同的方法,因为map的{​​{1}}需要一个名为P ** {{{ 3}} **。

     

以下是我们的案例:

HList
  

要使其正常工作,我们还会将import shapeless.PolyDefns.~> object toFlow extends (ParserStageDef ~> ProcessingFlow) { override def apply[T](f: ParserStageDef[T]) = Flow[Data].map(f.parser).map(f.processor) } 更改为ProcessingFlow,因为上面的多态函数需要更高的类型。

     

现在,我们的核心声明是:

ProcessingFlow[_] = Flow[Data, Data, _]
  

我们都准备好了!