题

是否有可能为无形'创建一个HList看起来如下的提取器.

val a ~ _ ~ b = 4 :: "so" :: 4.5 :: HNil
=> a == 4 && b == 4.5

1. 替换::为~,这应该不是问题.
2. 摆脱终止HNil.有没有可能出现的问题？

动机

经过多少汗水和泪水,我设法到达了以下代码的工作点:

for(
  x1 :: _ :: x2 :: HNil <- (expInt ~ "+" ~ expInt).llE
) yield (x1 + x2)

expInt解析Int一些monad E.类型(expInt ~ "+" ~ expInt).llE是E[Int :: String :: Int :: HNil].

我希望左边的模式在<-某种程度上类似于右边的组合子解析器的构造.

昨晚我试图做一些接受和调用泛型函数的东西(即类型在调用站点已知,但可能在调用站点之间有所不同,因此定义应该是跨arities的通用).

例如,假设我有一个功能f: (A, B, C, ...) => Z.(实际上有很多这样的fs,我事先并不知道,因此我无法修复类型或数量A, B, C, ..., Z.)

我正在努力实现以下目标.

1. 如何f通常使用实例调用(A, B, C, ...)？如果签名f是事先知道的,那么我可以做一些涉及Function.tupled f或等同的事情.

2. 如何定义另一个函数或方法(例如,一些object的apply具有相同签名的方法)f？也就是说,当且仅当类型检查时,如何定义g哪种类型检查？我正在研究Shapeless的.从我到目前为止所知,至少解决了"代表一个任意arity args列表"的问题,而且,Shapeless将解决与元组问题的转换.但是,我仍然不确定我是否理解这与通用arity的功能如何相符(如果有的话).g(a, b, c, ...)f(a, b, c, ...)HListHList

3. 如何定义具有相关类型签名的其他函数或方法f？现在想到的最大的例子是一些h: (A, B, C, ...) => SomeErrorThing[Z] \/ Z.

我记得前一段时间在Shapeless上观看过一次会议.虽然演示者没有明确地展示这些东西,但他们所做的演示(围绕抽象/泛化元组与HLists的各种技术)会让我相信使用相同的工具可以实现与上述类似的东西.

提前致谢!

我可以使用与无形副产品匹配的模式吗？

import shapeless.{CNil, :+:}

type ListOrString = List[Int] :+: String :+: CNil

def f(a: ListOrString): Int = a match {
  case 0 :: second :: Nil => second
  case first :: Nil => first
  case Nil => -1
  case string: String => string.toInt
}

这当然不起作用,因为a盒装为Coproduct.

有没有其他方法可以使用副产品并保持模式匹配的能力？

是否有可能(通过宏,某种形式的无形自动或其他形式)获得密封特征的子类列表:

• 在编译时？
• 在运行时？

我已经看到一个名为"at"的对象(可能是一个函数)散布在整个无形源和使用无形的代码中.特别是,它用于解答另一个问题.这是代码片段:

object iterateOverHList extends Poly1 {
  implicit def iterable[T, L[T] <: Iterable[T]] = at[L[T]](_.iterator)
}

我有一些线索,它与〜>类型的apply方法有关."at"具体做什么,它在哪里定义？

以下代码是Idris:

natAssociative : (a : Nat) -> (b : Nat) -> (c : Nat) -> (a + b) + c = a + (b + c)
natAssociative Z b c = the (b + c = b + c) refl
natAssociative (S k) b c = replace {P=\x => S (k + b) + c = S x} (natAssociative k b c) refl

我正在艰难地将其转化为无形.我尝试了一些不同的编码,但我认为这是最有希望的开始:

import scalaz.Leibniz._
import shapeless.{ HNil, Nat, Succ, Poly3 }
import shapeless.Nat._
import shapeless.ops.nat._

object natAssociative extends …

我想创建相当于:

def toTupleN[A1, ..., AN, L <: HList](l: L): TupleN[A1, ..., AN]

代码使用toTupleN只有在只有一个N值组合时才能编译l,因为可以从中创建元组.其他任何东西都应该生成编译时错误.应考虑可用的隐式转换.请注意,对其中l的值的大小或顺序没有限制.

例:

val l = 23 :: (1, "wibble") :: (2, "wobble") :: "foo" :: HNil
// l: shapeless.::[Int,shapeless.::[(Int, String),shapeless.::[(Int, String),shapeless.::[String,shapeless.HNil]]]] = 23 :: (1,wibble) :: (2,wobble) :: foo :: HNil

val t2: (String, Int) = toTuple2(l)
// t2: (String, Int) = (foo,23)

val nope: (String, String) = toTuple2(l)
// Compiler error because no combination of l's values can create …

我目前正在尝试在运行时动态创建Akka Stream图定义.这个想法是用户将能够以交互方式定义流并将它们附加到现有/运行BroadcastHubs.这意味着我不知道在编译时将使用哪些流甚至多少流.

不幸的是,我正在努力进行泛型/类型擦除.坦率地说,我甚至不确定我在JVM上尝试做什么.

我有一个函数将返回Flow代表两个连接的Akka Streams Flows.它使用Scala TypeTags来绕过类型擦除.如果第一个流的输出类型与第二个流的输入类型相同,则可以成功连接.这很好用.

import akka.NotUsed
import akka.stream.FlowShape
import akka.stream.scaladsl.GraphDSL.Implicits._
import akka.stream.scaladsl.{Flow, GraphDSL}

import scala.reflect.runtime.universe._
import scala.util.{Failure, Success, Try}

def connect[A: TypeTag, B: TypeTag, C: TypeTag, D: TypeTag](a: Flow[A, B, NotUsed],
                                                            b: Flow[C, D, NotUsed]): Try[Flow[A, D, NotUsed]] = {
  Try {
    if (typeOf[B] =:= typeOf[C]) {
      val c = b.asInstanceOf[Flow[B, D, NotUsed]]

      Flow.fromGraph {
        GraphDSL.create(a, c)((m1, m2) => NotUsed.getInstance()) { implicit b =>
          (s1, s2) =>
            s1 ~> …

我有以下案例类:

case class PropositionContent(title:String,content:String)

我想代表它作为数据的部分修改.

一种方法是创建案例类:

case class PartialPropositionContent(title:Option[String],content:Option[String)

然后是一些方法:

object PropositionContent {

   def append( pc  : PropositionContent
             , ppc : PartialPropositionContent) =
   PropositionContent ( ppc.title.getOrElse(pc.title)
                      , ppc.content.getOrElse(pc.content) )

   def append( ppc  : PartialPropositionContent
             , ppc2 : PartialPropositionContent ):  PartialPropositionContent = {...}

}

但这有点像锅炉架!

我认为一个case class PropositionContent[M[_]](title:M[String],content:M[String])不会真正解决的问题,我不知道如何使用Shapeless解决问题.

你有什么想法吗？

这个问题之前可能会被提出并回答,但我想通过一个例子来理解这个问题,我无法推断出Aux模式可能有用的地方!所以这是特征:

trait Foo[A] {
  type B
  def value: B
}

为什么我有一个类型绑定到值函数的返回类型？我这样做了什么？特别是,我会在哪里使用这种模式？