Question

我难以理解定义：

ifoldr :: Foldable f => (Int -> a -> b -> b) -> b -> f a -> b
ifoldr f z xs = foldr (\ x g i -> i `seq` f i x (g (i+1))) (const z) xs 0

尤其是，它似乎通过避免使用zip [1..]来避免空间泄漏，同时，它似乎派生了一个新的fold“ step function”（折叠函数），并在其前面附加了其他参数，但该参数最后传入\ x g i！

对于某些定义f' x (foldr f' z xs)来说，它等于f' = _unknown_ f并保留了非限制性属性吗？

Answer 1

简而言之：foldr生成一个函数（不是值列表），然后该函数将生成该列表。

让我们首先忽略foldr一段时间，然后专注于文件夹中使用的函数，让我们将此函数称为eval：

eval x g i = seq i (f i x (g (i+1))))

在这里我们将忽略seq：是的，它具有一些语义：评估i（以弱头范式）并检查i是否为底部，但让我们假设这不会引入底部。因此eval或多或少等于：

eval x g i = f i x (g (i+1))

现在，我们可以重新考虑foldr上下文了：

ifoldr f = foldr eval (const z) xs 0
    where eval x g i = f i x (g (i+1))

现在foldr的定义（用于列表，但让我们在这里保持简单）为：

foldr _ z [] = z
foldr f z (x:xs) = f x (foldr f z xs)

对于具有三个元素[x1, x2, x3]的列表，这意味着：

foldr eval (const z) [x1, x2, x3]

看起来像：

-- foldr eval (const z) [x1, x2, x3] is equivalent to
eval x1 (eval x2 (eval x3 (const z)))

由于eval的定义如上，这意味着我们可以将其专门用于：

\i1 -> f i1 x1 ((\i2 -> f i2 x2 (\i3 -> f i3 x3 (const z)) (i2 + 1)) (i1 + 1))

或者以某种方式使结构更清晰：

\i1 -> (
    f i1 x1
    \i2 -> (
        f i2 x2
        \i3 -> (
            f i3 x3
            (const z) (i3+1)
        ) (i2+1)
    ) (i1+1)
)

因此，您可以看到外部函数接受一个参数（此处为i1），并使用f（索引）i1来调用x1（第一项），作为最后一项的通话结果是剩余列表的“首屏”。因此，我们以i2作为参数进行了调用，但该i2被绑定了i1+1。

因此，如果执行替换（用i3用i2 + 1代替），这就是lambda演算的工作原理，我们将获得：

\i1 -> (
    f i1 x1
    \i2 -> (
        f i2 x2
        (
            f (i2+1) x3
            (const z) (i2+1+1)
        )
    ) (i1+1)
)

此外，我们可以将i2替换为i1+1：

\i1 -> (
    f i1 x1
    (
        f (i1+1) x2
        (
            f (i2+1) x3
            (const z) (i1+1+1+1)
        )
)

由于(const z)映射到z，所以无论参数是什么，我们都可以用(const z) (i1+1+1+1)替换z，所以：

\i1 -> (
    f i1 x1
    (
        f (i1+1) x2
        (
            f (i1+1+1) x3
            z
        )
)

所以现在我们知道了foldr eval (const z) [x1, x2, x3]所映射的内容，但是有一个最终的功能应用：最后的0。

这意味着我们用0调用了上面定义的lambda-expression，因此它折叠为：

\i1 -> (
    f i1 x1
    (
        f (i1+1) x2
        (
            f (i1+1+1) x3
            z
        )
) 0

因此：

(
    f 0 x1
    (
        f (0+1) x2
        (
            f (0+1+1) x3
            z
        )
)

或紧凑形式：

(f 0 x1 (f 1 x2 (f 2 x3 z)))

因此我们设法在解决方案中注入了索引。

现在seq当然具有功能：它将防止为索引创建巨大的（左递归）表达式树，而不是((((1+1)+1)+1)+1)+1，它将确保每次我们递增索引时，它会立即进行评估，因此我们将永远不会获得1+1+1，而总是得到2+1，并立即将其解析为3。

Answer 2

如果^{（确实如此）}

foldr c n (x:xs) = c x (foldr c n xs)  :: t

c x r = ...    -- r: mnemonic: recursive result

c x r :: t , r :: t , n :: t          -- same t

然后surely ^{（通过eta扩展）}

foldr c n (x:xs) i = c x (foldr c n xs) i  :: t

c x r i = ...   -- c = (\ x r i -> ... )

c x r i :: t , r i :: t , n i :: t        -- same t

所以我们可以拥有

ifoldr f n (x:xs) = foldr c n (x:xs) i = c x (foldr c n xs) i    :: t
                                       = f i x (foldr c n xs i')  :: t

c x r i = f i x (r i') 

c x r i :: t , r i :: t , n i :: t , f i x :: t -> t

那就是你在那里。

索引文件夹如何运作？

2 个答案: