[Haskell-cafe] Defining a Strict language pragma

Iustin Pop iusty at k1024.org
Tue Nov 6 00:28:32 CET 2012

On Mon, Nov 05, 2012 at 02:52:56PM -0800, Johan Tibell wrote:
> Hi all,
> I would like to experiment with writing some modules (e.g. low-level
> modules that do a lot of bit twiddling) in a strict subset of Haskell. The
> idea is to remove boilerplate bangs (!) and instead declare the whole
> module strict. I believe this would both make code that needs to be strict
> more declarative (you say what you want once, instead of putting bangs
> everywhere), less noisy, and more predictable (no need to reason about
> laziness in places where you know you don't want it). The idea is to
> introduce a new language pragma
> {-# LANGUAGE Strict #-}
> that has the above described effect.
> The tricky part is to define the semantics of this pragma in terms of
> Haskell, instead of in terms of Core. While we also need the latter, we
> cannot describe the feature to users in terms of Core. The hard part is to
> precisely define the semantics, especially in the presence of separate
> compilation (i.e. we might import lazy functions).
> I'd like to get the Haskell communities input on this. Here's a strawman:
>  * Every function application f _|_ = _|_, if f is defined in this module
> [1]. This also applies to data type constructors (i.e. the code acts if all
> fields are preceded by a bang).
>  * lets and where clauses act like (strict) case statements.
>  * It's still possible to define strict arguments, using "~". In essence
> the Haskell lazy-by-default with opt-out via "!" is replaced with
> strict-by-default with opt-out via "~".

Did you mean here "it's still possible to define _lazy_ arguments"? The
duality of !/~ makes sense, indeed.

I personally have no idea what implications this might have, but I would
be very interested to see how existing code (which doesn't require
laziness) would behave when run under this new pragma.


More information about the Haskell-Cafe mailing list