包装在函数中创建Shapeless FieldType

Question

有没有办法创建一个隐式类来提供一个自定义函数来返回一个与记录风格的singleton操作符->>相同类型的FieldType？

我想这样做：

import shapeless.syntax.singleton._ 

implicit class FieldMaker[S <: Symbol](val s: S) { 
    def make[T](t: T) = s ->> t 
} 

，使下面的两个值具有相同的类型：

val first = 'test ->> Foo("bar") 
val second = 'test make Foo("bar") 

在以前的尝试中，我不断收到由宏挫败mkSingletonOps。任何意见将是有益的！

更新：

这样做的动机从创建一个DSL，并试图小心地控制它的语法造成的。上面的简化示例跳过了这个隐式类在DSL中特定的目的，即将一个函数应用于返回DSL中其他位置所需的类型类。

甲多个示例性的情况将是：

import shapeless.syntax.singleton._ 

def func(t: T): SomeTypeclass[T] = _ // elided 

implicit class FieldMaker[S <: Symbol](val s: S) { 
    def make[T](t: T) = s ->> func(t) 
} 

使得以下两个值具有相同的类型：

val first = 'test ->> func(Foo("bar")) 
val second = 'test make Foo("bar") 

分配给second表达是用于DSL所需的语法。

Answer 1

可能没有。

import shapeless.Witness 
    import shapeless.labelled.FieldType 
    import shapeless.syntax.singleton._ 

    implicit class FieldMaker[S <: Symbol](val s: S) { 
    def make[T](t: T): FieldType[s.type, T] = s ->>[T] t 
    } 

    case class Foo(s: String) 

    val first: FieldType[Witness.`'test`.T, Foo] = 'test ->>[Foo] Foo("bar") 
    val second: FieldType[fm.s.type, Foo] forSome { val fm: FieldMaker[Symbol] } = 
    'test make[Foo] Foo("bar") 
    val third: FieldType[fm.s.type, Foo] forSome { val fm: FieldMaker[Witness.`'test`.T] } = 
    'test.narrow make[Foo] Foo("bar") 

的s ->>[T] t类型是FieldType[s.type, T]，这不依赖于类型参数S。 但是s.type中的s是什么？在隐式转换之前，它是'test，但在此之后它只是FieldMaker[S]（实例，仅在隐式转换期间存在的实例）的实例的字段，所以我们具有存在类型。只要我们有存在型，我们就不能回到'test。

这是如何隐含工作。

---

其实最后我发现，使同一类型的second为first（尽管它使用.narrow）的方式。我用类型和隐式转换替换了隐式转换。

import shapeless.Witness 
    import shapeless.labelled.FieldType 
    import shapeless.syntax.singleton._ 
    import shapeless.tag.@@ 

    trait FieldMaker[S <: Symbol, T] { 
    def make(t: T): FieldType[S, T] 
    } 

    object FieldMaker { 
    implicit def mkFieldMaker[/*S <: Symbol*/U, T](implicit 
                witness: Witness.Aux[/*S*/Symbol @@ U] 
               ): FieldMaker[/*S*/Symbol @@ U, T] = { 
     val name: /*S*/Symbol @@ U = witness.value 
     new FieldMaker[/*S*/Symbol @@ U, T] { 
     override def make(t: T): FieldType[/*S*/Symbol @@ U, T] = 
      (name ->>[T] t).asInstanceOf[FieldType[/*S*/Symbol @@ U, T]] 
     } 
    } 

    object op { 
     implicit class FieldMakerOp[S <: Symbol](s: S) { 
     def make[T](t: T)(implicit fm: FieldMaker[S, T]): FieldType[S, T] = fm.make(t) 
     } 
    } 

    } 

    case class Foo(s: String) 

    val first: FieldType[Witness.`'test`.T, Foo] = 'test ->>[Foo] Foo("bar") 

    import FieldMaker.op._ 
    val second: FieldType[Witness.`'test`.T, Foo] = 'test.narrow make/*[Foo]*/ Foo("bar")