如何解决递归地修改Haskell中数据结构的一部分
| 大家好，我是Haskell的新手，我想创建一个Haskell程序，该程序可以在逻辑表达式上应用DeMorgan的定律。问题是我无法将给定的表达式更改为新的表达式（在应用了德摩根定律之后） 具体来说就是我的数据结构data LogicalExpression = Var Char
| Neg LogicalExpression
| Conj LogicalExpression LogicalExpression
| Disj LogicalExpression LogicalExpression
| Impli LogicalExpression LogicalExpression
deriving(Show)
解决方法
卢克（luqui）提出了思考问题的最优雅方法。但是，他的编码要求您为要创建的每个此类重写规则手动获得正确的遍历范围。
比约恩·布林格特（Bjorn Bringert）的“几乎可组合功能的模式”中的组合可以使此操作变得更容易，尤其是如果您需要编写多个这样的规范化遍历时。它通常是用Applicatives或2级类型编写的，但是为了使事情简单一点，我将推迟：
给定您的数据类型
data LogicalExpression
= Var Char
| Neg LogicalExpression
| Conj LogicalExpression LogicalExpression
| Disj LogicalExpression LogicalExpression
| Impl LogicalExpression LogicalExpression
deriving (Show)
class Compos a where
compos\' :: (a -> a) -> a -> a
instance Compos LogicalExpression where
compos\' f (Neg e) = Neg (f e)
compos\' f (Conj a b) = Conj (f a) (f b)
compos\' f (Disj a b) = Disj (f a) (f b)
compos\' f (Impl a b) = Impl (f a) (f b)
compos\' _ t = t
elimImpl :: LogicalExpression -> LogicalExpression
elimImpl (Impl a b) = Disj (Not (elimImpl a)) (elimImpl b)
elimImpl t = compos\' elimImpl t -- search deeper
nnf :: LogicalExpression -> LogicalExpression
nnf (Neg (Conj a b)) = Disj (nnf (Neg a)) (nnf (Neg b))
nnf (Neg (Disj a b)) = Conj (nnf (Neg a)) (nnf (Neg b))
nnf (Neg (Neg a)) = nnf a
nnf t = compos\' nnf t -- search and replace
Neg
import Control.Applicative
import Control.Monad.Identity
class Compos a where
compos :: Applicative f => (a -> f a) -> a -> f a
compos\' :: Compos a => (a -> a) -> a -> a
compos\' f = runIdentity . compos (Identity . f)
instance Compos LogicalExpression where
compos f (Neg e) = Neg <$> f e
compos f (Conj a b) = Conj <$> f a <*> f b
compos f (Disj a b) = Disj <$> f a <*> f b
compos f (Impl a b) = Impl <$> f a <*> f b
compos _ t = pure t
-- no need to call self on the top-level structure,-- since deMorgan is never applicable to its own result
deMorgan (Neg (a `Conj` b)) = (deMorgan $ Neg a) `Disj` (deMorgan $ Neg b)
deMorgan (Neg (a `Disj` b)) = (deMorgan $ Neg a) `Conj` (deMorgan $ Neg b)
deMorgan (Neg a) = Neg $ deMorgan a
deMorgan (a `Conj` b) = (deMorgan a) `Conj` (deMorgan b)
-- ... etc.
P -> Q
not P or Q
Impli
deMorgan (Neg (Var x)) = Neg (Var x)
deMorgan (Neg (Neg a)) = deMorgan a
deMorgan (Neg (Conj a b)) = Disj (deMorgan (Neg a)) (deMorgan (Neg b))
-- ... etc. match Neg against every constructor
deMorgan (Conj a b) = Conj (deMorgan a) (deMorgan b)
-- ... etc. just apply deMorgan to subterms not starting with Neg
Neg
Var
deMorgan\' z@(Var x) = z
deMorgan\' (Neg (Conj x y)) = (Disj (Neg x) (Neg y))
deMorgan\' (Neg (Disj x y)) = (Conj (Neg x) (Neg y))
deMorgan\' z@(Neg x) = z
deMorgan\' (Conj x y) = Conj x y
deMorgan\' (Disj x y) = Disj x y
let var <- (Conj (Disj (Var \'A\') (Var \'B\')) (Neg (Disj (Var \'D\') (Var \'E\'))))
*Main> deMorgan\' var
Conj (Disj (Var \'A\') (Var \'B\')) (Neg (Disj (Var \'D\') (Var \'E\')))
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。