- 综合排序
- 最热优先
- 最新优先
- 来自专栏我杨某人的青春满是悔恨
Applicative 函子
Applicative 定律 Application 函子是一种加强的函子，在 Haskell 的 Control.Applicative 模块中定义了一个 Applicative 类型类： class 要成为 Applicative 类型类的实例，还必须定义两个函数，pure 和 <*>。 从这个定义来看，似乎只要是满足了以上几个条件的类型就可以称为 applicative 函子，事实上并非如此，要成为 applicative 函子还需要满足一条最重要的定律： pure f <*> x = 的函数 我们知道函数可以作为函子，其实函数也可以作为 applicative： instance Applicative ((->) r) where pure x = (\_ -> x) f 当然，将((->) r)作为 applicative 使用不是特别重要，但大家要理解并非只有容器或者某种数据结构才能作为函子。
1K10发布于 2018-09-10 - 来自专栏Bennyhuo
Kotlin版图解Functor、Applicative与Monad
这就是 Functor、 Applicative、 Monad、 Arrow 等概念的基础。 Maybe 数据类型定义了两种相关上下文： ? Applicative Applicative 又提升了一个层次。 对于 Applicative，我们的值像 Functor 一样包装在一个上下文中： ? 但是我们的函数也包装在一个上下文中！ ? Applicative 并没有开玩笑。 Applicative 定义了 (*)（在 Haskell 中是 <*>），它知道如何将一个 包装在上下文中的 函数应用到一个 包装在上下文中的 值上： ? （Haskell 中的）applicative 是实现了 Applicative 类型类的数据类型。 （Haskell 中的）monad 是实现了 Monad 类型类的数据类型。 Maybe 实现了这三者，所以它是 functor、 applicative、 以及 monad。 这三者有什么区别呢？ ?
1.9K20发布于 2020-02-20 - 来自专栏黯羽轻扬
Functor与Applicative_Haskell笔记7
Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d 更多参数的可以通过<$>和<*>秒秒钟定义出来，见下面Applicative 这个东西就是Applicative： class Functor f => Applicative f where pure :: a -> f a (<*>) :: f (a -> b) -> f a -> f b （摘自Applicative） 要求必须先是Functor实例，所以Applicative是一种特殊的Functor，所以也被称为Applicative functors 定义了两个接口 in ‘Control.Applicative’ instance Monad m => Applicative (WrappedMonad m) -- Defined in ‘Control.Applicative 实例都遵从这些规则，但同样只是道德约束，手动实现Applicative实例时要自觉遵守 Applicative style 通过<$>和<*>可以达到非常优雅的调用式风格。
81130发布于 2019-06-12 - 来自专栏函数式编程语言及工具
Scalaz（7）－ typeclass：Applicative－idomatic function application
以下是Applicative trait的部分定义：scalaz/Applicative.scala 1 trait Applicative[F[_]] extends Apply[F] { self ]: F[A] = Applicative[F].point(self) 12 def pure[F[_] : Applicative]: F[A] = Applicative[F].point (self) 13 def η[F[_] : Applicative]: F[A] = Applicative[F].point(self) 14 } //// 15 } 是通过implicit 这种Applicative的函数施用体现了它在并行运算中的优势。 4、Applicative style 函数施用。上面提到的|@|操作并不是一种操作函数而是一种层级式持续函数施用模式。 这是另一种通过函数施用实现连接Applicative类型值的方式。
1.1K90发布于 2018-01-05 - 来自专栏函数式编程语言及工具
Scalaz（42）－ Free ：FreeAp－Applicative Style Programming Language
我们可以用Applicative来产生静态结构的程序，这个从Applicative的运算函数ap可以看得出来：def ap(f: F[A=>B])(F[A]):F[B]。 与Free Monad相似，Free Applicative Functor也是Applicative的结构化。 与Free Monad一致，我们同样用ADT来模拟applicative编程语法，然后用ap函数把ADT链接起来成为程序。 * Not tail-recursive unless `G` is a free monad. */ def foldMap[G[_]:Applicative](f: F ~> G) : G[A] = this match { case Pure(x) => Applicative[G].pure(x) case x@Ap() => Applicative
84650发布于 2018-01-05 - 来自专栏函数式编程语言及工具
Scalaz（20）－Monad： Validation－Applicative版本的Either
实际上这个Validation是在\/的基础上增加了Applicative功能，就是实现了ap函数。通过Applicative实例就可以同时运算多个Validation并返回多条异常信息。 ](d: Validation[E, A]): ValidationFlatMap[E, A] = new ValidationFlatMap(d) } 因为Validation又是个Applicative
59180发布于 2018-01-05 - 来自专栏函数式编程语言及工具
泛函编程（28）－粗俗浅解：Functor, Applicative, Monad
//> res2: ch12.ex3.Box[Int] = Box(12) apply函数就是Applicative函数 虽然我们在上面分别实现了Functor,Applicative,Monad的功能函数 但Functor,Applicative,Monad都是泛函数据类型，我们还没有明确定义这些数据类型。这些数据类型自提供了操作函数对嵌在内部的变量进行更新。也就是说它们应该自带操作函数。 21 (bxHello apply {Box(lengthOf _)}).get //> res5: Int = 5 实现了flatMap, apply后Box是Functor,Applicative 看来，Functor, Applicative, Monad除了名称怪异外实际上并不可怕，我们可以从它们的用途中了解它们的意义。
1.3K60发布于 2018-01-05 - 来自专栏函数式编程语言及工具
泛函编程（25）－泛函数据类型－Monad－Applicative
因为我们能够用flatMap来实现map2，所以Monad就是Applicative。但反之Applicative不一定是Monad。既然我们希望提高泛函施用模式的效率，那我们就先从函数施用开始。 以下就是Applicative trait： 1 trait Applicative[F[_]] extends Functor[F] { 2 def unit[A](a: A): 所以Applicative extends Functor。下面我们来分析一下flatMap和map2的差别，这也代表着Monad和Applicative在行为上的区别。 我们可以对Monad extends Applicative: 1 trait Monad[M[_]] extends Applicative[M]{ 2 def unit[A](a: 但是，有些Applicative未必是Monad，因为我们可能无法用某些类型Applicative实例的map2或apply来实现flatMap、join、compose。
1.6K90发布于 2018-01-05 - 来自专栏函数式编程语言及工具
Scalaz（9）－ typeclass：checking instance abiding the laws
隐式实例（implicit instance），我们希望Configure类型既是一个Functor也是一个Applicative。 再看看Applicative的scalacheck property：scalaz/scalacheck/scalazProperties.scala 1 object applicative { "interchange") = applicative.interchange[F, Int, Int] 20 property("map consistent with ap") = applicative.mapApConsistency [F, Int, Int] 21 } 22 } applicative.laws定义了4个测试Property再加上apply的测试property。 功通过了Applicative定律测试。现在我们可以说Configure类型既是Functor也是Applicative。
62560发布于 2018-01-05 - 来自专栏函数式编程语言及工具
泛函编程（26）－泛函数据类型－Monad－Applicative Functor Traversal
前面我们讨论了Applicative。 Applicative 就是某种Functor，因为我们可以用map2来实现map，所以Applicative可以map，就是Functor，叫做Applicative Functor。 先看看两个Applicative组件的实现： 1 def product[F[_],G[_]](a1: Applicative[F],a2: Applicative[G]) = new Applicative [[V](F[V], G[V])] 11 def compose[F[_],G[_]](a1: Applicative[F], a2: Applicative[G]) = new Applicative 通过对两个Applicative进行函数组合后形成一个更高阶的Applicative。这个Applicative和其它普通的Applicative一样可以实现多参数函数的升阶连续施用。
1K100发布于 2018-01-05 - 来自专栏KAAAsS's Blog
当我们谈论Monad的时候（二）
b 实现Applicative 实现Applicative的方法和fmap大同小异，唯一的区别就是还需要对函数进行模式匹配。 引入Applicative的意义 上下文无关 引入Applicative的意义有很多，其中一点就是，Applicative和Monad的侧重点不同。 Applicative和Monad都能实现运算的组合与排序，因此它们都能对运算进行建模，但是Applicative在运算的过程中并没有上下文。 特例 此外，Applicative是一个比Monad更初级的结构。因此毫无疑问，存在是Applicative但不是Monad的情况。 而对Applicative的刻画增强了Haskell的表达能力，比如Traversable其实只需要Applicative就可以实现了。
1.4K10编辑于 2022-01-14 - 来自专栏黯羽轻扬
Monad_Haskell笔记10
一.从Functor到Monad 从类型来看，Functor到Applicative再到Monad是从一般到特殊的递进过程（Monad是特殊的Applicative，Applicative是特殊的Functor 的值 (<*>) :: (Applicative f) => f (a -> b) -> f a -> f b pure :: (Applicative f) => a -> f a Applicative 回到最初的场景，我们已经知道了Monad在语法上能够简化context相关计算，能够把a -> m b应用到m a上 既然Monad建立在Applicative的基础之上，那么，与Applicative 因为applicative functor并不允许applicative value之间有弹性的交互 这，怎么理解？ 再看一个Maybe Applicative的示例： > Just (+1) <*> (Just (+2) <*> (Just (+3) <*> Just 0)) Just 6 中间环节都不出错的Applicative
1.2K50发布于 2019-06-12 - 来自专栏黯羽轻扬
newtype_Haskell笔记8
在List场景，xs <*> ys表示从左侧xs中取出函数作用于右侧ys中的每一项，有两种实现方式： 笛卡尔积 拉链式的一一结对 分别对应[]和ZipList，例如： import Control.Applicative 对<*>而言，这两种实现都是可取的，但[]无法同时拥有两种不同的Applicative实现，所以造出了ZipList，让它以拉链结对的方式实现Applicative P.S.这里提到的<*>是Applicative 类定义的行为，具体见Functor与Applicative_Haskell笔记7 二.newtype ZipList就是因这个场景而产生的，本质上是对List的包装，定义如下： newtype ZipList deriving ( Show, Eq, Ord, Read, Functor , Foldable, Generic, Generic1) （摘自Control.Applicative ） 通过newtype关键字，基于现有类型（[]）创建一个新的（ZipList），再重写其接口实现： instance Applicative ZipList where pure x = ZipList
1K30发布于 2019-06-12 - 来自专栏一个会写诗的程序员的博客
Functors, Applicatives, And Monads In PicturesFunctors, Applicatives, And Monads In Pictures
> import Control.Applicative > let foo = fmap (+3) (+2) > foo 10 15 So functions are Functors too! With an applicative, our values are wrapped in a context, just like Functors: ? So now we know that Maybe is a Functor, an Applicative, and a Monad. An applicative is a data type that implements the Applicative typeclass. A Maybe implements all three, so it is a functor, an applicative, and a monad.
80440发布于 2018-12-12 - 来自专栏我杨某人的青春满是悔恨
Monad 定律
monad 是支持>>=操作的 applicative 函子，>>=读作绑定，它的类型是： (>>=) :: (Monad m) => m a -> (a -> m b) -> m b 即取一个 monad monad 有专属的类型类——Monad，其定义如下： class Applicative m => Monad (m :: * -> *) where (>>=) :: m a -> (a -> m b) -> m b (>>) :: m a -> m b -> m b return :: a -> m a fail :: String -> m a return和 applicative
72630发布于 2018-09-10 - 来自专栏函数式编程语言及工具
Scalaz（10）－ Monad：就是一种函数式编程模式－a design pattern
上面这些类型trait的继承关系是这样的：Monad继承了Applicative和Bind，Applicative继承了Apply, Apply继承了Functor, Bind也继承了Apply。 所以Monad同时又是Applicative和Functor，因为Monad实现了map和ap函数。一个Monad实例可以调用所有Applicative和Functor提供的组件函数。 确切来说，flatMap并不适合并行运算，所以我们需要Applicative。 这是因为Applicative是在既有的容器中运算，而flatMap则会重新创建新的容器（在Monad的世界里容器即为算法（computation）。 但是因为我们讲过Monad就是Applicative，所以Monad也可以实现并行运算。
1K100发布于 2018-01-05 - 来自专栏黯羽轻扬
Monadic Function_Haskell笔记12
Applicative最关键的是这个东西： (<*>) :: Applicative f => f (a -> b) -> f a -> f b 实际上用Monad也能实现，叫做ap： ap :: Monad m => m (a -> b) -> m a -> m b 很容易搞定： mf `ap'` m = do f <- mf x <- m return (f x) 所以，Monad还比Applicative 更进一步的，如果要实现自定义Monad，可以先实现return和>>=，然后就很容易实现Applicative（令<*> = ap，pure = return）和Functor（令fmap = liftM ） 我们知道有liftA2（直到liftA3），用来应对“多参”函数： liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d 实际上也有对应的liftM2（直到liftM5）： liftM2
1.2K30发布于 2019-06-12 - 来自专栏林集团的博客
实现TypeScript运行时类型检查
T<F> => F<T>转换成Haskell 的类型签名, 即可得到:t (f a) -> f (t a)将此类型输入到Hoogle, 我们看到这样一条类型签名:sequenceA :: Applicative t (f a) -> f (t a)fromStruct和fromArray一样, 其实现最终导向了这个"奇怪"的类型转换, 接下来我们就深入这个类型签名, 讲讲其背后蕴含的理论.sequenceA和Applicative :interface Applicative<F> extends Functor<F> { of: (a: A) => F; ap: <A, B>(fab: F<(a: A) 答案是Monad是比Applicative更加"强大", 但也更加严格的约束.一个函数, 对其依赖的类型拥有更加宽松的类型约束, 其使用场景也会更加广泛, 例如:type Move = (o: Animal ) => void;就比type Move = (o: Dog) => void;使用场景更加广泛, 也更加合适, 即最小依赖原则.Monad比Applicative更加"强大"的点在于:Applicative
3.1K30编辑于 2022-06-24 - 来自专栏一个会写诗的程序员的博客
来看看几种 Monad来看看几种 Monad
在这一章，我们会学到 Monad，基本上他是一种加强版的 Applicative Functor，正如 Applicative Functor 是 Functor 的加强版一样。 ? 如果你知道好几种 ``Applicative`` 的 instance 还有他们代表的意含就更好了，因为 monad 不过就是对 applicative 的概念进行一次升级。 Nothing Nothing 或者视为一个 applicative functor，他也有类似的作用。只是 applicative 也把函数包了起来。 因为 applicative functor 并不允许 applicative value 之间有弹性的交互。他们最多就是让我们可以用 applicative style 来传递参数给函数。 applicative operators 能拿到他们的结果并把他用 applicative 的方式喂给另一个函数，并把最终的 applicative 值放在一起。
1.4K20发布于 2018-12-12 - 来自专栏函数式编程语言及工具
Scalaz（27）－ Inference & Unapply ：类型的推导和匹配
Int]] = Some(List(2, 3, 4)) traverse函数的款式是这样的: final def traverse[G[_], B](f: A => G[B])(implicit G: Applicative [G]): G[F[B]] G是个Applicative，它的类型款式当然是G[B]这样的了，也就是我们必须提供f: A => G[B]这样的函数款式。 试试： 1 //val u1 = Unapply.unapplyMAB1[Applicative, \/, String, Int] //这个不行 2 //could not find implicit value for parameter TC0: scalaz#31.Applicative#28655[[α#75838]scalaz#31.\/#32660[α#75838,Int#1125]] 我们可以充分利用Unapply来编写一个更概括的sequenceList函数： 1 def sequenceListU[GA](lga: List[GA])(implicit U: Unapply[Applicative
1.4K80发布于 2018-01-05
腾讯云开发者
Copyright © 2013 - 2026 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有
深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 
粤公网安备44030502008569号
腾讯云计算（北京）有限责任公司 京ICP证150476号 | 京ICP备11018762号