definition of take

[Jorge Adriano Aires]

Hi, 
I don't know much about the internals of GHC, but I like look around once in a 
while to learn a few things. I was wondering about the definition of take, 
which is, for Ints:

---------------------------------------------------------------------
takeUInt :: Int# -> [b] -> [b]
takeUInt n xs
  | n >=# 0#  =  take_unsafe_UInt n xs
  | otherwise =  []

take_unsafe_UInt :: Int# -> [b] -> [b]
take_unsafe_UInt 0#  _  = []
take_unsafe_UInt m   ls =
  case ls of
    []     -> []
    (x:xs) -> x : take_unsafe_UInt (m -# 1#) xs
---------------------------------------------------------------------

Wouldn't pattern matching against 1# instead of 0#, like in the following 
definition, be better in terms of garbage collecting the list or what it 
depends on? 

-----------------------------------------------------------------------
takeUInt :: Int# -> [b] -> [b]
takeUInt 0# _ =  []
takeUInt n xs
  | n ># 0#   =  take_unsafe_UInt n xs
  | otherwise =  []

take_unsafe_UInt :: Int# -> [b] -> [b]
take_unsafe_UInt 1#  (x:xs)  = [x]
take_unsafe_UInt m   ls      =
  case ls of
    []     -> []
    (x:xs) -> x : take_unsafe_UInt (m -# 1#) xs
------------------------------------------------------------------

My guess would be that, if we're consuming a (take n xs) lazily, with the 
first definition garbage collecting would happen when the last element had 
been consumed  and with the second, when the last element had been produced - 
(which is when we find out there are no more elements to consume in each 
case).

Thanks, and sorry if the question is to naive,
J.A.