Å bestemme omfanget av lat evaluering

Question

Å bestemme omfanget av lat evaluering

stemmer

1

gitt

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)

Min funksjon for å telle noder (som synes av, men det er bortsett fra spørsmålet) er

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)

Har countikke vurdere innholdet i Msgkraft av sin verdi som blir forkastet av _? Kanskje et bedre spørsmål er, hvordan vet jeg hvor lat evaluering starter og slutter for denne typen ting?

Hvis den tredje linjen count'var:

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

Kan jeg anta at de tre andre områdene Msgble åpnet / evaluert, eller ikke lat evaluering gå så langt?

haskell lazy-evaluation binary-search-tree

Publisert på 10/10/2011 klokken 16:38
kilden bruker clintm

På andre språk...

1 svar

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

No. Områdene for en datastruktur som er bedømt dovent som standard. Siden du ikke bruker de andre feltene på noen måte, vil de ikke bli vurdert av denne koden. Hvis du ønsker å gjøre det slik at evaluering av en node styrker alle felt som skal vurderes, kan du legge strenghet merknader til feltene:

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 }

Siden teller nodene tvinger nodene selv som skal vurderes, vil dette også tvinge nodeverdiene som skal evalueres. Hvis du bare vil dette problemet for en funksjon, kan du tvinge evaluering i en mer finkornet måte ved hjelp av seq:

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

eller et smell mønster (krever BangPatternsforlengelse)

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