标签: equational-reasoning

如果那样的return a = return b话你能证明a=b吗？当我使用时=,我的意思是在法律和证据意义上,而不是Eq阶级意义上.

我认识的每一个单子似乎都满足了这一点,我想不出一个有效的monad(Const a不是一个算子和应用,而不是一个monad.)

记住这个计划:

{-# LANGUAGE RankNTypes #-}

import Prelude hiding (sum)

type List h = forall t . (h -> t -> t) -> t -> t

sum_ :: (Num a) => List a -> a
sum_ = \ list -> list (+) 0

toList :: [a] -> List a
toList = \ list cons nil -> foldr cons nil list

sum :: (Num a) => [a] -> a
-- sum = sum_ . toList        -- does not work
sum = \ …

是否存在Haskell的方程扩展器？

像foldr.com这样的东西:1+(1+(1+(1+(…))))=?

我是Haskell的新手我很难理解为什么某些方程比其他方程更优选.我认为如果我能看到方程扩展会有所帮助.

例如,我发现foldrvs foldl起初很难理解,直到我看到它们扩展.

foldr :: (a -> b -> b) -> b -> [a] -> b
foldr k z xs = go xs
             where
               go []     = z
               go (y:ys) = y `k` go ys

foldl :: (a -> b -> a) -> a -> [b] -> a
foldl f z0 xs0 = lgo z0 xs0
             where
                lgo z []     =  z
                lgo z (x:xs) = lgo (f z x) …

我正在尝试为Setoids建模Agda风格的等式推理证明(具有等价关系的类型).我的设置如下:

infix 1 :=:

interface Equality a where
  (:=:)  : a -> a -> Type

interface Equality a => VerifiedEquality a where  
  eqRefl : {x : a} -> x :=: x
  eqSym  : {x, y : a} -> x :=: y -> y :=: x
  eqTran : {x, y, z : a} -> x :=: y -> y :=: z -> x :=: z

使用这样的接口,我可以模拟一些像Syntax.PreorderReasoning伊德里斯库那样的等式推理组合器 .

syntax [expr] "QED" = qed expr 
syntax [from] "={" [prf] "}=" [to] …

好吧,这是使用foldr定义过滤函数:

myFilter p xs = foldr step [] xs
    where step x ys | p x       = x : ys
                    | otherwise = ys

例如,假设我有这个功能:

myFilter odd [1,2,3,4]

所以它将是:

foldr step [] [1,2,3,4]

这将是

step 1 (foldr step [] [2,3,4])

这将是

step 1 (step 2 (foldr step [] [3,4]))

这将是

step 1 (step 2 (step 3 (foldr step [] [4])))

这将是

step 1 (step 2 (step 3 (step 4 (foldr step [] []))))

并且foldr step [] []是[] …

阅读"使用Haskell进行功能思考"我遇到了一个程序计算的一部分,需要将map sum (map (x:) xss)其重写为map (x+) (map sum xss)

直觉我知道它有意义......

如果你有一些你想要求和的列表,但是在求和之前,你还要添加一个元素'x',那么就像获取origninal列表的总和列表并添加x一样对每个人都有价值.

但我想知道如何使用等式推理将一个转换为另一个.我觉得我错过了一条能帮助我理解的法律或规则.

从功能方程式的角度来看，我希望两者的含义相同：

x = [1, 2, 3]
y = ['a', 'b', 'c']

reduce(lambda x, y: x + y, zip(x, y))  # works

sum(zip(x, y))  # fails

为什么sum在这里失败？

是(sequence .) . flip fmap一样的forM吗？我在这里问是因为pointfree.io似乎不这么说......