Hacker News Reader

Comment by samthecoy | Hacker News Reader

Partial functions are not the same thing as "partially applied functions". Partial functions means that not every element of the domain is mapped to an element of the range, for example:

    divTenBy :: Double -> Double
    divTenBy n = 10 / n

If you actually call the above function you get a runtime exception. We really don't like functions that do this; they are called partial.

View on HN

Am I missing something subtle? Why would you get a runtime exception if you call this function?

The parent missed a part. If you call it with 0 you get an exception, because division by zero obviously.

No, you don't. You get Infinity. That's how floating point works.

In most languages you get an exception

Which languages would those be?

I guess I'm thinking of Python mostly. I thought OCaml did as well but apparently not.

  $ python3
  Python 3.9.1 (default, Feb  3 2021, 07:04:15)
  [Clang 12.0.0 (clang-1200.0.32.29)] on darwin
  Type "help", "copyright", "credits" or "license" for more information.
  >>> 10 / 0
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  ZeroDivisionError: division by zero
  >>>

Although Python seems to be the exception to the rule here, your example isn't exactly right. In your example, you're performing integer division, not floating point division. In most languages, integer division by zero is indeed some kind of exception (or UB, which will most likely result in a hardware exception, causing a signal sent to the process). However, floating point division by zero is well-defined, as per definition of floating point arithmetic (in some RFCs), and most languages don't throw exceptions in this case. Python indeed seems to be the exception to the rule.

In Python 3, 1/0 is floating point division. 1//0 would be integer division.

Right, Python2 is still the default on Debian, so I didn't notice.

If you call it with argument 0 you get a runtime exception, because it results in a division by zero.

It's "partial" because it's not defined for 0.

So it should have been: Double -> Maybe Double

That would be the "right way" to fix this.

(or create a type NotNilDouble, lol)

Or, controversially, define 1/0 = 0.[1]

[1]: https://www.hillelwayne.com/post/divide-by-zero/

Enough controversy in defining std libs as it is :)

The "right" way for division by zero is controversial, though maybe that would be a solution.

It's clearer for partial function "head :: [a] -> a", which takes the first of a list if it exists, and explodes without dignity if the list is empty (this is what makes head partial).

A proposal is "head :: [a] -> Maybe a", so head returns Nothing when the list is empty.

Idris does well here:

https://www.idris-lang.org/docs/current/prelude_doc/docs/Pre...'

Idris does well here:

https://www.idris-lang.org/docs/current/contrib_doc/docs/Dat...

If Double is IEEE 754 compatible then it should be perfectly defined for 0, you'd get +/- infinity. There are algorithms which rely on this.

Ah, so partial functions aren't onto (i.e. surjective).

No, they are not functions in the mathematical sense. It's not that they don't cover the output space, they don't cover the input space.

Not exactly, partial functions can be surjective, eg

f :: Int -> Bool

f 0 = True

f 1 = False

f n = f (n + 1)

is surjective onto Bool but also partial (doesn't return for n > 1). In Haskell we say that when a function doesn't return, the output is bottom, written as ⊥.

You could say that a function f : A -> B is partial if f^{-1}(B \ ⊥) is surjective.

Reply on news.ycombinator.com