What would pattern matching look like in a strict Haskell?

Question

As a research experiment, I've recently worked on implementing strict-by-default Haskell modules. Instead of being lazy-by-default and having ! as an escape hatch, we're strict-by-default and have ~ as an escape hatch. This behavior is enabled using a {-# LANGUAGE Strict #-} pragma.

While working on making patterns strict I came up on an interesting question: should patterns be strict in the "top-level" only or in all bind variables. For example, if we have

f x = case x of
  y -> ...

we will force y even though Haskell would not do so. The more tricky case is

f x = case x of
  Just y -> ...

Should we interpret that as

f x = case x of
  Just y -> ...  -- already strict in 'x' but not in `y`

or

f x = case x of
  Just !y -> ...  -- now also strict in 'y'

(Note that we're using the normal, lazy Haskell Just here.)

One design constraint that might of value is this: I want the pragma to be modular. For example, even with Strict turned on we don't evaluate arguments to functions defined in other modules. That would make it non-modular.

Is there any prior art here?

Answer 1

As far as I understand things, refutable patterns are always strict at least on the outer level. Which is another way to say that the scrutinized expression must have been evaluated to WHNF, otherwise you couldn't see if it is a 'Just' or a 'Nothing'.

Hence your

!(Just y) -> ...

notation appears useless.

OTOH, since in a strict language, the argument to Just must already have been evaluated, the notation

Just !y ->

doesn't make sense either.