Should Purescript's Partial instead be called Unsafe?

Purescript's Partial typeclass is an interesting thing, but you may be wondering where the forall a. ((Partial => a) -> Maybe a) lurks?

Partiality of partial functions are thought to be observable. We think that partial function a → b can be written as (a → Maybe b) Purescript's partial functions aren't observable in this way though, they may become preconditions that aren't encoded in the type at the moment. For example, unsafeIndex is allowed to return Javascript's undefined if it accesses outside the index.

unsafeIndex :: forall a. Partial => Array a -> Int -> a

The Partial here is less of Maybe and more of a warning: It may blow on your face. If you want to catch it, just use the index instead.

Perhaps if we just checked the unsafety, we could use Javascript's exception mechanism to catch Maybe like TheMatten proposed. But then it'd be similar to using the index in the first place then.

Lot of the names here are like crash, unsafe this and that. Should Partial have been named Unsafe? Well there's a likely reason why it wasn't. Although it would be the exact correct definition, it could be confused to Haskell's most common way to be labeled unsafe which is performing I/O, rather than breaking the type system.

Should the Partial be renamed to Unsafe immediately then? Nope. The main thing would be, do you expect it to matter that it has that name, once you've been explained that it means for more of an unsafe implementation-leaking partial function rather than a nice mathematical partial function.

It matters if there would be a feature that would prefer reassigning the name Partial to the more nice mathematical partial functions. But it might not matter if Partial functions become more partial and allow their partiality to be observed in the future.

Typeclass assisted transformations to whole programs

There's an one potential feature that might interfere, explained by Conal Elliott in his "Compiling to categories" paper. It allows giving functional programs varying interpretations by transforming from an one category to an another.

You see, category can enclose ideas such as pairs, being a function or what a natural number is. These notions can be transformed into a different category while preserving their overall structure. In the paper Conal proposes how to overload concepts such as a function or a pair, in order to vary interpretation of programs and then make them, for instance, compute incrementally or differentiate an arbitrary function.

One of the potential "categorical transforms" to a program, is the interpretation of partially defined functions as morphisms in a Kleisli category of the Maybe -monad. Because of thoughts like this I've been associating mathematical functions to (a → Maybe b) quite strongly. I was very surprised to see that Purescript's Partial weren't the partial that I expected.

How likely is it that Purescript's compiler would implement Conal's paper? Well one obstacle is that Purescript is doing this thing of constructing Javascript modules, and you can use these modules as long as there is a boundary that only gives you the type and doesn't require you to identify which program is inside the module. These kind of program transformations do force you to identify the program. But you can achieve that by just keeping the modules there but sidestepping them when they need to be provided explicitly.

How about the problem of Purescript's Partiality being inobservable? You've probably heard Javascript's JIT is pretty amazing and one really neat thing there are the fast guard clauses that do cost very little if they pass. There are several ways how this might resolve.

TL;DR: It probably should be called Unsafe, but there are problems in that approach as well, and it's likely good for now as long as you know what kind of Partial is being meant here.