相关疑难解决方法(0)

应用函子是众所周知的,并且在Haskellers中广受欢迎,因为它们能够在有效的环境中应用函数.

在类别理论术语中,可以证明以下方法Applicative:

pure :: a -> f a
(<*>) :: f (a -> b) -> f a -> f b

相当于有一个Functor f操作:

unit :: f ()
(**) :: (f a, f b) -> f (a,b)

这个想法是写pure你只是用给定的值替换()in unit,并写(<*>)你将函数和参数压缩到一个元组,然后在它上面映射一个合适的应用程序函数.

此外,这种对应关系变成了Applicative法律成左右自然monoidal十岁上下的法律unit和(**),所以实际上是一个适用函子也恰恰是一类理论家称之为一个宽松monoidal仿函数(松懈,因为(**)仅仅是一个自然的转变,而不是同构).

好的,很好,很棒.这是众所周知的.但是,这只是一个家庭不严monoidal函子-那些尊重的monoidal结构产品.松散的幺正算子涉及两种幺半群结构的选择,在源头和目的地:如果你把产品变成总和,你就会得到:

class PtS f where
  unit :: f Void
  (**) :: f a -> f b -> f (Either a b) …

我目前正在研究monad和applicative functors之间的联系.

我看到ap的两个实现:

ap m1 m2 = do { f <- m1 ; x <- m2 ; return (f x) }

和

ap m1 m2 = do { x <- m2 ; f <- m1 ; return (f x) }

第二个是不同的,但它会是一个很好的实现<*>吗？

我迷失了证据 pure (.) <*> u <*> v <*> w = u <*> (v <*> w)

我试图直观地说"monad的哪一部分是应用函子"......

我正在阅读有关应用程序并尝试理解它的haskellbook.

在书中,作者提到:

因此,使用Applicative,我们的结构和功能应用为我们的价值观提供了Monoid!

monoid如何连接到applicative？

在范畴论中,filter操作是否被视为态射？如果是,那是什么样的态射？示例(在Scala中)

val myNums: Seq[Int] = Seq(-1, 3, -4, 2)

myNums.filter(_ > 0)
// Seq[Int] = List(3, 2) // result = subset, same type

myNums.filter(_ > -99)
// Seq[Int] = List(-1, 3, -4, 2) // result = identical than original

myNums.filter(_ > 99)
// Seq[Int] = List() // result = empty, same type

Hask通常被认为是对象是类型的类别,而态射是函数.然而,我看到康纳尔麦克布莱德(@pigworker)警告反对使用Hask多次(1,2,3):

• 我会劝阻谈论"Hask类别",因为它潜意识地阻止你在Haskell编程中寻找其他分类结构.

• 注意,我不喜欢使用"Hask"作为"Haskell类型和函数类别"的名称:我担心将一个类别标记为Haskell类别会产生令人遗憾的副作用,使我们对其他分类结构的财富感到盲目在Haskell编程中.这是一个陷阱.

• 我希望人们不要称它为"哈斯克",它可能会限制想象力.

我们在Haskell中可以看到哪些其他类别？

在他的一个答案中,他触及了其中的一些想法,但我想知道是否有人可以扩展它; 我想知道是否还有更多的例子.

[...]各地潜伏着大量的分类结构,当然有更多类别的分类结构(可能但不一定).我特别喜欢索引族集之间的仿函数.

我经常找我称之为"纯粹的应用性使用Either",即Either用Applicative,只要我们没有实现一个可用实例Monad的实例,以及.

newtype AEither e a = AEither { unAEither :: Either e a }
  deriving Functor

-- technically we only need Semigroup
instance Monoid e => Applicative (AEither e) where
  pure a = AEither (pure a)
  AEither e1 <*> AEither e2 = AEither (combine e1 e2) where
    combine (Right f) (Right a) = Right (f a)
    combine (Left m1) (Left m2) = Left (m1 <> m2)
    combine (Left m ) _         = …

我试图在https://namc.in/2018-02-05-foldables-traversals的帮助下了解Traversable 。

作者在某处提到了以下句子：

对应用上下文而言，可遍历是针对Monoid值的可折叠。

他试图澄清什么？

我之间没有联系Foldable to Monoid。

请提供一个例子。

Conor McBride(pigworker)的答案讨论了Applicative也是容器的算子(由一组形状和一系列位置给出的数据类型).除其他外,他提到:

• 两个容器之间的多态函数有两个组件:一个作用于形状,一个作用于位置.
• 在与应用操作相关的操作下,施用容器的形状形成幺半群<*>.

我想知道是否可以在分类设置中进行类似的分析,并且我是否可以使用类别理论得出相同的结论(主要是因为我觉得类别理论比依赖类型理论更容易).

我知道仿Applicative函数是monoidal仿函数(从(Set, ×, 1)到(Set, ×, 1)),我相信容器可以被视为在列表上形状的仿函数(如这里或这里所建议的) - 但我对这个概念或这个断言不太满意.这是考虑应用容器的正确方法吗？作为整体列表上的幺半体仿函数？

PS:如果您认为stackoverflow不适合提出这类问题,请告诉我.

如适用函数的黑客中提到的那样，它们是强大的松散单曲面函数。那么，为什么它们在Haskell中的定义却不这样显示：

class Functor f => MonoidalApplicative f where
  mult :: f a -> f b -> f (a,b)
  unit :: a -> f a 

  starAp :: f (a -> b) -> f a -> f b
  starAp h x = fmap (uncurry ($)) (mult h x)

<*>（starAp）可以很容易地按照乘法来重构，这个定义对我来说更简单。例如，这是Maybe实例：

instance MonoidalApplicative Maybe where
  mult (Just x) (Just y) = Just (x,y)
  mult _ _ = Nothing

  unit x = Just x

我正在ApplicativeHaskell的Haskell编程中阅读Haskell.为了更好地理解它,我想出了以下Applicative列表定义:

-- Named as pure' and "app" to avoid confusion with builtin versions 
class Applicative' f where
 pure' :: a -> f a
 app :: f (a->b) -> f a -> f b

instance Applicative' [] where
 pure' x = [x]
 app _ [] = []
 app [g] (x:xs) = [(g x)] ++ app [g] xs
 app (g:gs) (x:xs) = [(g x)] ++ app gs xs

-- fmap functions could be defined as:
fmap1' :: (Applicative' …

我正在学习 Haskell 并尝试从《Haskell 编程从第一原理》一书中进行练习，并且我正在尝试编写 Pair 类型的应用程序

 data Pair a = Pair a a deriving Show

我在网上看到了一些其他示例，但我正在尝试一些不同的应用函子，我正在尝试利用这种类型的幺半群结构。这是我所拥有的

data Pair a = Pair a a deriving (Show, Eq)

instance Functor Pair where
     fmap f (Pair x y) = Pair (f x) (f y)

instance Semigroup a => Semigroup (Pair a) where
    (Pair x y) <> (Pair x' y') = Pair (x <> x') (y <> y')

instance Applicative Pair where
    pure x = Pair x x 
    (Pair f g) <*> p = …

我正在尝试扩大对Haskell中的符号的理解：

 $  : Function Application operator (Allow you to apply arguments over a function)
 &  : flipped version of Function Application Operator? (&) = flip ($)
<>  : associative operator (You'll find it in Semigroups and Monoids)
<$> : function application ($) lifted over a Functor structure
<&> : flipped functor map
<*> : applicative operator

我们可以<>和这个家庭建立联系<*>,<$>,<&>吗？我做的时候只想找一个快速的结论<*>,<$>,<&>是<..>用一个结构相关的东西，但是又是什么结构和关联运营商之间的联系？