scala - 在函数式 Scala 中，将一种参数化类型转换为另一种参数化类型的好方法是什么？

Question

我需要实现从一种数据结构到另一种数据结构的转换:

A[B] => C[D]

我可以将它实现为一个方法:

def transform(in: A[B]): C[D] = ???

但我想以类型驱动的开发方式来实现，代码是可扩展的、松散耦合的，并且可以随时扩展以满足来自业务的新的荒谬需求。 所以这就是我得到的:

type AB = A[B]
type CD = C[D]
trait Transformer[I,O] {
  def transform(in:I): O
}
implicit val abcdTransformer: Transformer[AB,CD] = 
  (in: AB) => ???

def transform[I,O](in: I)(implicit t: Transformer[I,O]): O = t.transform(in)

不确定我从中得到了什么，感觉有点矫枉过正。它真的是实现这种转变的好方法吗？ 我是否错过了一些已经提供此类样板等的库(猫)？

Answer 1

当类型类只有一个实例时，基于类型类和方法的方法没有太大区别。

使用类型类，您可以定义以不同方式处理不同的类型(类型类是类型级的，编译时“模式匹配”)

trait Transformer[I,O] {
  def transform(in:I): O
}
object Transformer {
  implicit val abcdTransformer: Transformer[AB,CD] = (in: AB) => ???
  implicit val efghTransformer: Transformer[EF,GH] = (in: EF) => ???
}

如果您的类型“相交”，您可以使用类型类来确定实例的优先级

trait Transformer[I,O] {
  def transform(in:I): O
}
trait LowPriorityTransformer {
  implicit val efghTransformer: Transformer[EF,GH] = (in: EF) => ???
}
object Transformer extends LowPriorityTransformer {
  implicit val abcdTransformer: Transformer[AB,CD] = (in: AB) => ???
}

使用类型类，您可以归纳地定义您的逻辑

trait Transformer[I,O] {
  def transform(in:I): O
}
object Transformer {  
  implicit def recurse(implicit t: Transformer[...]): Transformer[...] = ???
  implicit val base: Transformer[...] = ???
}

使用类型类，您可以执行类型级别的计算

trait Transformer[I] {
  type O
  def transform(in:I): O
}
object Transformer {
  implicit val abcdTransformer: Transformer[AB] { type O = CD } = ???
  implicit val efghTransformer: Transformer[EF] { type O = GH } = ???
}

def transform[I](in: I)(implicit t: Transformer[I]): t.O = t.transform(in)

这里是用类型类替换方法的例子

shapeless filter a list of options

How to overload generic method with different evidence without ambiguity?

When using HList with GADTs I am having to cast using asInstanceOf[H]. Is there a way to avoid the cast?

还可以使用类型类将多个隐式参数隐藏在一个单独的参数中，将您的逻辑封装在一个类型类中

How to wrap a method having implicits with another method in Scala?

Implicit Encoder for TypedDataset and Type Bounds in Scala

Parameterized folding on a shapeless HList

关于隐藏样板文件，一些样板文件将隐藏在 Dotty (Scala 3) 中。在

中不会有太多需要

def transform[I,O](in: I)(implicit t: Transformer[I,O]): O = t.transform(in) // (*)

还有。我们可以直接定义type classes与 extension methods

trait Transformer[I,O] {
  def (in:I) transform: O
}
object Transformer {
  given as Transformer[AB,CD] = (in: AB) => ??? // given is instead of implicit
}

import Transformer.{ given _}
ab.transform

在 Scala 2 中我有一个小库 AUXify (未准备好生产)生成类似 (*) 的样板

import com.github.dmytromitin.auxify.macros.delegated

@delegated
trait Transformer[I,O] {
  def transform(in:I): O
}
object Transformer {
  implicit val abcdTransformer: Transformer[AB,CD] = (in: AB) => ???
}

Transformer.transform(ab)

      // scalacOptions += "-Ymacro-debug-lite"
//Warning:scalac: {
//  abstract trait Transformer[I, O] extends scala.AnyRef {
//    def transform(in: I): O
//  };
//  object Transformer extends scala.AnyRef {
//    def <init>() = {
//      super.<init>();
//      ()
//    };
//    def transform[I, O](in: I)(implicit inst$macro$1: Transformer[I, O]): O = inst$macro$1.transform(in);
//    implicit val abcdTransformer: Transformer[AB, CD] = ((in: AB) => $qmark$qmark$qmark)
//  };
//  ()
//}

或生成扩展方法(语法)

import com.github.dmytromitin.auxify.macros.syntax

@syntax
trait Transformer[I,O] {
  def transform(in:I): O
}
object Transformer {
  implicit val abcdTransformer: Transformer[AB,CD] = (in: AB) => ???
}

import Transformer.syntax._
ab.transform[CD]

//Warning:scalac: {
//  abstract trait Transformer[I, O] extends scala.AnyRef {
//    def transform(in: I): O
//  };
//  object Transformer extends scala.AnyRef {
//    def <init>() = {
//      super.<init>();
//      ()
//    };
//    object syntax extends scala.AnyRef {
//      def <init>() = {
//        super.<init>();
//        ()
//      };
//      implicit class Ops$macro$1[I] extends scala.AnyRef {
//        <paramaccessor> val in: I = _;
//        def <init>(in: I) = {
//          super.<init>();
//          ()
//        };
//        def transform[O]()(implicit inst$macro$2: Transformer[I, O]): O = inst$macro$2.transform(in)
//      }
//    };
//    implicit val abcdTransformer: Transformer[AB, CD] = ((in: AB) => $qmark$qmark$qmark)
//  };
//  ()
//}

或生成物化器等

import com.github.dmytromitin.auxify.macros.apply

@apply
trait Transformer[I, O] {
  def transform(in:I): O
}
object Transformer {
  implicit val abcdTransformer: Transformer[AB, CD] = ???
}

Transformer[AB, CD].transform(ab)

//Warning:scalac: {
//  abstract trait Transformer[I, O] extends scala.AnyRef {
//    def transform(in: I): O
//  };
//  object Transformer extends scala.AnyRef {
//    def <init>() = {
//      super.<init>();
//      ()
//    };
//    def apply[I, O](implicit inst: Transformer[I, O]): Transformer[I, O] = inst;
//    implicit val abcdTransformer: Transformer[AB, CD] = $qmark$qmark$qmark
//  };
//  ()
//}

还可以使用 Simulacrum 生成单参数类型类的扩展方法(和实体化器)

import simulacrum.typeclass

@typeclass
trait Transformer[I] {
  type O
  def transform(in:I): O
}
object Transformer {
  implicit val abcdTransformer: Transformer[AB] { type O = CD } = ???
}

Transformer[AB].transform(ab)

import Transformer.ops._
ab.transform

//Warning:scalac: {
//  @new _root_.scala.annotation.implicitNotFound("Could not find an instance of Transformer for ${I}") abstract trait Transformer[I] extends _root_.scala.Any with _root_.scala.Serializable {
//    type O;
//    def transform(in: I): O
//  };
//  object Transformer extends scala.AnyRef {
//    def <init>() = {
//      super.<init>();
//      ()
//    };
//    implicit val abcdTransformer: Transformer[AB] {
//      type O = CD
//    } = $qmark$qmark$qmark;
//    @new scala.inline() def apply[I](implicit instance: Transformer[I]): Transformer[I] {
//      type O = instance.O
//    } = instance;
//    abstract trait Ops[I] extends scala.AnyRef {
//      def $init$() = {
//        ()
//      };
//      type TypeClassType <: Transformer[I];
//      val typeClassInstance: TypeClassType;
//      import typeClassInstance._;
//      def self: I;
//      def transform: O = typeClassInstance.transform(self)
//    };
//    abstract trait ToTransformerOps extends scala.AnyRef {
//      def $init$() = {
//        ()
//      };
//      @new java.lang.SuppressWarnings(scala.Array("org.wartremover.warts.ExplicitImplicitTypes", "org.wartremover.warts.ImplicitConversion")) implicit def toTransformerOps[I](target: I)(implicit tc: Transformer[I]): Ops[I] {
//        type TypeClassType = Transformer[I] {
//          type O = tc.O
//        }
//      } = {
//        final class $anon extends Ops[I] {
//          def <init>() = {
//            super.<init>();
//            ()
//          };
//          type TypeClassType = Transformer[I] {
//            type O = tc.O
//          };
//          val self = target;
//          val typeClassInstance: TypeClassType = tc
//        };
//        new $anon()
//      }
//    };
//    object nonInheritedOps extends ToTransformerOps {
//      def <init>() = {
//        super.<init>();
//        ()
//      }
//    };
//    abstract trait AllOps[I] extends Ops[I] {
//      type TypeClassType <: Transformer[I];
//      val typeClassInstance: TypeClassType
//    };
//    object ops extends scala.AnyRef {
//      def <init>() = {
//        super.<init>();
//        ()
//      };
//      @new java.lang.SuppressWarnings(scala.Array("org.wartremover.warts.ExplicitImplicitTypes", "org.wartremover.warts.ImplicitConversion")) implicit def toAllTransformerOps[I](target: I)(implicit tc: Transformer[I]): AllOps[I] {
//        type TypeClassType = Transformer[I] {
//          type O = tc.O
//        }
//      } = {
//        final class $anon extends AllOps[I] {
//          def <init>() = {
//            super.<init>();
//            ()
//          };
//          type TypeClassType = Transformer[I] {
//            type O = tc.O
//          };
//          val self = target;
//          val typeClassInstance: TypeClassType = tc
//        };
//        new $anon()
//      }
//    }
//  };
//  ()
//}