Cats（2）－ Free语法组合，Coproduct-ADT composition

最新推荐文章于 2024-05-21 09:46:02 发布
最新推荐文章于 2024-05-21 09:46:02 发布
阅读量595 收藏 1
点赞数
分类专栏： 编程技术 Scala Cats 函数式编程（Functional Programming） 文章标签： 编程 scala cats 函数式编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TIGER_XC/article/details/52453346
版权

    上篇我们介绍了Free类型可以作为一种嵌入式编程语言DSL在函数式编程中对某种特定功能需求进行描述。一个完整的应用可能会涉及多样的关联功能，但如果我们为每个应用都设计一套DSL的话，那么在我们的函数式编程中将会不断重复的功能相似的DSL。我们应该秉承函数式编程的核心思想：函数组合（compositionality）来实现DSL的组合：把DSL拆解成最基础语句ADT，然后用这些ADT来组合成适合应用功能要求的完整DSL。我们还是使用上篇那个Interact DSL，这次再增加一个Login功能：

package demo.app
import cats.free.{Free,Inject}
object FreeModules {
  object ADTs {
    sealed trait Interact[+A]
    object Interact {
      case class Ask(prompt: String) extends Interact[String]
      case class Tell(msg: String) extends Interact[Unit]
      type FreeInteract[A] = Free[Interact,A]
      def ask(prompt: String): FreeInteract[String] = Free.liftF(Ask(prompt))
      def tell(msg: String): FreeInteract[Unit] = Free.liftF(Tell(msg))
    }

    sealed trait Login[+A]
    object Login {
      type FreeLogin[A] = Free[Login,A]
      case class Authenticate(user: String, pswd: String) extends Login[Boolean]
      def authenticate(user: String, pswd: String): FreeLogin[Boolean] =
        Free.liftF(Authenticate(user,pswd))
    }

  }

}


上面我们增加了个Login类。我们先来进行DSL编程：

  object DSLs {
    import ADTs._
    import Interact._
    import Login._
    val interactDSL: FreeInteract[Unit]  = for {
      first <- ask("What's your first name?")
      last <- ask("What's your last name?")
      _ <- tell(s"Hello, $first $last!")
    } yield()

    val loginDSL: FreeLogin[Boolean] = for {
      login <- authenticate("Tiger","123")
    } yield login
  }


很明显，用一种DSL编程是无法满足Login功能需要的。我们需要像下面这样的DSL： 

 val interactLoginDSL: Free[???,Boolean] = for {
      uid <- ask("Enter your User ID:")
      psw <- ask("Enter your Password:")
      aut <- authenticate(uid,pwd)
    } yield aut


不过上面的???应该是什么呢？它应该是Interact和Login的集合。cats提供了Coproduct，它是一个树形数据结构：

/** `F` on the left and `G` on the right of [[scala.util.Either]].
 *
 * @param run The underlying [[scala.util.Either]].
 */
final case class Coproduct[F[_], G[_], A](run: Either[F[A], G[A]]) {...}


Coproduct 的每一个节点（Either[F[A],G[A]]）都是一个ADT，F[A]或者G[A]。我们可以用多层递归Coproduce结构来构建一个多语法的树形结构，如： 

type H[A] = Coproduct[F,G,A]
type I[A] = Coproduct[H,X,A]
type J[A] = Coproduct[J,Y,A]  //ADT(F,G,X,Y)


用Coproduct的树形结构可以容纳多种DSL的ADT。在上面的例子里我们需要一个组合的语法InteractLogin：

type InteractLogin[A] = Coproduct[Interact,Login,A]


cats提供了Inject类来构建Coproduct：

sealed abstract class Inject[F[_], G[_]] {
  def inj[A](fa: F[A]): G[A]

  def prj[A](ga: G[A]): Option[F[A]]
}

private[free] sealed abstract class InjectInstances {
  implicit def catsFreeReflexiveInjectInstance[F[_]]: Inject[F, F] =
    new Inject[F, F] {
      def inj[A](fa: F[A]): F[A] = fa

      def prj[A](ga: F[A]): Option[F[A]] = Some(ga)
    }

  implicit def catsFreeLeftInjectInstance[F[_], G[_]]: Inject[F, Coproduct[F, G, ?]] =
    new Inject[F, Coproduct[F, G, ?]] {
      def inj[A](fa: F[A]): Coproduct[F, G, A] = Coproduct.leftc(fa)

      def prj[A](ga: Coproduct[F, G, A]): Option[F[A]] = ga.run.fold(Some(_), _ => None)
    }

  implicit def catsFreeRightInjectInstance[F[_], G[_], H[_]](implicit I: Inject[F, G]): Inject[F, Coproduct[H, G, ?]] =
    new Inject[F, Coproduct[H, G, ?]] {
      def inj[A](fa: F[A]): Coproduct[H, G, A] = Coproduct.rightc(I.inj(fa))

      def prj[A](ga: Coproduct[H, G, A]): Option[F[A]] = ga.run.fold(_ => None, I.prj)
    }
}

inj[A](fa: F[A]):G[A]代表将F[A]注入更大的语法集G[A]。cats提供了三种实现了ink函数的Inject隐式实例：

1、catsFreeReflexiveInjectInstance:Inject[F,F]：对单一语法，无须构建Coproduct

2、catsFreeLeftInjectInstance:Inject[F,Coproduct[F,G,?]]：构建Coproduct结构并将F放在左边

3、catsFreeRightInjectInstance:Inject[F,Coproduct[H,G,?]]：把F注入到已经包含H,G的Coproduct[H,G,?]

有了这三种实例后我们可以根据解析到的隐式实例类型使用inj函数通过Coproduct构建更大的语法集了。我们可以通过implicitly来验证一下Interact和Login语法的Inject隐式实例：

    val selfInj = implicitly[Inject[Interact,Interact]]
    type LeftInterLogin[A] = Coproduct[Interact,Login,A]
    val leftInj = implicitly[Inject[Interact,LeftInterLogin]]
    type RightInterLogin[A] = Coproduct[Login,LeftInterLogin,A]
    val rightInj = implicitly[Inject[Interact,RightInterLogin]]


现在我们可以用Inject.inj和Free.liftF把Interact和Login升格成Free[G,A]。G是个类型变量，Interact和Login在Coproduct的最终左右位置由当前Inject隐式实例类型决定： 

  object ADTs {
    sealed trait Interact[+A]
    object Interact {
      case class Ask(prompt: String) extends Interact[String]
      case class Tell(msg: String) extends Interact[Unit]
      type FreeInteract[A] = Free[Interact,A]
      //def ask(prompt: String): FreeInteract[String] = Free.liftF(Ask(prompt))
      //def tell(msg: String): FreeInteract[Unit] = Free.liftF(Tell(msg))
      def ask[G[_]](prompt: String)(implicit I: Inject[Interact,G]): Free[G,String] =
        Free.liftF(I.inj(Ask(prompt)))
      def tell[G[_]](msg: String)(implicit I: Inject[Interact,G]): Free[G,Unit] =
        Free.liftF(I.inj(Tell(msg)))
    }

    sealed trait Login[+A]
    object Login {
      type FreeLogin[A] = Free[Login,A]
      case class Authenticate(user: String, pswd: String) extends Login[Boolean]
      //def authenticate(user: String, pswd: String): FreeLogin[Boolean] =
      //  Free.liftF(Authenticate(user,pswd))
      def authenticate[G[_]](user: String, pswd: String)(implicit I: Inject[Login,G]): Free[G,Boolean] =
        Free.liftF(I.inj(Authenticate(user,pswd)))
    }

现在我们可以用混合语法的DSL来编程了： 

  object DSLs {
    import ADTs._
    import Interact._
    import Login._
    val interactDSL: FreeInteract[Unit] = for {
      first <- ask("What's your first name?")
      last <- ask("What's your last name?")
      _ <- tell(s"Hello, $first $last!")
    } yield()

    val loginDSL: FreeLogin[Boolean] = for {
      login <- authenticate("Tiger","123")
    } yield login

    type InteractLogin[A] = Coproduct[Interact,Login,A]
    val interactLoginDSL: Free[InteractLogin,Boolean] = for {
      uid <- ask[InteractLogin]("Enter your User ID:")
      pwd <- ask[InteractLogin]("Enter your Password:")
      aut <- authenticate[InteractLogin](uid,pwd)
    } yield aut
  }


在interactLoginDSL里所有ADT通过Inject隐式实例都被自动升格成统一的Free[Coproduct[Interact,Login,A]]。

interactLogin的功能实现方式之一示范如下：

  object IMPLs {
    import cats.{Id,~>}
    import ADTs._,Interact._,Login._
    import DSLs._
    object InteractConsole extends (Interact ~> Id) {
      def apply[A](ia: Interact[A]): Id[A] = ia match {
        case Ask(p) => {println(p); readLine}
        case Tell(m) => println(m)
      }
    }
    object LoginMock extends (Login ~> Id) {
      def apply[A](la: Login[A]): Id[A] = la match {
        case Authenticate(u,p) => if (u == "Tiger" && p == "123") true else false
      }
    }
    val interactLoginMock: (InteractLogin ~> Id) = InteractConsole.or(LoginMock)
  }


这个interactLoginMock就是一个Interact,Login混合语法程序的功能实现。不过我们还是应该赋予Login一个比较实在点的实现：我们可以用一种依赖注入方式通过Reader数据类型把外部系统的用户密码验证的方法传入： 

  import Dependencies._
    import cats.data.Reader
    type ReaderPass[A] = Reader[PasswordControl,A]
    object LoginToReader extends (Login ~> ReaderPass) {
      def apply[A](la: Login[A]): ReaderPass[A] = la match {
        case Authenticate(u,p) => Reader{pc => pc.matchUserPassword(u,p)}
      }
    }
    object InteractToReader extends (Interact ~> ReaderPass) {
      def apply[A](ia: Interact[A]): ReaderPass[A] = ia match {
        case Ask(p) => {println(p); Reader(pc => readLine)}
        case Tell(m) => {println(m); Reader(pc => ())}
      }
    }
    val userLogin: (InteractLogin ~> ReaderPass) = InteractToReader or LoginToReader


假设用户密码验证由外部另一个系统负责，PasswordControl是与这个外部系统的界面（interface）： 

object Dependencies {
  trait PasswordControl {
    val mapPasswords: Map[String,String]
    def matchUserPassword(uid: String, pwd: String): Boolean
  }
}


我们用Reader来注入PasswordControl这个外部依赖（dependency injection IOC）。因为Interact和Login结合形成的是一个统一的语句集，所以我们必须进行Interact与ReaderPass对应。下面我们先构建一个PasswordControl对象作为模拟数据，然后试运行： 

object catsComposeFree extends App {
  import Dependencies._
  import FreeModules._
  import DSLs._
  import IMPLs._
  object UserPasswords extends PasswordControl {
    override val mapPasswords: Map[String, String] = Map(
      "Tiger" -> "123",
      "John" -> "456"
    )
    override def matchUserPassword(uid: String, pwd: String): Boolean =
      mapPasswords.getOrElse(uid,pwd+"!") == pwd
  }

  val r = interactLoginDSL.foldMap(userLogin).run(UserPasswords)
  println(r)

}

运算结果： 

Enter your User ID:
Tiger
Enter your Password:
123
true
...
Enter your User ID:
Chan
Enter your Password:
123
false


我们再用这个混合的DSL编个稍微完整点的程序： 

    val userLoginDSL: Free[InteractLogin,Unit] = for {
      uid <- ask[InteractLogin]("Enter your User ID:")
      pwd <- ask[InteractLogin]("Enter your Password:")
      aut <- authenticate[InteractLogin](uid,pwd)
      _ <- if (aut) tell[InteractLogin](s"Hello $uid")
           else tell[InteractLogin]("Sorry, who are you?")
    } yield()


运算这个程序不需要任何修改： 

  //val r = interactLoginDSL.foldMap(userLogin).run(UserPasswords)
  //println(r)
  userLoginDSL.foldMap(userLogin).run(UserPasswords)


现在结果变成了： 

Enter your User ID:
Tiger
Enter your Password:
123
Hello Tiger
...
Enter your User ID:
CHAN
Enter your Password:
123
Sorry, who are you?


如果我们在这两个语法的基础上再增加一个模拟权限管理的语法，ADT设计如下：

    sealed trait Auth[+A]
    object Auth {
      case class Authorize(uid: String) extends Auth[Boolean]
      def authorize[G[_]](uid:String)(implicit I: Inject[Auth,G]): Free[G,Boolean] =
        Free.liftF(I.inj(Authorize(uid)))
    }


假设实际的权限管理依赖外部系统，我们先定义它的界面： 

object Dependencies {
  trait PasswordControl {
    val mapPasswords: Map[String,String]
    def matchUserPassword(uid: String, pwd: String): Boolean
  }
  trait PermControl {
    val mapAuthorized: Map[String,Boolean]
    def authorized(uid: String): Boolean
  }
}

再用三种语法合成的DSL来编一段程序： 

    import Auth._
    type Permit[A] = Coproduct[Auth,InteractLogin,A]
    val userPermitDSL: Free[Permit,Unit] = for {
      uid <- ask[Permit]("Enter your User ID:")
      pwd <- ask[Permit]("Enter your Password:")
      auth <- authenticate[Permit](uid,pwd)
      perm <- if(auth) authorize[Permit](uid)
              else Free.pure[Permit,Boolean](false)
      _ <- if (perm) tell[Permit](s"Hello $uid, welcome to the program!")
           else tell[Permit]("Sorry, no no no!")
    } yield()


很遗憾，这段代码无法通过编译，cats还无法处理多层递归Coproduct。对Coproduct的处理scalaz还是比较成熟的，我在之前写过一篇scalaz Coproduct Free的博客，里面用的例子就是三种语法的DSL。实际上不单只是Coproduct的问题，现在看来cats.Free对即使很简单的应用功能也有着很复杂无聊的代码需求，这是我们无法接受的。由于Free编程在函数式编程里占据着如此重要的位置，我们暂时还没有其它选择，所以必须寻找一个更好的编程工具才行，freeK就是个这样的函数组件库。我们将在下篇讨论里用freeK来实现多种语法DSL编程。

无论如何，我还是把这篇讨论的示范代码附在下面：

import cats.data.Coproduct
import cats.free.{Free, Inject}
object FreeModules {
  object ADTs {
    sealed trait Interact[+A]
    object Interact {
      case class Ask(prompt: String) extends Interact[String]
      case class Tell(msg: String) extends Interact[Unit]
      type FreeInteract[A] = Free[Interact,A]
      //def ask(prompt: String): FreeInteract[String] = Free.liftF(Ask(prompt))
      //def tell(msg: String): FreeInteract[Unit] = Free.liftF(Tell(msg))
      def ask[G[_]](prompt: String)(implicit I: Inject[Interact,G]): Free[G,String] =
        Free.liftF(I.inj(Ask(prompt)))
      def tell[G[_]](msg: String)(implicit I: Inject[Interact,G]): Free[G,Unit] =
        Free.liftF(I.inj(Tell(msg)))
    }

    sealed trait Login[+A]
    object Login {
      type FreeLogin[A] = Free[Login,A]
      case class Authenticate(user: String, pswd: String) extends Login[Boolean]
      //def authenticate(user: String, pswd: String): FreeLogin[Boolean] =
      //  Free.liftF(Authenticate(user,pswd))
      def authenticate[G[_]](user: String, pswd: String)(implicit I: Inject[Login,G]): Free[G,Boolean] =
        Free.liftF(I.inj(Authenticate(user,pswd)))
    }

    sealed trait Auth[+A]
    object Auth {
      case class Authorize(uid: String) extends Auth[Boolean]
      def authorize[G[_]](uid:String)(implicit I: Inject[Auth,G]): Free[G,Boolean] =
        Free.liftF(I.inj(Authorize(uid)))
    }
    val selfInj = implicitly[Inject[Interact,Interact]]
    type LeftInterLogin[A] = Coproduct[Interact,Login,A]
    val leftInj = implicitly[Inject[Interact,LeftInterLogin]]
    type RightInterLogin[A] = Coproduct[Login,LeftInterLogin,A]
    val rightInj = implicitly[Inject[Interact,RightInterLogin]]
  }

  object DSLs {
    import ADTs._
    import Interact._
    import Login._
    val interactDSL: FreeInteract[Unit] = for {
      first <- ask("What's your first name?")
      last <- ask("What's your last name?")
      _ <- tell(s"Hello, $first $last!")
    } yield()

    val loginDSL: FreeLogin[Boolean] = for {
      login <- authenticate("Tiger","123")
    } yield login

    type InteractLogin[A] = Coproduct[Interact,Login,A]
    val interactLoginDSL: Free[InteractLogin,Boolean] = for {
      uid <- ask[InteractLogin]("Enter your User ID:")
      pwd <- ask[InteractLogin]("Enter your Password:")
      aut <- authenticate[InteractLogin](uid,pwd)
    } yield aut
    val userLoginDSL: Free[InteractLogin,Unit] = for {
      uid <- ask[InteractLogin]("Enter your User ID:")
      pwd <- ask[InteractLogin]("Enter your Password:")
      aut <- authenticate[InteractLogin](uid,pwd)
      _ <- if (aut) tell[InteractLogin](s"Hello $uid")
           else tell[InteractLogin]("Sorry, who are you?")
    } yield()
  /*  import Auth._
    type Permit[A] = Coproduct[Auth,InteractLogin,A]
    val userPermitDSL: Free[Permit,Unit] = for {
      uid <- ask[Permit]("Enter your User ID:")
      pwd <- ask[Permit]("Enter your Password:")
      auth <- authenticate[Permit](uid,pwd)
      perm <- if(auth) authorize[Permit](uid)
              else Free.pure[Permit,Boolean](false)
      _ <- if (perm) tell[Permit](s"Hello $uid, welcome to the program!")
           else tell[Permit]("Sorry, no no no!")
    } yield() */
  }
  object IMPLs {
    import cats.{Id,~>}
    import ADTs._,Interact._,Login._
    import DSLs._
    object InteractConsole extends (Interact ~> Id) {
      def apply[A](ia: Interact[A]): Id[A] = ia match {
        case Ask(p) => {println(p); readLine}
        case Tell(m) => println(m)
      }
    }
    object LoginMock extends (Login ~> Id) {
      def apply[A](la: Login[A]): Id[A] = la match {
        case Authenticate(u,p) => if (u == "Tiger" && p == "123") true else false
      }
    }
    val interactLoginMock: (InteractLogin ~> Id) = InteractConsole.or(LoginMock)
    import Dependencies._
    import cats.data.Reader
    type ReaderPass[A] = Reader[PasswordControl,A]
    object LoginToReader extends (Login ~> ReaderPass) {
      def apply[A](la: Login[A]): ReaderPass[A] = la match {
        case Authenticate(u,p) => Reader{pc => pc.matchUserPassword(u,p)}
      }
    }
    object InteractToReader extends (Interact ~> ReaderPass) {
      def apply[A](ia: Interact[A]): ReaderPass[A] = ia match {
        case Ask(p) => {println(p); Reader(pc => readLine)}
        case Tell(m) => {println(m); Reader(pc => ())}
      }
    }
    val userLogin: (InteractLogin ~> ReaderPass) = InteractToReader or LoginToReader

  }
}
object Dependencies {
  trait PasswordControl {
    val mapPasswords: Map[String,String]
    def matchUserPassword(uid: String, pwd: String): Boolean
  }
  trait PermControl {
    val mapAuthorized: Map[String,Boolean]
    def authorized(uid: String): Boolean
  }
}

object catsComposeFree extends App {
  import Dependencies._
  import FreeModules._
  import DSLs._
  import IMPLs._
  object UserPasswords extends PasswordControl {
    override val mapPasswords: Map[String, String] = Map(
      "Tiger" -> "123",
      "John" -> "456"
    )
    override def matchUserPassword(uid: String, pwd: String): Boolean =
      mapPasswords.getOrElse(uid,pwd+"!") == pwd
  }

  //val r = interactLoginDSL.foldMap(userLogin).run(UserPasswords)
  //println(r)
  userLoginDSL.foldMap(userLogin).run(UserPasswords)

}

















TIGER_XC
关注
专栏目录
scalaz-and-cats：Scalaz和Cats之间的用法示例和基准（w Haskell Ground-truth）
02-04
scalaz-and-cats：Scalaz和Cats之间的用法示例和基准（w Haskell Ground-truth）
pureharm-effects-cats:cats + cats-effect +“ pureharm”的fs2模块
04-07
这是针对那些意识到没有将cats ， cats-effect ， fs2视为标准库就不能真正编写任何生产应用程序的开发人员的。 package myapp import busymachines . pureharm package object effects extends
探索Scala编程的新维度：ScalaZ与Cats
最新发布
gitblog_00028的博客
05-21 254
探索Scala编程的新维度：ScalaZ与Cats 项目地址:https://gitcode.com/fosskers/scalaz-and-cats 项目简介 在Scala的世界里，ScalaZ和Cats是两个备受瞩目的函数式编程库，为开发者提供了诸如Monad等核心概念的实现。它们不仅帮助提升团队对功能性编程的理解，还能改善代码质量，优化性能敏感的应用。这个开源项目是一个公正的比较，旨在帮你选...
工资管理系统
dayouxiang0367的博客
11-25 193
//本程序主要采用链表，结合文件的操作实现 #include<stdio.h> #include<dos.h> #include<conio.h> #include<stdlib.h>#include<string.h>#include<mem.h> #include<ctype.h>#inclu...
CATS软件安装[2022.1.20更新]
无
09-04 4493
官方网址：http://web.mit.edu/mfloyd/www/computing/cats/ 教学视频：https://ke.qq.com/course/283024 1.Linux下解压文件与压缩文件： （1）压缩文件。命令格式： tar -zcvf 压缩文件名：.tar.gz （2）解压文件。命令格式： tar -zxvf 压缩文件名：.tar.gz 压缩后的文件只能放在当...
dogs-vs-cats-redux-kernels-edition.zip
07-15
kaggle官网猫狗数据集下载速度太慢了，分享给大家下载。dogs-vs-cats-redux-kernels-edition.zip解压后有train.zip、test.zip，还有sample_submission.csv。
猫狗数据集cats-and-dogs-small.zip
03-02
《猫狗数据集cats-and-dogs-small.zip：深度学习中的图像分类初探》 在人工智能领域，特别是机器学习和深度学习部分，数据集是至关重要的组成部分。本文将深入探讨一个广为使用的数据集——"猫狗数据集"，具体版本...
cats-blender-plugin-源码.rar
10-10
本文将对"cats-blender-plugin-源码.zip"中的关键知识点进行详细的解读。 首先，Blender插件的开发基于Python语言，因此理解Python基础和Blender API是必不可少的。Blender的API允许开发者访问和控制软件的各个层面...
中信证券自动化交易平台(CATS)-API参考
03-22
2. CATS API函数分类 函数分为多个类别，包括初始化和退出清理、通信会话管理、版本信息获取、连接服务器、工具函数、接口入出参处理、数据库操作以及账户和交易订阅相关功能。 - 初始化及退出清理：如CATSAPI_Init...
JAVA基础02_Java程序设计结构00_格式化输出
gonggui的博客
11-27 114
  1.         每个以%字符开始的格式说明符都用相应的参数替换，格式说明符尾部的转换符用于指示被格式化的数值类型，常见的转换符有： （1）       f表示浮点数 （2）       s表示字符串 （3）       d表示十进制数 （4）       tx表示日期时间 （5）       %表示% （6）       n表示行分割符 public cla...
Java——数组习题
ivhs的博客
04-08 2171
package chap02; import java.util.Scanner; /** * * @author admin * @date 2020-4-8 * description: * 题目内容： 编写程序， 从控制台读取下面的信息， 每月按22天工作日计算，结果保留两位小数，输出月薪。 员工姓名（如： zhangmin ） 每天的工作小时数（如: 8 ） 每小时的酬金（...
Java 学习笔记二
huahuahailang的专栏
11-19 1037
标准输入输出 Scanner类 Scanner s=new Scanner (System.in); import java.util.Scanner; public class  TestInput{ public static void main(String []args){ Scanner s=new Scanner (System.in); System.out.p
浅谈Slick（3）－ Slick201：从fp角度了解Slick
TIGER_XC的专栏
09-30 1315
我在上期讨论里已经成功的创建了一个简单的Slick项目，然后又尝试使用了一些最基本的功能。Slick是一个FRM（Functional Relational Mapper）,是为fp编程提供的scala SQL Query集成环境，这可以让编程人员在scala编程语言里用函数式编程模式来实现对数据库的操作。在这片讨论里我想以函数式思考模式来加深了解Slick。我对fp编程模式印象最深的就是类型匹配
细谈Slick（5）－ 学习体会和将来实际应用的一些想法
TIGER_XC的专栏
10-14 1239
通过一段时间的学习和了解以及前面几篇关于Slick的讨论后对Slick这个函数式数据库编程工具有了些具体的了解。回顾我学习Slick的目的，产生了许多想法，觉着应该从实际工作应用的角度把我对Slick目前能够达到的目的及在现有功能的优势和特点下如何能进一步改进来正真符合IT系统对数据库程序编程和运行效率的要求这些想法提供出来跟大家分享一下，看看是否能够引起大家的共鸣，为我下一步的工作制定一个方向性
浅谈Slick（1）－ 基本功能描述
TIGER_XC的专栏
09-21 1238
Slick (Scala language-integrated connection kit)是scala的一个FRM（Functional Relational Mapper），即函数式的关系数据库编程工具库。Slick的主要目的是使关系数据库能更容易、更自然的融入函数式编程模式，它可以使使用者像对待scala集合一样来处理关系数据库表。也就是说可以用scala集合的那些丰富的操作函数来处理库
Cats（3）－ freeK-Free编程更轻松，Free programming with freeK
TIGER_XC的专栏
09-09 1006
在上一节我们讨论了通过Coproduct来实现DSL组合：用一些功能简单的基础DSL组合成符合大型多复杂功能应用的DSL。但是我们发现：cats在处理多层递归Coproduct结构时会出现编译问题。再就是Free编程是一个繁复的工作，容易出错，造成编程效率的低下。由于Free编程目前是函数式编程的主要方式（我各人认为），我们必须克服Free编程的效率问题。通过尝试，发现freeK可以作为一个很好的
浅谈Slick（4）－ Slick301：我的Slick开发项目设置
TIGER_XC的专栏
10-04 900
前面几篇介绍里尝试了一些Slick的功能和使用方式，看来基本可以满足用scala语言进行数据库操作编程的要求，而且有些代码可以通过函数式编程模式来实现。我想，如果把Slick作为数据库操作编程的主要方式的话，可能需要弄一套比较规范的模式来应付日常开发（也要考虑团队开发）、测试和维护。
FunDA：一个开源的函数式数据处理工具库，也是Slick的补充
TIGER_XC的专栏
04-08 889
如果你是一个Slick用户，或者你是一个数据库编程人员正在尝试进入函数式编程模式，那么FunDA可能会帮到你。 目前市面上FRM(Functional Relational Mapper)，即函数式的数据库处理工具库的选择并不多，Typesafe公司的Slick可能是最通用的选择了。整体上来说：Slick还是一个不错的函数式数据库编程工具，用scala语言，很多地方引用了函数式的抽象模式和对象（
cats-blender-plugin-master
07-25
cats-blender-plugin-master是一个用于将pmx格式转换为fbx格式的插件。你可以通过以下步骤来安装cats插件并使用它进行格式转换： 1. 首先，你需要下载cats插件。你可以在Gitee加速地址上找到插件的下载链接。下载...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值