On 5/19/05, Matt Fowles <[EMAIL PROTECTED]> wrote:
> What does the reduce metaoperator do with an empty list?
/me puts on his lambda hat
In Haskell, there is a distinction between foldl and foldl1 (similar
remarks apply to foldr/foldr1):
The former (foldl) requires you to give an explicit 'left unit',
which is implicitly added to the left of the list being reduced. This
means that folding an empty list will just give you the unit.
foldl (+) 0 [a,b,c] = ((0+a)+b)+c
foldl (+) 0  = 0
The latter (foldl1) doesn't use a unit value, but this means that you
can't fold empty lists.
foldl1 (+) [a,b,c] = (a+b)+c
foldl1 (+)  = ***error***
/me puts camel hat back on
This suggests that -reducing an empty list should probably (IMO) do
one of the following:
* Fail, since it's an ill-defined operation without an explicit unit
* Try to find a suitable unit value (see below), and fail if it doesn't find one
You /could/ try to do something 'sensible' and return 0 or undef, but
this seems likely to result in more confusion.
Another alternative is to give the user the option of specifying such
a unit when using the reduction meta-operator, but this seems to work
against the whole point of [+] (which is brevity). If you want to
specify your own unit, use '&reduce'.
> my @a;
> [+] @a; # 0? exception?
> [*] @a; # 1? exception?
> [<] @a; # false?
> [||] @a; # false?
> [&&] @a; # true?
> Also if it magically supplies some correct like the above, how does it
> know what that value is?
Perhaps the operator could have some kind of 'unit' trait? (Or perhaps
'left_unit' and 'right_unit'?)
 Just remember that unlike foldr/foldl, which are explicitly
right/left associative, [+] is 'DWIM-associative', reflecting the
associativity of the underlying operator.
 e.g. 0 is the left (and right) unit of + because 0 + x == x (and x + 0 == 0)