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?

È pubblicato 10/10/2011 alle 15:38
fonte dall'utente
In altre lingue...                            


1 risposte

voti
1

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
Risposto il 10/10/2011 a 15:56
fonte dall'utente

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more