Het bepalen van de omvang van de lazy evaluatie

Question

Het bepalen van de omvang van de lazy evaluatie

stemmen

1

Gegeven

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)

Mijn functie om knooppunten (die lijkt af, maar dat is afgezien van de vraag) is te tellen

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)

Is countde inhoud van de niet beoordelen Msgop grond van de waarde ervan wordt weggegooid door _? Misschien een betere vraag is, hoe weet ik waar de lazy evaluatie begint en eindigt voor dit soort dingen?

Als de derde regel van count'was:

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

Mag ik aannemen dat de andere drie velden van Msgwerden benaderd / geëvalueerd, of is lui evaluatie zo ver gaan?

haskell lazy-evaluation binary-search-tree

De vraag is gesteld op 10/10/2011 om 17:38
bron van user clintm

In andere talen...

1 antwoorden

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

Nee De velden van een datastructuur worden lui geëvalueerd standaard. Omdat je niet met behulp van de andere gebieden op enigerlei wijze, zullen ze niet worden beoordeeld door deze code. Als u wilt om het te maken, zodat de evaluatie van een knooppunt krachten al zijn gebieden te evalueren, kunt u strengheid aantekeningen toevoegen aan de velden:

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 }

Omdat het tellen van de knooppunten dwingt knooppunten zelf te evalueren, zal dit ook dwingen knooppunt waarden te evalueren. Als u alleen dit gedrag voor één functie, kunt u de evaluatie dwingen in een meer fijnkorrelige manier met behulp van seq:

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

of een knal patroon (vereist BangPatternsextensie)

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