Mértékének meghatározására lusta értékelés

Question

Mértékének meghatározására lusta értékelés

szavazat

1

Adott

data BTree a = End
             | Node a (BTree a) (BTree a)
   deriving(Show,Eq,Ord)

data Msg = Msg { from :: String
               , to :: String
               , when :: Int
               , message :: String }

instance Ord Msg where
    compare a b = (when a) `compare` (when b)

instance Eq Msg where
    (==) a b = (when a) == (when b)

Saját függvény számolni csomópontok (ami úgy tűnik ki, de ez eltekintve a kérdés) van

count :: (Ord a) => (BTree a) -> Int
count = sum . count'
 where
  count' :: (Ord a) => (BTree a) -> [Int] 
  count' End = []
  count' (Node _ l r) =
    [1] ++ (count' l) ++ (count' r)

Vajon countnem értékelik a tartalmát a Msgfogva érték alatt kezelnek _? Talán jobb kérdés, hogy tudom, hogy hol lusta értékelés kezdődik és végződik ez a fajta dolog?

Ha a harmadik sorban a count'következő volt:

count' (Node (Msg x _ _ _) l r) =

Lehet feltételezni, hogy a másik három területen Msgis elérhető / értékelni, vagy egyáltalán lusta értékelés ilyen messzire menni?

haskell lazy-evaluation binary-search-tree

A kérdést 10/10/2011 17:38
a forrás felhasználó clintm

Más nyelveken...

1 válasz

hammar · Accepted Answer · 2011-10-10 17:56

Nem, a mezők adatstruktúra értékeljük lustán alapértelmezés szerint. Mivel éppen nem használja a más területeken bármilyen módon, akkor nem értékeli ezt a kódot. Ha azt szeretnénk, hogy győződjön meg úgy, hogy értékeli a csomópont erők minden mezőt kell értékelni, akkor add szigorúsága kommentárokat a mezőket:

data BTree a = End
             | Node !a (BTree a) (BTree a)
   deriving(Show,Eq,Ord)

data Msg = Msg { from :: !String
               , to :: !String
               , when :: !Int
               , message :: !String }

Mivel számítva a csomópontok kényszeríti a csomópontokat maguk értékelni kell, ez is kényszeríteni a csomóponti értékeket kell értékelni. Ha csak szeretné ezt a viselkedést a több funkciót, akkor kényszerítheti értékelést egy sokkal finomabb módon, seq:

count' (Node x l r) = x `seq` ([1] ++ count' l ++ count' r)

vagy robbanással mintát (előírja a BangPatternskiterjesztés)

count' (Node !x l r) = [1] ++ count' l ++ count' r