小编kir*_*rov的帖子

我发现pure对于这个 Applicative 实例，至少有 2 个实现，它们遵循所有的定律（恒等性、同态、交换、组合）。其中之一仍然是错误的吗？

data List a = 
    Nil 
  | Cons a (List a) 
  deriving (Eq, Show) 

newtype ZipList' a = 
  ZipList' (List a) 
  deriving (Eq, Show)

instance Applicative ZipList' where 
  ZipList' fss <*> ZipList' xss = ZipList' $ applicate fss xss
    where applicate (Cons f fs) (Cons x xs) = Cons (f x) (applicate fs xs)
          applicate Nil         _           = Nil
          applicate _           Nil         = Nil

pure x = ZipList' (Cons x Nil)

或者

pure a …

我试图理解什么是 Haskell Reader monad，但我在书中的这一部分很挣扎：

类型参数的“只读”性质r意味着您可以r为您调用的函数交换不同的类型或值，但不能为调用您的函数交换。证明这一点的最好方法是使用该withReaderT函数，该函数让我们开始一个新的Reader上下文，并提供不同的参数：

withReaderT 
  :: (r' -> r) 
  -- ^ The function to modify the environment. 
  -> ReaderT r m a 
  -- ^ Computation to run in the modified environment. 
  -> ReaderT r' m a 

Run Code Online (Sandbox Code Playgroud)

那么，首先，您能否具体说明什么是“您调用的函数”，什么是“调用您的函数”？

假设我们有一个一元序列：

doSomething = do 
    a <- f 
    b <- g 
    c <- h 
    pure (a, b, c) 

我们可以使用 applicative functor 轻松地重写它：

doSomething2 = (,,) <$> f <*> g <*> h

但是如果 monadic 序列看起来像这样：

doSomething' n = do 
    a <- f n 
    b <- g a 
    c <- h b 
    pure (a, b, c)

还有可能在那里使用 applicative 吗？如果不是，障碍是什么？（还有一本书写的，尽管如此，我们可以使用 applicative 和join一起使用，但我不知道如何使用）。

（这段代码没有多大意义，但我需要此逻辑才能在其他复杂函数中使用）：

import Data.List

elemIndex1 xss@(x:xs) = 
    if (x == ' ') 
    then (elemIndex x xss) 
    else (elemIndex1 xs)

所以我想这个功能给这个：

elemIndex1 "qwe asd zxc"
Just 3

相反，它给出了以下内容：

elemIndex1 "qwe asd zxc"
Just 0

据我了解，在else子句中，xss实际上变成了xs。所以我的问题是：是否有可能将变量（x：xs）绑定到常量并在任何迭代中使用该常量？

我正在尝试测试encode和decode函数（在 中定义Data.ByteString.Base64.Lazy）是相反的：

import qualified Data.ByteString.Lazy as BL

encoded :: Gen BL.ByteString
encoded = do
  body <- concat <$> listOf (group 0)
  end <- group =<< choose (0, 2)
  return . BL.pack $ body <> end
 where
  group :: Int -> Gen [Word8]
  group pad = do
    letters <- vectorOf (4 - pad)
      . elements . map (fromIntegral . ord)
      $ ['A'..'Z'] <> ['a'..'z'] <> ['0'..'9'] <> ['+','/','=']
    return $ letters <> replicate pad 61 …

我正在尝试理解 State newtype 并且我正在努力解决书中对同构的这种解释：

新类型必须与它们包装的类型具有相同的底层表示，因为新类型包装在编译时消失。因此 newtype 中包含的函数必须与它包装的类型同构。也就是说，必须有一种方法可以在不丢失信息的情况下从 newtype 到它包装的事物并再次返回。

应用于 State newtype 是什么意思？

newtype State s a = State { runState :: s -> (a, s) } 

这种解释“必须有一种方法可以从 newtype 到它包装的东西然后再回来”尚不清楚。

另外，你能不能说一下，在这个例子中哪里有同构，哪里没有，为什么。

type Iso a b = (a -> b, b -> a) 

newtype Sum a = Sum { getSum :: a }

sumIsIsomorphicWithItsContents :: Iso a (Sum a) 
sumIsIsomorphicWithItsContents = (Sum, getSum)

(a -> Maybe b, b -> Maybe a) 

[a] -> a, a -> [a]