小编pla*_*ian的帖子

学习Haskell的第11章介绍了以下定义:

instance Applicative ((->) r) where
    pure x = (\_ -> x)
    f <*> g = \x -> f x (g x)

在这里,作者参与了一些不寻常的挥手("<*>的实例实现有点神秘,所以如果我们只是[在没有解释它的情况下显示它的话]它是最好的").我希望这里的某个人可以帮助我搞清楚.

根据应用类定义, (<*>) :: f (a -> b) -> f a -> f b

在实例中,替换((->)r)为f:r->(a->b)->(r->a)->(r->b)

所以第一个问题是,我该如何从这种类型中获得f <*> g = \x -> f x (g x)？

但即使我认为最后一个公式是理所当然的,我也很难同意我给GHCi的例子.例如:

Prelude Control.Applicative> (pure (+5)) <*> (*3) $ 4
17

这个表达式看起来与之相符f <*> g = \x -> f (g x)(请注意,此版本x之后不会出现f. …

因此,我花了很多时间阅读并重新阅读The Little Schemer中第9章的结尾,其中应用Y组合器是为该length功能开发的.我认为我的困惑归结为一个单独的声明,对比两个版本的长度(在组合器被分解之前):

A:
  ((lambda (mk-length)
     (mk-length mk-length))
   (lambda (mk-length)
     (lambda (l)
       (cond
         ((null? l) 0 )
         (else (add1
                ((mk-length mk-length)
                 (cdr l))))))))

B:
((lambda (mk-length)
      (mk-length mk-length))
    (lambda (mk-length)
      ((lambda (length)
         (lambda (l)
           (cond
             ((null? l) 0)
             (else (add1 (length (cdr l)))))))
       (mk-length mk-length))))

第170页(第4版)指出A.

当我们将它应用于参数时返回一个函数

而B

不返回功能

从而产生自我应用的无限回归.我很难过.如果B受到这个问题的困扰,我不知道A如何避免它.

对不起,这是一个非常基本的问题:在GHCi中,import Library.Name和之间有区别:m +Library.Name吗？它们似乎是等价的,但我认为有替代语法的原因.

以下两个公式有什么区别？

cp [] = [[]]
cp (xs:xss) = [x:ys | x <- xs, ys <- cp xss]
----------------------------------------------
cp [] = [[]]
cp (xs:xss) = [x:ys | x <- xs, ys <- yss]
              where yss = cp xss

样本输出: cp [[1,2,3],[4,5]] => [[1,4],[1,5],[2,4],[2,5],[3,4],[3,5]]

根据与Haskell的功能性思考(p.92),第二个版本是"更有效的定义...... [保证cp xss只计算一次",尽管作者从未解释过为什么.我原以为他们是等同的.

我最近开始在Hackage上查看核心库,并且有一个我不理解的反复出现的习惯用法.以下是ST模块的示例:

instance Monad (ST s) where
    {-# INLINE (>>=)  #-}
    (>>) = (*>)
    (ST m) >>= k
      = ST (\ s ->
        case (m s) of { (# new_s, r #) ->
        case (k r) of { ST k2 ->
        (k2 new_s) }})

特别是,我不明白(# new_s, r #).我假设第二个哈希是指一个未装箱的值,但其余的对我来说是一个谜(大概与"新状态"有关).

我是Scheme的新手,试图理解函数中出现的某些值如何在多次使用中持续存在.采取以下计数器:

(define count
   (let ((next 0))
     (lambda ()
       (let ((v next))
         (set! next (+ next 1))
         v))))

我无法弄清楚(并且没有在任何地方找到解释),为什么next每次使用时都不会重置为0 count.

虽然Qt的文档表明这两个函数是不同的(第一个不包括框架),无论我选择哪个小部件 - 包括我的应用程序的主窗口 - someWidget->frameGeometry().height()总是返回相同的值someWidget->geometry.height().

我在这里错过了什么？

我对defn的作用有点困惑.如果fn只生成匿名函数,我可以理解需要一个结合def和fn功能的构造,但是fn也可以创建命名函数.至少在repl中,我看不出这种用法与defn的区别.

当我试图增加我对函数式编程的知识时,我发现很难重新想象我在函数方面用OOP语言解决的问题的解决方案,特别是在涉及小部件的情况下.像Project Euler和4Clojure这样的网站非常适合学习操作原始数据的核心功能和技术,但我真正喜欢的是讨论如何将OOP结构惯用地转换为FP的资源,特别注意识别何时以及如何使用州.(举一个具体的例子,在Clojure中实现钢琴键盘的最佳方法是什么？)

在Learn You a Haskell的第6章中,介绍了以下函数:

zipWith' :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith' _ [] _ = []
zipWith' _ _ [] = []
zipWith' f (x:xs) (y:ys) = f x y : zipWith' f xs ys

作者给出了几个使用它的例子,我发现它很容易遵循.然后这个:

ghci> zipWith' (zipWith' (*)) [[1,2,3],[3,5,6],[2,3,4]] [[3,2,2],[3,4,5],[5,4,3]]

哪个输出 [[3,4,6],[9,20,30],[10,12,12]]

这是懒惰评估的一个例子吗？我试图将zipWith'翻译成Scheme(见下文).我使用了"简单"的例子,但不是最后一个,这让我觉得Haskell的懒惰可能会带来不同.

(define zipWith
  (lambda (f listA listB)
    (cond
      ((null? listA) (quote ()))
      ((null? listB) (quote ()))
      (else (cons (f (car listA) (car listB)) (zipWith f (cdr listA) …