exceeding nr of arguments in a list (or zf-expression)

[Ronny Wichers Schreur]

Hello,

Paul de Mast wrote (to the Clean Mailing List):

 > For solving puzzles zf-expressions are sometimes useful, but the
 > maximum nr of expressions (generators and filters) is 32 according
 > to the reference manual.
 > [..]
 > Any suggestions why the compiler thinks there are more then 32
 > expressions?

The essential limit is that in the Clean implementation functions
(and constructors) can't have more that 32 arguments. Comprehensions
are transformed to normal functions, and nested comprehensions are
transformed to nested function.

In your program the deepest generator uses all x's. In the transformed
program all these x's will be lifted. Consequently the function for this
generator will have 18 (lifted x's) + 19 (generators) = 37 arguments.

Normally the 32 limit is not a problem, because functions with that
many arguments are not comprehendible anyway (and terribly inefficient,
should you care for that).

It's not difficult to rewrite your program so that it doesn't lift
all individuel elements of the hexagon. Also you rebuild the list
of available numbers in every generator, which is not necessary:

------------------------------------------------------------------------------------
placements :: Int Hexagon [Int] -> [(Hexagon, [Int])]
placements position hexagon numbers
	=	[	(place number position hexagon, removeMember number numbers)
		\\	number <- numbers
		]
	where
		place :: Int Int Hexagon -> Hexagon
		place number position hexagon
			=	{{e \\ e <-: hexagon} & [position] = number}

empty_hexagon :: Hexagon
empty_hexagon
	=	{	{undef \\ _ <- [0..19]}
		& 	[0] = -1 // [0] is not used (Paul uses one based indices)
		}

magic_hexagon :: Hexagon
magic_hexagon
= hd [ x
		\\	(x, l) <- placements 1 empty_hexagon [1..19]
		,	(x, l) <- placements 2 x l
		,	(x, l) <- placements 3 x l
		|	x.[1] + x.[2] + x.[3] == 38
		,	(x, l) <- placements 4 x l
		,	(x, l) <- placements 8 x l
		|	x.[1] + x.[4] + x.[8] == 38
		,	(x, l) <- placements 7 x l
		,	(x, l) <- placements 12 x l
		|	x.[3] + x.[7] + x.[12] == 38
		, 	(x, l) <- placements 13 x l
		,	(x, l) <- placements 17 x l
		|	x.[8] + x.[13] + x.[17] == 38
		,	(x, l) <- placements 18 x l
		,	(x, l) <- placements 19 x l
		|	x.[18] + x.[19] + x.[17] == 38
		,	(x, l) <- placements 16 x l
		|	x.[16] + x.[19] + x.[12] == 38
		,	(x, l) <- placements 11 x l
		,	(x, l) <- placements 15 x l
		|	x.[7] + x.[11] + x.[15] + x.[18] == 38
		,	(x, l) <- placements 5 x l
		,	(x, l) <- placements 6 x l
		|	x.[4] + x.[5] + x.[6] + x.[7] == 38
		&&	x.[2] + x.[6] + x.[11] + x.[16] == 38
		,	(x, l) <- placements 9 x l
		|	x.[2] + x.[5] + x.[9] + x.[13] == 38
		,	(x, l) <- placements 10 x l
		|	x.[8] + x.[9] + x.[10] + x.[11] + x.[12] == 38
		&&	x.[1] + x.[5] + x.[10] + x.[15] + x.[19] == 38
		,	(x, l) <- placements 14 x l
		|	x.[13] + x.[14] + x.[15] + x.[16] == 38
		&&	x.[3] + x.[6] + x.[10] + x.[14] + x.[17] == 38
		&&	x.[4] + x.[9] + x.[14] + x.[18] == 38
	]
------------------------------------------------------------------------------------

Still quite a long program, but I can't be bothered now to generalise it
for arbitrary hexagons.


Cheers,

Ronny Wichers Schreur