Strict tuples

[Manuel M T Chakravarty]

Simon Marlow:
> Not to mention overlap with sections:  (!i).  Even with just bang
> patterns, we have some interesting parsing problems due to the overlap
> with infix '!'.  eg., now 
> 
>   arr ! x = indexArray arr x
> 
> will probably parse as
> 
>   arr (!x) = indexArray arr x
> 
> which means that in order to define (!) you have to use the prefix form:
> (!) arr x = ...
> 
> GHC's implementation of bang pattern parsing has some ugliness to deal
> with this.  In the report, we will have to be very careful to make sure
> the syntax doesn't have any ambiguities in this area, which will
> probably mean adding special cases to the grammar.
> 
> My suggestion is to avoid these problems by removing infix '!' from the
> syntax:
> 
> http://haskell.galois.com/cgi-bin/haskell-prime/trac.cgi/wiki/ArrayIndex
> ing
> 
> I realise this is a code-breaking change, but I consider the special
> cases introduced to the syntax by bang patterns to be rather warty.
> Also, since I think many of us envisage Haskell moving towards having
> more strictness annotations in the future, it makes sense to
> consistently use the '!' operator to mean "strict".

I agree that the use of ! for indexing is a bad choice, actually a very
bad choice.  As arrays are not used that much and (!) isn't even
exported from the Prelude, I like the idea of changing the indexing
syntax.  I am less convinced that it is wise to change the syntax of
function composition, as this will break a huge set of programs.  I
actually also don't see that this affects the array proposal.  (.#)
would be a valid and free operator anyway, wouldn't it?  What about list
indexing? Use (.##)?  (Doesn't look very nice, but transfers the (!) for
arrays and (!!) for lists idea.)  A change to list indexing will
probably break more programs than a change to array indexing.

Apart from the syntactic issues, does anybody else support the idea of
strict tuples as proposed?  I just want to know whether I am alone on
this before putting it on the wiki.

Manuel

> On 19 March 2006 02:35, Manuel M T Chakravarty wrote:
> > 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.
>