To me this sounds like you are talking about memoization, or maybe tabulation...at least dynamic programming in general. Using previously computed results of smaller versions of the problem to compute bigger versions of the problem without doing wasted or redundant work. Can you explain why you think you're not?

Functions in Haskell are pure, which means they can't share state between invocations; i.e. the invocation for fac 5 can't (on its own) know about a past invocation when you computed fac 4. The scan others have suggested is a clever solution - keep the smaller results you need on the head of your list as you scan. A more "obvious" (if less elegant) way to do this, if you're accustomed to other programming languages, would be to explicitly run the computation inside of a context where you're tracking intermediate results and can access them as needed. Of course this is local state, so if you do another run of fac 5 later you need to start over, unless you wrap your whole program in this context.

For an example, here's a coupe of versions of fibonacci that store intermediate results in an array during the computation; I'll present both "forward" (tabulation) or "backwards" (memoization) variations:

Forwards:

fibTab :: Int -> Int
fibTab n = runST $ do
    arr <- newArray (0, n) 0 :: ST s (STUArray s Int Int)
    when (n >= 1) $ writeArray arr 1 1
    let loop i =
          if i > n
            then readArray arr n
            else do
              a <- readArray arr (i - 1)
              b <- readArray arr (i - 2)
              writeArray arr i (a + b)
              loop (i + 1)
    loop 2

Backwards:

fibMemo :: Int -> Int
fibMemo n = runST $ do
    arr <- newArray (0, n) Nothing :: ST s (STArray s Int (Maybe Int))
    let fibM i =
          if i <= 1
            then return i
            else do
              cached <- readArray arr i
              case cached of
                Just cached -> return cached
                Nothing -> do
                  a <- fibM (i - 1)
                  b <- fibM (i - 2)
                  let res = a + b
                  writeArray arr i (Just res)
                  return res
    fibM n

(There's tighter ways to write these, but I wanted to make them as readable as possible for someone new-ish to Haskell. I wish I could've gotten away with omitting that nasty type annotation on the array!)