[momentoftop]

Here's a pure computation:

    import Data.List (nubBy)

    refuteGoldbach :: Integer
    refuteGoldbach = head $ [ n
                            | n <- [4,6..]
                            , not $ n `elem` [ p1 + p2 | p1 <- primesTo n, p2 <- primesTo n ]
                            ]
      where primesTo n = takeWhile (< n) $ nubBy isMultiple [2..]
            isMultiple m n = n `rem` m == 0

If you think you already know the answer to this computation, get yourself a Field's medal.

And then there are pure functions. Every time you compute a function using an input no-one has tried before, you are probably computing something that is not already known. You do this routinely even with a calculator.

[Scarblac]

And if you don't store the answer in some kind of state, it's lost and computing the pure function was useless.

[HelloNurse]

In typical functional languages state is managed so that it doesn't hurt, not completely absent.

For example, a REPL keeps state in the messages it prints to the terminal and this state isn't visible in the pure function definitions and expression the program is concerned with.

[Life_exe]

You don't have to throw away the result. That's what the State Monads are for. Immutable State is Ok. Memoization is Ok.

[linspace]

> get yourself a Field's medal.

Unfortunately I'm over 40, otherwise I would try