Примерно это имел в виду Робин Зигмонд:

checkNumbers :: IO [Int]
checkNumbers = filterM check [1..10000]
    where
        check number = do
            print $ "Checking number" <> show number
            pure $ isSpecial number

Это напечатает «Проверка числа x» перед проверкой каждого числа. Не стесняйтесь экспериментировать с любыми другими эффектами (или, по-вашему, «многословием») внутри функции check.

Вот способ, который не требует ввода-вывода, вместо этого полагаясь на лень, и ваш программист угадывает, какая «сторона» условия встречается чаще. Просто чтобы было с чем поиграть, вот немного медленная функция, которая проверяет, является ли число кратным 10. Детали этой функции не важны, не стесняйтесь пропустить ее, если что-то не имеет смысла. Я также собираюсь включить отчеты о времени; вы увидите, почему позже.

> isSpecial :: Int -> Bool; isSpecial n = last [1..10000000] `seq` (n `mod` 10 == 0)
> :set +s

(Добавляйте один 0 каждые пять лет.)

Теперь идея будет такой: вместо понимания вашего списка мы будем использовать partition, чтобы разделить список на две части, элементы, которые соответствуют предикату, и те, которые не соответствуют. Мы напечатаем тот из них, у которого больше элементов, чтобы мы могли следить за прогрессом; к тому времени, когда он будет полностью напечатан, другой будет полностью оценен, и мы сможем проверить его, как захотим.

> :m + Data.List
> (matches, nonMatches) = partition isSpecial [1..20]
(0.00 secs, 0 bytes)
> nonMatches
[1,2,3,4,5,6,7,8,9,11,12,13,14,15,16,17,18,19]
(12.40 secs, 14,400,099,848 bytes)

Очевидно, я не могу отобразить это через StackOverflow, но когда я сделал вышеописанное, числа в списке nonMatches медленно появлялись на моем терминале одно за другим, давая довольно хороший индикатор того, где в списке он в данный момент думал. И теперь, когда вы печатаете matches, полный список доступен более или менее мгновенно, как вы можете видеть по отчету о времени (т.е. не через очередное 12-секундное ожидание):

> matches
[10,20]
(0.01 secs, 64,112 bytes)

Но будьте осторожны!

1. Важно, чтобы matches и nonMatches имели типы, которые не являются полиморфными классами типов (т. е. не имеют типов, начинающихся с Num a => ... или какого-либо другого ограничения). В приведенном выше примере я добился этого, сделав isSpecial мономорфным, что вынуждает matches и nonMatches быть такими же, но если ваш isSpecial полиморфен, вы должны указать сигнатуру типа для matches или nonMatches, чтобы предотвратить эту проблему.

2. Таким образом, все списки nonMatches и matches будут реализованы в памяти. Это может быть дорого, если первоначальный разделяемый список очень длинный. (Но до, скажем, пары сотен тысяч Ints для современных компьютеров не так уж и много.)

Debug.Trace

Вы можете посмотреть на Debug.Trace. Он позволяет выводить сообщения на консоль. Но поскольку Haskell ленив, контролировать, когда происходит печать, не так просто. И это тоже не рекомендуется для производства:

Prelude Debug.Trace> import Debug.Trace
Prelude Debug.Trace> [x | x <- [1..10], traceShow (x, odd x) $ odd x]
(1,True)
[1(2,False)
(3,True)
,3(4,False)
(5,True)
,5(6,False)
(7,True)
,7(8,False)
(9,True)
,9(10,False)
]

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

Что я обычно делаю, так это разбиваю входной список на фрагменты из n элементов, фильтрую каждый фрагмент так же, как и весь список, и преобразовываю каждый фрагмент в пару его головного элемента и отфильтрованного фрагмента:

chunked_result = [ (h, [n | n <- chunk, isSpecial n])
                   | chunk@(h:_) <- chunksOf n input]

Помещение такого списка результатов через concatMap snd дает исходную не "подробную" опцию.

Настройка значения n повлияет на частоту, с которой будет "сообщаться" о прогрессе, когда список результатов будет просто распечатываться, показывая как проверенные, так и обнаруженные числа, с некоторым несущественным "шумом" вокруг них.

Использование second concat . unzip в списке результатов фрагментов чем-то похоже на идею разбиения Даниэля Вагнера (с оговорками),^(*), но с вашим установленным значением n, а не просто 1.

Если вашей конкретной проблеме присуще алгоритмическое замедление, примените оценку времени выполнения по порядку роста анализ.

^(*), чтобы сделать его совместимым, нам нужно вставить где-нибудь seq посередине, например

chunked_result = [ (last s `seq` last chunk, s)
                   | chunk <- chunksOf n input
                     let s = [n | n <- chunk, isSpecial n] ]

или что-то.