Stanovení rozsahu líné vyhodnocování

Question

Stanovení rozsahu líné vyhodnocování

hlasů

1

daný

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)

Moje funkce počítat uzlů (což se zdá být pryč, ale to je až na otázku) je

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)

Má countnehodnotí obsah Msgz titulu své hodnoty, přičemž odstraňují _? Možná lepší otázka je, jak mohu vědět, kde líné začíná vyhodnocování a končí na takovéhle věci?

V případě, že třetí řada count'byla:

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

Mohu předpokládat, že další tři obory Msgbyly přístupné / vyhodnoceny, nebo se líné vyhodnocování zajít tak daleko?

haskell lazy-evaluation binary-search-tree

Položena 10/10/2011 v 17:38
zdroj uživatelem clintm

V jiných jazycích...

1 odpovědí

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

No. Oblasti datové struktury jsou hodnoceny líně ve výchozím nastavení. Vzhledem k tomu, že nejste s využitím jiných polí v žádném případě nebudou hodnoceny tímto kódem. Chcete-li, aby to tak, aby vyhodnocení uzlu síly všechny jeho pole, které mají být hodnoceny, můžete přidat přísností popisy k polím:

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 }

Vzhledem k tomu, počítání uzly nutí uzly samotné, které mají být hodnoceny, bude také vynutit hodnoty uzel být vyhodnocen. Pokud chcete pouze toto chování pro své jedné funkce, můžete vynutit vyhodnocení ve více jemnozrnného způsobem za použití seq:

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

nebo rána vzor (vyžaduje BangPatternsrozšíření)

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