Set the stack size to <size> bytes [default: 64K].
For concurrent/parallel programs, it is the stack size of the main
thread; generally speaking, c/p stacks are in heap.
Note: if your program seems to be consuming infinite stack space, it
is probably in a loop :-) Of course, if stacks are in the heap, make
that infinite heap space...

`-s<file>' or `-S<file>':

Write modest (`-s') or verbose (`-S') garbage-collector
statistics into file <file>. The default <file> is
<program>`.stat'. The <file> `stderr' is treated
specially, with the output really being sent to `stderr'.
The amount of heap allocation will typically increase as the total heap
size is reduced. The reason for this odd behaviour is that updates of
promoted-to-old-generation objects may require the extra allocation of a new-generation
object to ensure that there are never any pointers from the old
generation to the new generation.
For some garbage collectors (not including the default one, sadly),
you can convert the `-S' output into a residency graph (in
PostScript), using the `stat2resid' utility in
the GHC distribution (`ghc/utils/stat2resid').

`-N':

Normally, the garbage collector black-holes closures which are being
evaluated, as a space-saving measure. That's exactly what you want
for ordinary Haskell programs.
When signal handlers are present, however, a computation may be
abandoned prematurely, leaving black holes behind. If the signal
handler shares one of these black-holed closures, disaster can result.
Use the `-N' option to prevent black-holing by the garbage
collector if you suspect that your signal handlers may share any
subexpressions with the top-level computation. Expect your heap usage
to increase, since the lifetimes of some closures may be extended.