在函数式 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

标准库 (2.13.x) 非常接近您的需要，具体取决于您的需要。

import scala.collection.Factory

implicit class AB2CD[A,B](from :IterableOnce[A]) {
  def transit[CC[_]](f :A => B
                   )(implicit fctry: Factory[B, CC[B]]
                   ) :CC[B] = {
    val bs = LazyList.unfold(from.iterator) { itr =>
               Option.when(itr.hasNext) (f(itr.next()), itr)
             }
    fctry.fromSpecific(bs)
  }
}

测试：

Option(88).transit[Vector](_.toString)//res0: Vector[String] = Vector(88)
Seq('c','x').transit[Set](_.asDigit)  //res1: Set[Int] = Set(12, 33)
List(1.1,2.2).transit[Array](_ < 2)   //res2: Array[Boolean] = Array(true, false)

由于 IterableOnce 的限制，这不会从 Array 转移，也不会转移到 String 或从 String 转移。有一个解决方法，但我只想到此为止。

Answer 2

当存在类型class的单个实例时，基于类型class和方法的方法之间没有太大区别。

使用类型 class，您可以定义以不同方式处理不同的类型（类型 classes 是类型级别，编译时 "pattern-matching"）

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) => ???
}

如果您的类型 "intersect"，类型 class 您可以优先考虑实例

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) => ???
}

使用类型 class 你可以归纳地定义你的逻辑

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

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

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)

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

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

中

Implicit Encoder for TypedDataset and Type Bounds in Scala

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

不会有太多需要

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

更多。我们可以直接定义type classes with 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: Transformer[I, O]): O = inst$macro.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[I] extends scala.AnyRef {
//        <paramaccessor> val in: I = _;
//        def <init>(in: I) = {
//          super.<init>();
//          ()
//        };
//        def transform[O]()(implicit inst$macro: Transformer[I, O]): O = inst$macro.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

生成单参数类型 classes 的扩展方法（和实体化器）

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()
//      }
//    }
//  };
//  ()
//}

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

In functional Scala, what is a good way to go transform one parametrized type to another?

scala

functional-programming

typeclass

scala-cats