Determinare la portata della valutazione pigra

Question

Determinare la portata della valutazione pigra

voti

1

Dato

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)

La mia funzione per contare i nodi (che sembra fuori ma che è a parte la questione) è

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)

Non countNon valutare il contenuto della Msgvirtù del suo valore per essere scartato da _? Forse una domanda migliore è: come faccio a sapere dove inizia valutazione pigri e termina per questo genere di cose?

Se la terza linea di count'stato:

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

Posso supporre che gli altri tre campi di Msgsi accedeva / valutati, ovvero non effettua la valutazione pigra arrivare a tanto?

haskell lazy-evaluation binary-search-tree

È pubblicato 10/10/2011 alle 17:38
fonte dall'utente clintm

In altre lingue...

1 risposte

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

No. I campi di una struttura di dati vengono valutati pigramente per default. Dal momento che non si sta usando gli altri campi in qualsiasi modo, non saranno valutati da questo codice. Se si vuole fare in modo che la valutazione di un nodo forze tutti i suoi campi da valutare, è possibile aggiungere annotazioni severità ai campi:

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 }

Poiché contare i nodi costringe i nodi stessi da valutare, questo costringerà anche i valori del nodo da valutare. Se si desidera solo questo comportamento per la vostra una funzione, è possibile forzare la valutazione in modo più capillare utilizzando seq:

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

o un motivo scoppio (richiede l' BangPatternsestensione)

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