# Strict tuples

Manuel M T Chakravarty chak at cse.unsw.edu.au
Sat Mar 18 21:35:12 EST 2006

```Loosely related to Ticket #76 (Bang Patterns) is the question of whether
we want the language to include strict tuples.  It is related to bang
patterns, because its sole motivation is to simplify enforcing
strictness for some computations.  Its about empowering the programmer
to choose between laziness and strictness where they deem that necessary
without forcing them to completely re-arrange sub-expressions (as seq
does).

So what are strict tupples?  If a lazy pair is defined in pseudo code as

data (a, b) = (a, b)

a strict pair would be defined as

data (!a, b!) = ( !a, !b )

Ie, a strict tuple is enclosed by bang parenthesis (! ... !).  The use
of the ! on the rhs are just the already standard strict data type
fields.

Why strict tuples, but not strict lists and strict Maybe and so on?
Tuples are the Haskell choice of returning more than one result from a
function.  So, if I write

add x y = x + y

the caller gets an evaluated result.  However, if I write

addmul x y = (x + y, x * y)

the caller gets a pair of two unevaluated results.  Even with bang
patterns, I still have to write

addmul x y = let !s = x + y; !p = x * y in (s, p)

to have both results evaluated.  With strict tuples

addmul x y = (!x + y, x * y!)

suffices.

Of course, the caller could invoke addmul using a bang patterns, as in

let ( !s, !p ) = addmul x y
in ...

but that's quite different to statically knowing (from the type) that
the two results of addmul will already be evaluated.  The latter leaves
room for more optimisations.

Syntax issues
~~~~~~~~~~~~~
* In Haskell (,) is the pair constructor.  What should be use for
strict tuples?  (!,!) ?
* With strict tuples (! and !) would become some sort of
reserved/special symbol.  That interferes with bang patterns, as
(!x, y!) would be tokenized as (! x , y !).  We could use ( ... !)
for strict tuples to avoid that conflict, or just requires that the
user write ( !x, !y ) when they want a bang pattern.  (Just like you
cannot write `Just.x' to mean `Just . x' as the former will always be
read as a qualified name and not the application of function
composition.

Bang patterns enable the programmer (among other things) to define
functions with strict arguments.  Strict tuples enable to define strict
results.

Manuel

PS: IIRC Clean supports strict tuples.

```