Post by Frerich Raabe
What about functions like length? length (repeat ()) is bottom.
repeat () is not bottom. Ergo, length is partial.
This caught me by surprise - I would have never considered 'length'
to be a partial function! Maybe I don't quite understand what it
means for some expression to be 'bottom' (I thought that's the same
We have to be a bit careful with attributing blame for failure.
By David's argument, e.g. "fst" would also be "partial". Consider:
(_|_, _|_) /= _|_
fst (_|_, _|_) == _|_
But the bottom here does not originate in the computation of "fst" as
such, but in the computation of the *argument* to "fst".
Similarly for "length" above: "length" is not to blame for the
length (repeat ()) == _|_
It's simply that computation of the argument to length takes a very(!)
In a language with strict semantics, this is of course no surprise
at all, and I suspect no one would suggest that a function
like "length" is partial in a strict setting just because the
overall computation fails to terminate when the computation of
an argument does.
Post by Frerich Raabe
My naive understanding was that a partial function is one which has
no definition for certain arguments; in particular, it has no
definition which could be used while doing equational reasoning by
hand, on a piece of paper (i.e. without running the program).
It appears that this is not quite correct -- instead, any function
which fails to return anything (at runtime!) for certain arguments is
partial? E.g. 'sort' would be partial or even 'elem' (consider 'True
`elem` repeat False')?
I'd say neither "sort" nor "elem" is partial for the same reason.
As to the original suggestion of marking functions as partial, I think
that's fine, as long as one is careful to explain exactly what is meant.
(And documenting (different forms of) strictness would be fine too.)
But one should bear in mind that there are functions that are
partial for other reasons that pattern matching failure, in particular
numerical functions like division, square root, ...
(And the full story of floating point arithmetic with infinities
and NaNs etc. is of course quite complicated.)
Students (well, any programmer) should of course be aware that one have
to be extra careful when using partial functions, and certainly also
encouraged to seek alternative formulations, but just saying "Don't use
partial functions" is not the full story.
This message and any attachment are intended solely for the addressee
and may contain confidential information. If you have received this
message in error, please contact the sender and delete the email and
Any views or opinions expressed by the author of this email do not
necessarily reflect the views of the University of Nottingham. Email
communications with the University of Nottingham may be monitored
where permitted by law.