可应用和可遍历函子(Applicative And Traversable Functor)在Scala中的应用笔记

2025高教社数学建模国赛A题 - 烟幕干扰弹的投放策略(完整参考论文) 摘要:本研究基于模拟遗传退火算法优化无人机投放烟幕弹策略,建立三维运动学模型分析遮蔽效果。针对不同战术场景(单机单弹至多机多弹),构建以遮蔽时间最大化为目标的非线性优化模型。通过改进遗传算法求解最优参数组合,结果显示在给定条件下单枚烟幕弹对M1导弹的有效遮蔽时长可达1.4秒。研究为无人机协同干扰提供了高效解决方案,验证了智能算法在复杂战术决策中的适用性。关键词:烟幕干扰;无人机投弹;运动学建模;时序优化;遗传算法。 阅读详情

这个例子来源于scala圣经级教程《Functional Programming in Scala》,虽然原书的随书代码可以找到这些类的影子,但却没有关于如何使用这些类的示例代码,本人在阅读此书期间,除了跟着书中的代码敲了一遍之外,还写了一些测试代码进行验证,贴出来作为blog主要是为了方便自己,也为那些同样在阅读此书的人参考, 因为或许有可能你看了书本也不知道如何使用这些现成的函数和库。注释不多,本人也不可能写太多,因为这本书不是简单的入门书,而是一本进阶,升华用的内涵书籍,三言两语也解释不清其中的很多细节,如果看不懂,但是又感兴趣的就去看原书吧……


package applicative

import monad.Functor
import monoids._
import state.State._
import state._

import scala.language.{higherKinds, implicitConversions}

trait Applicative[F[_]] extends Functor[F] {
  // `map2` is implemented by first currying `f` so we get a function
  // of type `A => B => C`. This is a function that takes `A` and returns
  // another function of type `B => C`. So if we map `f.curried` over an
  // `F[A]`, we get `F[B => C]`. Passing that to `apply` along with the
  // `F[B]` will give us the desired `F[C]`.
  def map2[A,B,C](fa: F[A], fb: F[B])(f: (A, B) => C): F[C] =
    apply(map(fa)(f.curried))(fb)

  // We simply use `map2` to lift a function into `F` so we can apply it
  // to both `fab` and `fa`. The function being lifted here is `_(_)`,
  // which is the same as the lambda notation `(f, x) => f(x)`. That is,
  // It's a function that takes two arguments:
  //   1. A function `f`
  //   2. An argument `x` to that function
  // and it simply applies `f` to `x`.
  def apply[A,B](fab: F[A => B])(fa: F[A]): F[B] =
    map2(fab, fa)(_(_))

  def unit[A](a: => A): F[A]

  def map[A,B](fa: F[A])(f: A => B): F[B] =
    apply(unit(f))(fa)

  def sequence[A](fas: List[F[A]]): F[List[A]] =
    traverse(fas)(fa => fa)

  def traverse[A,B](as: List[A])(f: A => F[B]): F[List[B]] =
    as.foldRight(unit(List[B]()))((a, fbs) => map2(f(a), fbs)(_ :: _))

  def replicateM[A](n: Int, fa: F[A]): F[List[A]] =
    sequence(List.fill(n)(fa))

  def factor[A,B](fa: F[A], fb: F[B]): F[(A,B)] =
    map2(fa, fb)((_,_))

  def product[G[_]](G: Applicative[G]): Applicative[({type f[x] = (F[x], G[x])})#f] = {
    val self = this
    new Applicative[({type f[x] = (F[x], G[x])})#f] {
      def unit[A](a: => A) = (self.unit(a), G.unit(a))
      override def apply[A,B](fs: (F[A => B], G[A => B]))(p: (F[A], G[A])) =
        (self.apply(fs._1)(p._1), G.apply(fs._2)(p._2))
    }
  }

  // Here we simply use `map2` to lift `apply` and `unit` themselves from one
  // Applicative into the other.
  // If `self` and `G` both satisfy the laws, then so does the composite.
  // The full proof can be found at
  // https://github.com/runarorama/sannanir/blob/master/Applicative.v
  def compose[G[_]](G: Applicative[G]): Applicative[({type f[x] = F[G[x]]})#f] = {
    val self = this
    new Applicative[({type f[x] = F[G[x]]})#f] {
      def unit[A](a: => A) = self.unit(G.unit(a))
      override def map2[A,B,C](fga: F[G[A]], fgb: F[G[B]])(f: (A,B) => C) =
        self.map2(fga, fgb)(G.map2(_,_)(f))
    }
  }

  def sequenceMap[K,V](ofa: Map[K,F[V]]): F[Map[K,V]] =
    (ofa foldLeft unit(Map.empty[K,V])) { case (acc, (k, fv)) =>
      map2(acc, fv)((m, v) => m + (k -> v))
    }

}

sealed trait Validation[+E, +A]

case class Failure[E](head: E, tail: Vector[E])
  extends Validation[E, Nothing]

case class Success[A](a: A) extends Validation[Nothing, A]

object Applicative {
  val streamApplicative = new Applicative[Stream] {

    def unit[A](a: => A): Stream[A] =
      Stream.continually(a) // The infinite, constant stream

    override def map2[A,B,C](a: Stream[A], b: Stream[B])( // Combine elements pointwise
                                                          f: (A,B) => C): Stream[C] =
      a zip b map f.tupled
  }

  def validationApplicative[E]: Applicative[({type f[x] = Validation[E,x]})#f] =
    new Applicative[({type f[x] = Validation[E,x]})#f] {
      def unit[A](a: => A) = Success(a)
      override def map2[A,B,C](fa: Validation[E,A], fb: Validation[E,B])(f: (A, B) => C) =
        (fa, fb) match {
          case (Success(a), Success(b)) => Success(f(a, b))
          case (Failure(h1, t1), Failure(h2, t2)) =>
            Failure(h1, t1 ++ Vector(h2) ++ t2)
          case (e@Failure(_, _), _) => e
          case (_, e@Failure(_, _)) => e
        }
    }

  type Const[A, B] = A

  implicit def monoidApplicative[M](M: Monoid[M]) =
    new Applicative[({ type f[x] = Const[M, x] })#f] {
      def unit[A](a: => A): M = M.zero
      override def apply[A,B](m1: M)(m2: M): M = M.op(m1, m2)
    }

}

trait Monad[F[_]] extends Applicative[F] {
  def flatMap[A,B](ma: F[A])(f: A => F[B]): F[B] =
    join(map(ma)(f))

  override def apply[A,B](mf: F[A => B])(ma: F[A]): F[B] =
    flatMap(mf)(f => map(ma)(f))

  override def map[A,B](m: F[A])(f: A => B): F[B] =
    flatMap(m)(a => unit(f(a)))

  override def map2[A,B,C](ma: F[A], mb: F[B])(f: (A, B) => C): F[C] =
    flatMap(ma)(a => map(mb)(b => f(a, b)))

  def compose[A,B,C](f: A => F[B], g: B => F[C]): A => F[C] =
    a => flatMap(f(a))(g)

  def join[A](mma: F[F[A]]): F[A] = flatMap(mma)(ma => ma)
}

object Monad {

  // Notice that in the case of a `Left`, flatMap does nothing.
  def eitherMonad[E]: Monad[({type f[x] = Either[E, x]})#f] =
    new Monad[({type f[x] = Either[E, x]})#f] {
      def unit[A](a: => A): Either[E, A] = Right(a)
      override def flatMap[A,B](eea: Either[E, A])(f: A => Either[E, B]) = eea match {
        case Right(a) => f(a)
        case Left(b) => Left(b)
      }
    }

  def stateMonad[S] = new Monad[({type f[x] = State[S, x]})#f] {
    def unit[A](a: => A): State[S, A] = State(s => (a, s))
    override def flatMap[A,B](st: State[S, A])(f: A => State[S, B]): State[S, B] =
      st flatMap f
  }

  // Monad composition
  def composeM[G[_],H[_]](implicit G: Monad[G], H: Monad[H], T: Traverse[H]):
  Monad[({type f[x] = G[H[x]]})#f] = new Monad[({type f[x] = G[H[x]]})#f] {
    def unit[A](a: => A): G[H[A]] = G.unit(H.unit(a))
    override def flatMap[A,B](mna: G[H[A]])(f: A => G[H[B]]): G[H[B]] =
      G.flatMap(mna)(na => G.map(T.traverse(na)(f))(H.join))
  }

}

trait Traverse[F[_]] extends Functor[F] with Foldable[F] { self =>
  def traverse[M[_]:Applicative,A,B](fa: F[A])(f: A => M[B]): M[F[B]] =
    sequence(map(fa)(f))
  def sequence[M[_]:Applicative,A](fma: F[M[A]]): M[F[A]] =
    traverse(fma)(ma => ma)

  type Id[A] = A

  val idMonad = new Monad[Id] {
    def unit[A](a: => A) = a
    override def flatMap[A,B](a: A)(f: A => B): B = f(a)
  }

  def map[A,B](fa: F[A])(f: A => B): F[B] =
    traverse[Id, A, B](fa)(f)(idMonad)

  import Applicative._

  override def foldMap[A,B](as: F[A])(f: A => B)(mb: Monoid[B]): B =
    traverse[({type f[x] = Const[B,x]})#f,A,Nothing](
      as)(f)(monoidApplicative(mb))

  def traverseS[S,A,B](fa: F[A])(f: A => State[S, B]): State[S, F[B]] =
    traverse[({type f[x] = State[S, x]})#f, A, B](fa)(f)(Monad.stateMonad)

  def zipWithIndex_[A](ta: F[A]): F[(A,Int)] =
    traverseS(ta)((a: A) => (for {
      i <- get[Int]
      _ <- set(i + 1)
    } yield (a, i))).run(0)._1

  def toList_[A](fa: F[A]): List[A] =
    traverseS(fa)((a: A) => (for {
      as <- get[List[A]] // Get the current state, the accumulated list.
      _  <- set(a :: as) // Add the current element and set the new list as the new state.
    } yield ())).run(Nil)._2.reverse

  def mapAccum[S,A,B](fa: F[A], s: S)(f: (A, S) => (B, S)): (F[B], S) =
    traverseS(fa)((a: A) => (for {
      s1 <- get[S]
      (b, s2) = f(a, s1)
      _  <- set(s2)
    } yield b)).run(s)

  override def toList[A](fa: F[A]): List[A] =
    mapAccum(fa, List[A]())((a, s) => ((), a :: s))._2.reverse

  def zipWithIndex[A](fa: F[A]): F[(A, Int)] =
    mapAccum(fa, 0)((a, s) => ((a, s), s + 1))._1

  def reverse[A](fa: F[A]): F[A] =
    mapAccum(fa, toList(fa).reverse)((_, as) => (as.head, as.tail))._1

  override def foldLeft[A,B](fa: F[A])(z: B)(f: (B, A) => B): B =
    mapAccum(fa, z)((a, b) => ((), f(b, a)))._2

  def zip[A,B](fa: F[A], fb: F[B]): F[(A, B)] =
    (mapAccum(fa, toList(fb)) {
      case (a, Nil) => sys.error("zip: Incompatible shapes.")
      case (a, b :: bs) => ((a, b), bs)
    })._1

  def zipL[A,B](fa: F[A], fb: F[B]): F[(A, Option[B])] =
    (mapAccum(fa, toList(fb)) {
      case (a, Nil) => ((a, None), Nil)
      case (a, b :: bs) => ((a, Some(b)), bs)
    })._1

  def zipR[A,B](fa: F[A], fb: F[B]): F[(Option[A], B)] =
    (mapAccum(fb, toList(fa)) {
      case (b, Nil) => ((None, b), Nil)
      case (b, a :: as) => ((Some(a), b), as)
    })._1

  def fuse[M[_],N[_],A,B](fa: F[A])(f: A => M[B], g: A => N[B])
                         (implicit M: Applicative[M], N: Applicative[N]): (M[F[B]], N[F[B]]) =
    traverse[({type f[x] = (M[x], N[x])})#f, A, B](fa)(a => (f(a), g(a)))(M product N)

  def compose[G[_]](implicit G: Traverse[G]): Traverse[({type f[x] = F[G[x]]})#f] =
    new Traverse[({type f[x] = F[G[x]]})#f] {
      override def traverse[M[_]:Applicative,A,B](fa: F[G[A]])(f: A => M[B]) =
        self.traverse(fa)((ga: G[A]) => G.traverse(ga)(f))
    }
}

case class Tree[+A](head: A, tail: List[Tree[A]])

object Traverse {
  val listTraverse = new Traverse[List] {
    override def traverse[M[_],A,B](as: List[A])(f: A => M[B])(implicit M: Applicative[M]): M[List[B]] =
      as.foldRight(M.unit(List[B]()))((a, fbs) => M.map2(f(a), fbs)(_ :: _))
  }

  val optionTraverse = new Traverse[Option] {
    override def traverse[M[_],A,B](oa: Option[A])(f: A => M[B])(implicit M: Applicative[M]): M[Option[B]] =
      oa match {
        case Some(a) => M.map(f(a))(Some(_))
        case None    => M.unit(None)
      }
  }

  val treeTraverse = new Traverse[Tree] {
    override def traverse[M[_],A,B](ta: Tree[A])(f: A => M[B])(implicit M: Applicative[M]): M[Tree[B]] =
      M.map2(f(ta.head), listTraverse.traverse(ta.tail)(a => traverse(a)(f)))(Tree(_, _))
  }

  // An example of a Foldable that is not a functor
  case class Iteration[A](a: A, f: A => A, n: Int) {
    def foldMap[B](g: A => B)(M: Monoid[B]): B = {
      def iterate(n: Int, b: B, c: A): B =
        if (n <= 0) b else iterate(n-1, g(c), f(a))
      iterate(n, M.zero, a)
    }
  }
}




object Test  {

  def main(args: Array[String]): Unit = {

    val streamApplicative = Applicative.streamApplicative

    val ones = streamApplicative.unit(1)
    val twos = streamApplicative.unit(2)


    println(streamApplicative.map2(ones, twos)(_ -> _).take(10))
    println(streamApplicative.map2(ones, twos)(_ -> _).take(10).toList)

    import Applicative._

    import scala.language.implicitConversions
    val intMonoidApplicative = Monoid.intAddition
    println(intMonoidApplicative(1)(2))
    println(intMonoidApplicative.unit(8))


    //通过compose得到一个产生流的流
    val composedStream = streamApplicative.compose(streamApplicative)
    println(composedStream.unit(1).take(4).toList)


    val validationComposeStream = Applicative.validationApplicative[Exception].compose(streamApplicative)
    println(validationComposeStream.unit(0))

    //反过来调用,类型推导错误,汗
    //val streamComposeValidation= streamApplicative.compose(Applicative.validationApplicative[Exception])
    //println(streamApplicative.unit(0))


    println(Monad.stateMonad[List[Int]].unit(5).run(Nil))

    val listTraverse = Traverse.listTraverse

    val li = List(1, 2, 3, 4, 5, 6, 7, 8)

    val listTraverseS = listTraverse.traverseS[Int, Int, Int](li)((a: Int) => State.unit(a))
    println(listTraverseS.run(0))


    val zipWithIndexRes = listTraverse.zipWithIndex(li)
    println(zipWithIndexRes)

    val zipWithIndex_Res = listTraverse.zipWithIndex_(li)
    println(zipWithIndex_Res)


    val li1 = List("one", "two", "three", "four", "five", "six", "seven")
    val li2 = List(11, 12, 13, 14, 15)

    val zipLRes = listTraverse.zipL(li1, li2)
    println(zipLRes)


    val zipRRes = listTraverse.zipR(List("one", "two", "three"), li2)
    println(zipRRes)

    val fuse = listTraverse.fuse[({type f[x] = State[Int, x]})#f, ({type f[x] = State[Int, x]})#f, Int, Int](List(1, 2, 3, 4, 5))(
      (a: Int) => State.unit(a),
      (a: Int) => State.unit(2 * a))(Monad.stateMonad, Monad.stateMonad)
    println(fuse._1.run(0))
    println(fuse._2.run(0))


    val listComposeOption = listTraverse.compose(Traverse.optionTraverse)

    val liOp1 = List(Some(3), None)
    val liOp2 = List(Some(3), Some(5))
    val f = (a: Int) => State.unit[Int, Int]( a * a)

    val listComposeOptionRes = listComposeOption.traverse[({type f[x] = State[Int, x]})#f,Int, Int](liOp1)(f)(Monad.stateMonad)
    println(listComposeOptionRes.run(0))

    val listComposeOptionRes2 = listComposeOption.traverse[({type f[x] = State[Int, x]})#f,Int, Int](liOp2)(f)(Monad.stateMonad)
    println(listComposeOptionRes2.run(0))


    val streamProduct = streamApplicative.product(streamApplicative)
    println(streamProduct.unit(1))

    val pow2 = (a: Int) => math.pow(a, 2)
    val double = (a: Int) => 2 * a
    val streamProductApplyRes = streamProduct((streamApplicative.unit(pow2),  streamApplicative.unit(double)))(streamProduct.unit(3))

    println(streamProductApplyRes)

  }

}

上述代码的运行结果是:

Stream((1,2), ?)
List((1,2), (1,2), (1,2), (1,2), (1,2), (1,2), (1,2), (1,2), (1,2), (1,2))
3
0
List(Stream(1, ?), Stream(1, ?), Stream(1, ?), Stream(1, ?))
Success(Stream(0, ?))
(5,List())
(List(1, 2, 3, 4, 5, 6, 7, 8),0)
List((1,0), (2,1), (3,2), (4,3), (5,4), (6,5), (7,6), (8,7))
List((1,0), (2,1), (3,2), (4,3), (5,4), (6,5), (7,6), (8,7))
List((one,Some(11)), (two,Some(12)), (three,Some(13)), (four,Some(14)), (five,Some(15)), (six,None), (seven,None))
List((Some(one),11), (Some(two),12), (Some(three),13), (None,14), (None,15))
(List(1, 2, 3, 4, 5),0)
(List(2, 4, 6, 8, 10),0)
(List(Some(9), None),0)
(List(Some(9), Some(25)),0)
(Stream(1, ?),Stream(1, ?))
(Stream(9.0, ?),Stream(6, ?))

879675643@qq.com  lhever

.---.                                                                         
|   |   .              __.....__   .----.     .----.   __.....__              
|   | .'|          .-''         '.  \    \   /    /.-''         '.            
|   |<  |         /     .-''"'-.  `. '   '. /'   //     .-''"'-.  `. .-,.--.  
|   | | |        /     /________\   \|    |'    //     /________\   \|  .-. | 
|   | | | .'''-. |                  ||    ||    ||                  || |  | | 
|   | | |/.'''. \\    .-------------''.   `'   .'\    .-------------'| |  | | 
|   | |  /    | | \    '-.____...---. \        /  \    '-.____...---.| |  '-  
|   | | |     | |  `.             .'   \      /    `.             .' | |      
'---' | |     | |    `''-...... -'      '----'       `''-...... -'   | |      
      | '.    | '.                                                   |_|      
      '---'   '---'  
vue2/3 - 详细实现内网使用离线高德地图功能,在vue中无需网络离线使用高德地图相关功能,高德地图如何离线加载详细教程(内网部署及使用),提供最新完整的瓦片资源下载及相关工具(示例代码,一键复制 vue,vue2,vue3,高德地图,离线使用高德地图,高德地图瓦片官方下载,vue内网使用高德地图离线无网络,断网情况下使用高德地图,vue离线高德地图教程,如何实现内网部署高德地图,无需联网离线使用,vue+ts实现离线高德地图 内网离线高德地图,如何在高德地图Vue项目中下载离线地图,高德离线地图加载不出来,高德地图离线使用不显示怎么办,怎么解决vue内网使用离线高德地图加载失败问题,vue实现离线地图+高德瓦片,vue引入高德离线地图,vue项目如何使用离线高德地图和自定义地图样式,高德离线地图的下 阅读详情

相关推荐

海外跨境电商商城源码-进出口电商平台网站-多语言多商户平台

我们的海外跨境电商系统源码还包括各种功能模块,如用户管理、商品管理、订单管理等。支付管理:与主流支付平台(如Stripe、PayPal等)的集成,支持多种支付方式;订单管理:创建订单、支付订单、取消订单等操作,以及订单状态查询和历史记录;购物车管理:添加商品到购物车、查看购物车、修改购物车中的商品数量等操作;商品管理:商品信息录入、编辑、删除等操作,以及商品分类和搜索功能。客服管理:在线咨询、投诉处理等功能,提供更好的用户服务。用户管理:注册、登录、忘记密码、个人资料。# 检查电子邮件地址是否有效。

柏诣科技的博客 2664

简单介绍函数式编程中的Functor(函子),Applicative(加强版函子),Monad(单子)

原文地址:http://skaka.me/blog/2015/12/19/functor-applicative-monad-scala-haskell/ 如果你是刚接触函数式编程,可能很容易被下面这些术语弄迷惑:Functor(函子),Applicative(加强版函子),Monad(单子)。 这些概念不是空穴来风,它们出自范畴论,如果你上网去搜范畴论,可能会找到大篇的术语定义,学术资

pingyan158的专栏 4605

Android Settings 设置Preference置灰显示

使Preference置灰显示,不能点击。先调用Preference的setEnabled(false),再调用setShouldDisableView(true); 如果使置灰项恢复正常可点击,可调用setEnabled(true)。

随风而动 1050

Functor、Applicative 和 Monad

Functor、Applicative 和 Monad 是函数式编程语言中三个非常重要的概念,尤其是 Monad ,难倒了不知道多少英雄好汉。事实上,它们的概念是非常简单的,但是却很少有文章能够将它们描述清楚,往往还适得其反,越描越黑。与其它文章不同的是,本文将从结论出发,层层深入,一步步为你揭开它们的神秘面纱。说明:本文中的主要代码为 Haskell 语言,它是一门纯函数式的编程语言。其中,具体...

bbbeoy的专栏 881

IGBT基础知识

IGBT

u010783226的专栏 1万+

Cesium生态盘点:超图、火星3D等15个二次开发框架对比

本文深入解析Cesium生态中的15个二次开发框架,包括超图、火星3D等主流选择,帮助开发者根据项目需求进行精准选型。从性能表现、功能完备性、开发友好度等维度进行对比,特别适合需要处理地理空间数据和构建三维可视化的JavaScript开发者。

weixin_28197941的博客 499

Scalaz(20)-Monad: Validation-Applicative版本的Either

scalaz还提供了个type class叫Validation。乍看起来跟\/没什么分别。实际上这个Validation是在\/的基础上增加了Applicative功能,就是实现了ap函数。通过Applicative实例就可以同时运算多个Validation并返回多条异常信息。所以,\/与Validation核心分别就在于Validation可以返回多条异常信息。Validation也是由两种状

TIGER_XC的专栏 977

说说PSTN、ISDN、 ADSL三种互联网接入方式的区别。

互联网的接入方式: 电话拨号接入(PSTN) ISDN接入 ADSL接入 Cable MODEM接入 局域网接入 光纤接入(FDDI) 卫星接入 DDN专线 目前来说,ADSL和Cable MODEM比较常用,今天我们就先来说说PSTN、ISDN和ADSL的区别。 电话拨号接入(PSTN/POTS,Public Switched Telephone Network / Public Oold Telephone Service) 数据终端设备(DTE)通过数据通信设备(DCE)再连

Winyaz的博客 2万+

函数式编程(2):Applicative编程

Applocative编程定义: 函数A作为参数提供给函数B var nums = [1,2,3,4,5];function doubleAll(array){ return _.map(array,function(n){ return n*2; }) } doubleAll(nums) // [2,4,6,8,10]function average(array){ var

juzipchy的博客 700

成本会计(第九版)王忠孝课后习题答案解析

在掌握了基础知识之后,我们还需要培养自己的实际操作能力。此外,在学习过程中,遇到困难时,要及时向老师、同学请教,不要害怕暴露自己的不足。三人行,必有我师,每个人都有值得学习的地方。首先,我们需要认真阅读教材,把基础知识掌握牢固。在这里,我建议大家使用《成本会计(第九版)》的配套练习册,这样可以帮助我们检查学习效果。同时,网上的一些优质课程和论坛也是不错的学习资源,例如网易云课堂、中国大学MOOC等。别担心,这里我给大家推荐一些实用的学习资料和方法,帮助你更好地掌握这门课程。出版社: 大连理工大学出版社。

weixin_58833001的博客 1889

NSIS教程(8): 基于第三方界面库的安装包界面

前面的几篇文章介绍了NSIS的传统界面的安装包和现代界面的安装包的制作方法,也提到了NSIS支持自定义页面(即使用page custom)的特性,自定义页面需要用户自己创建对话框、控件、添加控件响应等等,虽然NSIS提供了nsDialogs.nsh来支持这些功能,但使用起来还是不太方便(需要专门了解这个插件诸多用法),而且不够灵活,所以本文介绍一种终极的自定义界面的安装包解决方案,即完全使用第三方

while(1) { smile(); } 9万+

【Flink】FlinkSQL如何触发执行计算

Table (通过 StatementSet.addInsert() 输出给某个 Sink)和 INSERT 语句 (通过调用 StatementSet.addInsertSql())会先被缓存到 StatementSet 中,StatementSet.execute() 方法被调用时,所有的 sink 会被优化成一张有向无环图。该方法是用来将一个表的内容插入到目标表中,一旦该方法被调用, TABLE API 程序立即被翻译。该方法是用来执行一个 SQL 语句,一旦该方法被调用, SQL 语句立即被翻译。

一杯咖啡半杯糖的博客 1007

Scala 编程学习指南(三)

在前两章中,我们的视角发生了相当大的转变。在第六章探索内置效果中,我们查看了一些标准库中可用的具体效果的实现。在第七章理解代数结构中,我们从实际跳到了理论,并玩转了抽象代数结构。现在我们已经熟悉了使用由法律定义的抽象的过程,我们最终可以履行我们在第六章探索内置效果中给出的承诺,并识别出隐藏在我们在那里接触到的标准实现背后的抽象。我们将定义和实现一个函子,这是一个在处理任何效果时都很有用的抽象概念。此外,我们还将有三种不同的风味,所以请保持关注!到本章结束时,你将能够识别并实现或使用以下结构之一:函子适用函子

龙哥盟 471

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

Scalaz(7)- typeclass:Applicative-idomatic function application

Applicative,正如它的名称所示,就是FP模式的函数施用(function application)。我们在前面的讨论中不断提到FP模式的操作一般都在管道里进行的,因为FP的变量表达形式是这样的:F[A],即变量A是包嵌在F结构里的。Scalaz的Applicative typeclass提供了各种类型的函数施用(function application)和升格(lifting)方法。与其

TIGER_XC的专栏 683

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

函子应用和单子

我花了几天的时间弄清楚monad是什么之后,才对functor,Applicative和Monad有所了解。 这是我发现的。 我正在用Kotlin举例说明 什么是函子 函子可以按以下方式定义 函子只是可以映射的东西。 函子是一种数据结构,其作用类似于持有通用类型的容器 让我们定义数据类型或容器来保存值 class Functor < T > { object N...

编程故事的地方 424

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

同时使用java和scala语言的maven项目pom文件示例

主要就是在pom.xml中添加scala的三个依赖包和maven-scala插件,配置如下:&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-in...

lhever_的博客 3157

使用Scala实现链表(List)数据结构

这个例子来源于scala圣经级教程《Functional Programming in Scala》,由于本人跟着书中的代码敲了一遍,然后写了点测试代码验证了一下正确性,所以就放在这做个备忘吧。贴出来只是为了方便自己,如果看不懂,但是又感兴趣的就去看原书吧。package fpinscala.datastructures sealed trait List[+A] case object Nil...

lhever_的博客 1877

Monoid在Scala中的应用笔记

这个例子来源于scala圣经级教程《Functional Programming in Scala》,虽然原书的随书代码可以找到这些类的影子,但却没有关于如何使用这些类的示例代码,本人在阅读此书期间,除了跟着书中的代码敲了一遍之外,还写了一些测试代码进行验证,贴出来作为blog主要是为了方便自己,也为那些同样在阅读此书的人参考。注释不多,本人也不可能写太多,因为这本书不是简单的入门书,而是...

lhever_的博客 1404

Monad在Scala中的应用笔记

这个例子来源于scala圣经级教程《Functional Programming in Scala》,虽然原书的随书代码可以找到这些类的影子,但却没有关于如何使用这些类的示例代码,本人在阅读此书期间,除了跟着书中的代码敲了一遍之外,还写了一些测试代码进行验证,贴出来作为blog主要是为了方便自己,也为那些同样在阅读此书的人参考。注释不多,本人也不可能写太多,因为这本书不是简单的入门书,而是...

lhever_的博客 1310

使用Scala从头实现一个简单的语法分析器组合字库

这个例子来源于scala圣经级教程《Functional Programming in Scala》,虽然原书的随书代码可以找到这些类的影子,但却没有关于如何使用这些类的示例代码,本人在阅读此书期间, ,除了跟着书中的代码敲了一遍之外,还写了一些测试代码进行验证,贴出来作为blog主要是为了方便自己,也为那些同样在阅读此书的人参考。注释不多,本人也不可能写太多,因为这本书不是简单的入门书,...

lhever_的博客 1002

用Scala实现Stream(一个惰性的链表)数据结构

这个例子来源于scala圣经级教程《Functional Programming in Scala》,由于本人跟着书中的代码敲了一遍,然后写了点测试代码验证了一下正确性,所以就放在这做个备忘吧。贴出来只是为了方便自己得意,如果看不懂,但是又感兴趣的就去看原书吧…… package laziness trait Stream[+A] { import laziness.Stream...

lhever_的博客 995

使用Scala对带状态函数或API进行抽象的示例(State)

这个例子来源于scala圣经级教程《Functional Programming in Scala》,由于本人跟着书中的代码敲了一遍,然后写了点测试代码验证了一下正确性,所以就放在这做个备忘吧。贴出来只是为了方便自己,如果看不懂,但是又感兴趣的就去看原书吧…… package state import RNG.Simple import state.State._ case cla...

lhever_的博客 659

使用Scala实现Option数据结构

这个例子来源于scala圣经级教程《Functional Programming in Scala》,由于本人跟着书中的代码敲了一遍,然后写了点测试代码验证了一下正确性,所以就放在这做个备忘吧。贴出来只是为了方便自己,如果看不懂,但是又感兴趣的就去看原书吧。package errorhandling //hide std library `Option`, since we are writing...

lhever_的博客 606

用Scala实现一个纯函数风格的引用透明的伪随机数生成器

这个例子来源于scala圣经级教程《Functional Programming in Scala》,由于本人跟着书中的代码敲了一遍,然后写了点测试代码验证了一下正确性,所以就放在这做个备忘吧。贴出来只是为了方便自己,如果看不懂,但是又感兴趣的就去看原书吧…… package state trait RNG { def nextInt: (Int, RNG) } obje...

lhever_的博客 567

使用Scala实现Either数据结构

这个例子来源于scala圣经级教程《Functional Programming in Scala》,由于本人跟着书中的代码敲了一遍,然后写了点测试代码验证了一下正确性,所以就放在这做个备忘吧。贴出来只是为了方便自己,如果看不懂,但是又感兴趣的就去看原书吧。package errorhandling //hide std library `Either`, since we are writing...

lhever_的博客 516
上一篇: Monad在Scala中的应用笔记
下一篇: 在纯函数中使用局部可变状态的Scala代码示例
lhever_
博客等级 码龄14年 213粉丝 130原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值