yavaş değerlendirme kapsamını belirleme

Question

yavaş değerlendirme kapsamını belirleme

oy

1

verilmiş

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)

Benim işlevi düğümleri (ki kapalı görünüyor ama bu sorunun kenara var) 'dir saymak

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)

Mu countiçeriğini değerlendirmez Msgıskartaya değerinin göre sayesinde _? Belki daha iyi bir soru, nasıl tembel değerlendirme başlar biliyor ve bu tür bir şey için biter mi edilir?

Üçüncü hat ise count'oldu:

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

Ben diğer üç alan varsayabiliriz Msg/ erişilen değerlendirilen veya tembel değerlendirme o kadar ileri gider ki?

haskell lazy-evaluation binary-search-tree

Oluştur 10/10/2011 saat 17:38
kaynak kullanıcı clintm

Diğer dillerde...

1 cevaplar

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

Hayır Bir veri yapısının alanlar varsayılan olarak tembel değerlendirilir. Eğer herhangi bir şekilde diğer alanlarını kullanarak değiliz olduklarından, bu kod tarafından değerlendirmeye alınmayacaktır. Eğer tüm alanları değerlendirilecek bir düğüm kuvvetleri değerlendirerek, sen tarlalara katılık, açıklama ekleme böylece bunu yapmak isterseniz:

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 }

Düğümlerin sayılması kendileri değerlendirilecek düğümleri zorlar için, bu da değerlendirilecek duğum değerlerini zorlar. Yalnızca tek bir fonksiyon için bu davranışı istiyorsanız, kullandığınız bir daha ince taneli bir şekilde değerlendirilmesini zorlayabilir seq:

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

ya da patlama deseni (gerektirir BangPatternsuzantısı)

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