आलसी मूल्यांकन की सीमा निर्धारित करने

दिया हुआ

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)

मेरे समारोह नोड्स (जो बंद लगता है, लेकिन है कि प्रश्न से अलग है) है गिनती करने के लिए

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)

करता है countकी सामग्री का मूल्यांकन नहीं कर Msgअपने मूल्य के द्वारा आधार पर खारिज कर दिया जा रहा है _? शायद एक बेहतर सवाल, कैसे मैं कहाँ आलसी मूल्यांकन शुरू होता है पता है और बात की इस तरह के लिए समाप्त हो जाती है है है?

तो की तीसरी पंक्ति count'था:

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

मैं मान सकते हैं कि के अन्य तीन क्षेत्रों Msgपहुँचा रहे थे / मूल्यांकन किया, या आलसी मूल्यांकन है कि अब तक जाता है?