Scala 类型宏失效：如何从定义计算类型？

类型宏已关闭

然而，我有两个重要的用例需要它们。结果是我的应用程序失去了重要的可扩展性。 两者都是给定其他类型的类型的动态编译时生成。 基本上我想做一些事情，比如（显然不是scala代码，但我想你会明白的）：

例如，在哪里

class C
trait T1 extends C
trait T2 extends C

type Remaining[C with T1 with T2, T2] is assigned to "C with T1" at compile time
(so the macro would have generated the subclass list, and generated a new type from the list without T2) 

我不是用宏做的，所以这些都是假设。我计划现在就做。。直到我看到那类人死了。 不管怎样，有人知道获得这些功能的诀窍吗？

---

谢谢

据我所知，第一个用例在某种程度上确实可以通过隐式实现。下面是一个示例，说明这可能是什么样子：

scala> trait Bound[A] {
     |   type Type
     | }
defined trait Bound

scala> implicit val bound1 = new Bound[Int] { type Type = String }
bound1: Bound[Int]{type Type = String}

scala> implicit val bound2 = new Bound[String] { type Type = Double }
bound2: Bound[String]{type Type = Double}

scala> val tpe = implicitly[Bound[Int]]
tpe: Bound[Int] = $anon$1@2a6b3a99

scala> type U = tpe.Type
defined type alias U

但是：

scala> implicitly[U =:= String]
<console>:19: error: Cannot prove that U =:= String.
              implicitly[U =:= String]
                        ^

但是，不确定如何将生成的

HList

组合成复合类型。类似于（伪代码）：

trait剩余[T1和T2]）=ev2
//^非真实语法，类型级别函数用于组合/混合类型
val tpe=产品类型
类型结果=tpe.Out
}

据我所知，第一个用例在某种程度上确实可以通过隐式实现。下面是一个示例，说明这可能是什么样子：

scala> trait Bound[A] {
     |   type Type
     | }
defined trait Bound

scala> implicit val bound1 = new Bound[Int] { type Type = String }
bound1: Bound[Int]{type Type = String}

scala> implicit val bound2 = new Bound[String] { type Type = Double }
bound2: Bound[String]{type Type = Double}

scala> val tpe = implicitly[Bound[Int]]
tpe: Bound[Int] = $anon$1@2a6b3a99

scala> type U = tpe.Type
defined type alias U

但是：

scala> implicitly[U =:= String]
<console>:19: error: Cannot prove that U =:= String.
              implicitly[U =:= String]
                        ^

但是，不确定如何将生成的

HList

组合成复合类型。类似于（伪代码）：

trait剩余[T1和T2]）=ev2
//^非真实语法，类型级别函数用于组合/混合类型
val tpe=产品类型
类型结果=tpe.Out
}

在第一个示例中，您没有显示用例，而是显示宏定义。如果没有实际的用例（其中是

T[U]

needed），就很难进行评估。不过，看起来这里不需要宏，只需要一些开箱即用的类型约束。scala中的类型非常灵活。参见scalaz和shapeless(‎) 对于高级类型用法。@0\uuu第二个用例是执行如下操作：，但是使用复杂的选项，例如“如果我插入选项A，我就不能插入B；D，在插入C等后就可以插入”。我最终得到了类似于链接中的内容，但是，我没有用模式case编写一个简短的可读代码，而是用所有子类的树来完成。第一个用例是自动转换。我可以用一个简单的算法来完成，但我必须在不同的类中编写所有的案例。@Arseniy Zhizhelev它似乎不是我想要的（或者我不理解它们）。我知道scala中有两个截然不同的世界。已识别元素的世界和类型的世界。你可以在已识别元素的世界中编码，但只能在类型的世界中进行统计声明。我的梦想是在类型的世界中编码（仅使用类型），但这似乎是一个死梦。@coo lhobou Scala（）中的文章类型级编程显示类型系统相当强大，允许几乎一般的编程！我看不出你想要实现什么。你能解释没有宏的问题吗？在你的第一个示例中，你没有显示用例，而是显示宏定义。没有实际用例（其中是

t[U]

needed）这很难评估。但看起来，这里不需要宏，只需要一些开箱即用的类型约束。scala中的类型非常灵活。请参阅scalaz和shapeless(‎) 对于高级类型用法。@0\uuu第二个用例是执行如下操作：，但是使用复杂的选项，例如“如果我插入选项A，我就不能插入B；D，在插入C等后就可以插入”。我最终得到了类似于链接中的内容，但是，我没有用模式case编写一个简短的可读代码，而是用所有子类的树来完成。第一个用例是自动转换。我可以用一个简单的算法来完成，但我必须在不同的类中编写所有的案例。@Arseniy Zhizhelev它似乎不是我想要的（或者我不理解它们）。我知道scala中有两个截然不同的世界。已识别元素的世界和类型的世界。你可以在已识别元素的世界中编码，但只能在类型的世界中进行统计声明。我的梦想是在类型的世界中编码（仅使用类型），但这似乎是一个死梦。@coo lhobou Scala（）中的文章类型级编程显示类型系统相当强大，并且允许几乎一般的编程！我看不出你想要实现什么。你能在没有宏的情况下解释这个问题吗？谢谢。我没有访问scala编译器的权限，但我猜

type U=tpe。type#type

不会丢失信息。谢谢。我没有访问scala编译器的权限，但我可以uess

type U=tpe。type#type

不会丢失信息

scala> implicitly[bound1.Type =:= String]
res0: =:=[bound1.Type,String] = <function1>

scala> trait Remaining[A <: HList, B] { type Result = Remove[A, B] }
defined trait Remaining

scala> new Remaining[C :: T1 :: T2 :: HNil, T2] {}
res5: Remaining[shapeless.::[C,shapeless.::[T1,shapeless.::[T2,shapeless.HNil]]],T2] = $anon$1@3072e54b

trait Remaining[A <: HList, B] {
  def produceType(
    implicit ev0 : Remove.Aux[A, B, C],
             ev1 : IsCons.Aux[C, H, T],
             ev2 : LeftFolder[T, H, (T1, T2) => T1 with T2]) = ev2
             //                     ^ Not real syntax, type-level function to combine/mix types
  val tpe = produceType
  type Result = tpe.Out
}