Well, my question does not meet the standards for a question at stackoverflow: (I am a haskell beginner) This example is from LYAH: import System.Random finiteRandoms :: (RandomGen g, Random a, Num n) => n -> g -> ([a], g) finiteRandoms 0 gen = ([], gen) finiteRandoms n gen = let (value, newGen) = random gen (restOfList, finalGen) = finiteRandoms (n-1) newGen in (value:restOfList, finalGen) Looking at that function, I find it impossible to understand how that recursion works. I have to pull out a pencil and paper to figure it out. If I was given the task of writing that function, I would write it like this: import System.Random finiteRands :: (RandomGen g, Random a) => Int -> g -> [a] finiteRands n gen = finiteRands' n gen [] finiteRands' :: (RandomGen g, Random a) => Int -> g -> [a] -> [a] finiteRands' 0 _ acc = acc finiteRands' n gen acc = let (rand_num, new_gen) = random gen in finiteRands' (n-1) new_gen (rand_num:acc) To me, it makes the function(s) simplistic to understand. Is the first solution a known 'design pattern' in recursion? The first solution: import System.Random finiteRandoms :: (RandomGen g, Random a, Num n) => n -> g -> ([a], g) finiteRandoms 0 gen = ([], gen) finiteRandoms n gen = let (value, newGen) = random gen (restOfList, finalGen) = finiteRandoms (n-1) newGen in (value:restOfList, finalGen) seems to operate a bit like foldr: the recursion spins to the base case, and the base case's return value, ([], gen), is passed back through all the function calls. Each function call modifies the tuple (the in clause) before returning it to the previous function call. Is one solution more efficient than the other? I believe my solution is tail recursive, but it's my understanding that compilers can now optimize just about anything into tail recursion. Thanks.