ну тогда понятно откуда редурант, я четко уверен, что он просто аргументы анализирует в корке. Какие-нибудь не используются - редурант констрейнт

let loop = (`mod` a) . (* b)
in  iterate' loop 1 !! foo

Почему если использовать не стрикт версию iterate, то память не очищается, а хранится весь список?
upd: изменил код

След. значение ведь зависит только от последнего в списке.

let loop = (`mod` a) . (* b)
in  iterate' loop 1 !! foo

почему вы считаете, что хранится весь список? и какой список?

Я код не тот пастнул, считаю, потому что при больших foo память забивается
Если использовать iterate', то при том же foo память не растет

Список, что выдает iterate

она не списком забивается

строгий iterate' строго вычисляет элементы

в обоих случаях все промежуточные элементы отбрасываются

но нестрогий строит цепочку задумок

это не тот список, о котором вы подумали

куда отбрасываются, не понял

они же в список идут

список никто не держит

(!!) этот список потребляет

а, там код поменялся

сначала было
 let loop = (`mod` a) . (* b)
  in length . takeWhile (/= foo) $ iter loop 1

взял вот такой код

main = do
 args <- getArgs
 print $ case args of
   ["lazy"] -> iterate (+ 1) (1 :: Int) !! 10000000
   ["strict"] -> iterate' (+ 1) (1 :: Int) !! 10000000
   _ -> 0

-- app lazy +RTS -s
  1,289,568,088 bytes allocated in the heap
  1,908,168,568 bytes copied during GC
    360,770,632 bytes maximum residency (16 sample(s))
    274,564,024 bytes maximum slop
           1103 MiB total memory in use (0 MB lost due to fragmentation)

-- app strict +RTS -s
    720,352,472 bytes allocated in the heap
      3,564,816 bytes copied during GC
        251,944 bytes maximum residency (2 sample(s))
        169,944 bytes maximum slop
             18 MiB total memory in use (0 MB lost due to fragmentation)

в первом случае список хранится, потому что чтобы потребить нужный элемент, ему нужно вычислить весь список до этого элемента, но делает он это в момент !!

во втором случае это не нужно, каждый элемент списка уже самодостаточен, не требует вычисления предыдущего