🚀 go-pugleaf

kh@cs.glasgow.ac.uk (Kevin Hammond) writes:
>In article <293@smds.UUCP> rh@smds.UUCP (Richard Harter) writes:
>>Could some one post a summary explanation of the off-side rule, please?

>Simply put, in Miranda all text to the right of a defining operator
>("where" or "=") after a newline comprises part of the previous line.
>Other newlines act as separators.  This applies recursively, so you
>can build up levels of nested definitions structured by their layout.

This is not quite correct. The offside rule in Miranda applies to
certain nonterminals in the syntax such as: each alternative on the
righthand side of a variable or function definition, other righthand
sides (type definitions, aliases, and specifications), bodies of
module inclusion directives. The definition list after "where" does
not create a ``offside level'' in itself, it's included in that of the
last alternative of the righthand side.

Also, the critical indentation is determined by the first token
produced by the nonterminal, not by the token before it.

>This allows:

>	|| Example 2
>	 f (x:xs)
>	   y
>             z
>          =  x + 
>           y + z

Therefore, this example gives a "syntax error - unexpected token
OFFSIDE". The last line should be indented to the level of the "x" in
the line above, not just past the "=".

>Note that Haskell's layout rule is *not identical* to the Miranda
>off-side rule.  In particular:

>	i)	It is possible to turn off layout at will;
>	ii)	The layout rules do not use "=" as a defining point;
>	iii)	Alignment of definitions is significant

>(ii) is particularly important -- I find my Miranda programs regularly
>vanish off the RHS of the page (because of the need to insert a fixed
>amount of space), but this never happens with Haskell.

(ii) is incorrect, and the wild indentation can be avoided with an
alternative style:

	function of six rather longwindedly named arguments =
		right hand side
		where some other function =
			is defined

You can also break before the "=", at the cost of a tabstop. I usually
do that, especially when there are several alternatives:

	foo a b c
	  = bar a		, if b = c
	  = baz (bar b ++ bar c)
		kvetch		, otherwise
	    where
	      kvetch
		= burble a b c

It's not pretty, but it always works (even if you modify the left hand
side later) and the indentation only depends on nesting level.

The other two points are valid, and very much in Haskell's favor.

--
Lars Mathiesen, DIKU, U of Copenhagen, Denmark      [uunet!]mcsun!diku!thorinn
Institute of Datalogy -- we're scientists, not engineers.      thorinn@diku.dk