encodeURIComponent can explode.

[damncabbage]

encodeURIComponent is encoded as String -> String.

This is a counter-example to that type:

> encodeURIComponent( [737,58851,43953,5591,56687,47584,10580,64494].map(function(x) { return String.fromCharCode(x); }).join("") );
URIError: malformed URI sequence

I'd argue it should be String -> Maybe String, to account for the possibility of the exception, with an Unsafe twin that pretends String -> String is accurate (like with Regex vs Regex.Unsafe).

(I came across this while generating strings with String.fromCharArray <<< Jack.boundedChar; boundedChar is defined here, but is basically any character.)

[garyb]

Everything in globals would appear to be highly janky. 😭

Making the result Maybe sounds like a sensible fix.

[paf31]

But then we'd have to add a dependency on maybe.

[garyb]

Oh right, it's currently dependency-less. Any other ideas? Church-encoded maybe callback? (... but... ew).

[paf31]

Could just mark it as Partial perhaps.

[chexxor]

How to use the Partial version?

let x = unsafePartial $ encodeURIComponent (fromCharCode 56687)

We would need to add docs to that function, then, to indicate that the input string needs to be checked that it is a valid URI component string before removing the Partial constraint with unsafePartial. We would need to write a function which performs the exact same validations performed by the encodeURIComponent function itself, like isValidURIString :: String -> Boolean. Those validations are documented in ES2015 spec: URI Handling Function Properties

From the ES2015 spec, one reason it would throws URIError is if input characters are out of bounds.

"If the code unit value of C is not less than 0xDC00 and not greater than 0xDFFF, throw a URIError exception"

Another option is to use callbacks to avoid the dependency on Maybe: 😆

encodeURIComponent :: String -> (Error -> Unit) -> (String -> Unit)

[damncabbage]

I'd honestly take the Maybe dependency over the Partial, Church or String -> (Error -> a) -> (String -> a) -> a versions. :(

[chexxor]

Can we take a dependency on purescript-exception? We could do

foreign import decodeURIComponent :: forall e.
  String -> Eff (exception :: EXCEPTION | e) String

[safareli]

I just came here for opening this issue :D

We can depend on purescript-control (which depends on purescript-prelude only) and use Alternative:

decodeURIComponent :: forall f. Alternative f => String -> f String
decodeURIComponent = decodeURIComponent' empty pure

foreign import decodeURIComponent' :: forall a. a -> (String -> a) ->  String -> a

[safareli]

This way we can also fix #5 too.

[safareli]

also note that all this URI functions could exploded:

foreign import decodeURI :: String -> String
foreign import encodeURI :: String -> String
foreign import decodeURIComponent :: String -> String
foreign import encodeURIComponent :: String -> String

We can move them to Global.Unsafe at least, if we don't want dependence even on ps-control

[paf31]

Please let's not use Alternative though.

[safareli]

Please let's not use Alternative though.

@paf31 can you explain Why Alternative is not desired?

so you prefer to move them to unsafe?

[paf31]

I know some people like to turn Maybes into Alternatives in their APIs, and I just don't like it. It adds a dictionary overhead where isn't not needed, since you're not adding any expressivity (the Maybe to Alternative function is already packaged up as oneOf). It also makes the types harder to read, because it's not clear if you're going to be returning multiple results via Alternative.

[garyb]

For now I've moved them to Global.Unsafe with a warning about them throwing URIError.