Question

我正在为考试做准备的其中一项任务让我创造了

from models.scan import Scan
from models.ping import Ping

hosts = "192.168.0.0/24"
input_hosts = Ping.prep_hosts(hosts)  # or Scan.prep_hosts(hosts)
pinger = Ping(ping_string, input_hosts)

然后它要求制作

data Exp = T | F | And Exp Exp | Or Exp Exp | Not Exp deriving (Eq, Show, Ord, Read)

这就是我想出来的

folde :: a -> a -> (a -> a -> a) -> (a -> a -> a) -> (a -> a) -> Exp -> a

作业要求folde :: a -> a -> (a -> a -> a) -> (a -> a -> a) -> (a -> a) -> Exp -> a folde t f a o n T = t folde t f a o n F = f folde t f a o n (And x y) = a (folde t f a o n x) (folde t f a o n y) folde t f a o n (Or x y) = o (folde t f a o n x) (folde t f a o n y) folde t f a o n (Not x) = n (folde t f a o n x)，evb和evi。

他们都应该使用正确的参数一次调用folde。

Evb评估布尔表达式。

evh

Evi评估为整数，将evb :: Exp -> Bool evb = folde True False (&&) (||) not视为T，Int 1视为F，Int 5视为And，{{1} } +和Or为否定。

到目前为止一切顺利，一切正常。我也很乐意收到任何反馈意见。

但是，我似乎无法理解如何解决Not。 evi :: Exp -> Int evi = folde 1 5 (+) (*) negate应该计算树的高度。

应为evh

作业说它应该将evh和evh :: Exp -> Int视为高度T。它继续F评估为1。 Not x和height x + 1有And。

我似乎无法弄清楚我应该传递给Or函数

Answer 1

作业说它应该将T和F视为高度1。它继续Not x评估为height x + 1。 And和Or的最高子树高度为1。

你可以用显式递归直接写这个：

height T = 1
height F = 1
height (Not x) = height x + 1
height (And x y) = max (height x) (height y) + 1
height (Or  x y) = max (height x) (height y) + 1

现在，你如何用folde写这个？关于递归折叠的关键是folde为每个函数提供折叠所有子树的结果。当您folde And l r时，它首先折叠两个子树，然后将这些结果传递给folde的参数。因此，代替您手动调用height x，folde将为您计算并将其作为参数传递，因此您自己的工作最终会像\x y -> max x y + 1一样。本质上，将height拆分为5个定义，每个构造函数一个，而不是解构和递归子树，将子树的高度作为参数：

heightT = 1 -- height T = 1
heightF = 1 -- height F = 1
heightN x = x + 1 -- height (Not x) = height x + 1
heightA l r = max l r + 1 -- height (And l r) = max (height l) (height r) + 1
heightO l r = max l r + 1 -- height (Or  l r) = max (height l) (height r) + 1

将它们提供给folde，然后简化

height = folde 1 1  -- T F
               ao   -- And
               ao   -- Or
               (+1) -- Not
         where ao x y = max x y + 1

<小时/> 现在换新的东西！采用这个定义：

data ExpF a = T | F | Not a | And a a | Or a a
              deriving (Functor, Foldable, Traversable)

这看起来像你的Exp，除了递归之外，它有一个类型参数和一堆用于该类型值的漏洞。现在，看看ExpF下的表达式类型：

T :: forall a. ExpF a
Not F :: forall a. ExpF (ExpF a)
And F (Not T) :: forall a. ExpF (ExpF (ExpF a))

如果你在上面的每一个中设置a = ExpF (ExpF (ExpF (ExpF (ExpF ...))))（在无限远处），你会发现它们都可以具有相同的类型：

T             :: ExpF (ExpF (ExpF ...))
Not F         :: ExpF (ExpF (ExpF ...))
And F (Not T) :: ExpF (ExpF (ExpF ...))

无限很有趣！我们可以使用Fix

对这种无限递归类型进行编码

newtype Fix f = Fix { unFix :: f (Fix f) }
-- Compare
-- Type  level: Fix f = f (Fix f)
-- Value level: fix f = f (fix f)
-- Fix ExpF = ExpF (ExpF (ExpF ...))
-- fix (1:) =    1:(   1:(  1: ...))
-- Recover original Exp
type Exp = Fix ExpF
-- Sprinkle Fix everywhere to make it work
Fix T :: Exp
Fix $ And (Fix T) (Fix $ Not $ Fix F) :: Exp
-- can also use pattern synonyms
pattern T' = Fix T
pattern F' = Fix F
pattern Not' t = Fix (Not t)
pattern And' l r = Fix (And l r)
pattern Or' l r = Fix (Or l r)
T' :: Exp
And' T' (Not' F') :: Exp

现在这里有一个很好的部分：fold的一个定义来统治它们：

fold :: Functor f => (f a -> a) -> Fix f -> a
fold alg (Fix ffix) = alg $ fold alg <$> ffix
-- ffix :: f (Fix f)
-- fold alg :: Fix f -> a
-- fold alg <$> ffix :: f a
-- ^ Hey, remember when I said folds fold the subtrees first?
-- Here you can see it very literally

这是一个单态height

height = fold $ \case -- LambdaCase extension: \case ... ~=> \fresh -> case fresh of ...
  T -> 1
  F -> 1
  Not x -> x + 1
  And x y -> max x y + 1
  Or  x y -> max x y + 1

现在是一个非常多态的height（在你的情况下，它是一个人关闭;哦，好吧）。

height = fold $ option 0 (+1) . fmap getMax . foldMap (Option . Just . Max)
height $ Fix T -- 0
height $ Fix $ And (Fix T) (Fix $ Not $ Fix F) -- 2

请参阅recursion-schemes套餐，了解这些黑暗艺术。它还使得这类基本类型（如[]）具有类型系列，并且不需要使用所述技巧+ {TH}来Fix所有内容。

使用Haskell中的folde函数查找树高

1 个答案: