Polishing the boilerplate: a dis-unsafely safe cast

[Hal Daume III]

This is getting off-topic, but...

I don't like this solution at all :).  It is very dependent on read being
a true inverse of show, which isn't always the case.  Perhaps more
importantly though, I don't like the fact that it will readily convert
between Int and Float, etc.  For instance, in almost all of my
applications I use something that looks like:

> newtype Log = Log !Double

where 'show (Log d) = show (exp l)' and 'read s = Log (log (read s))'.  If
I wanted to have a function applied to only Logs, having it also applied
to Floats/Doubles/etc because of the show/read connection would be very
bad and would require me to wrap things up in more and more constructors
just to get unique show instances.

Not to mention that it's terribly inefficient.

If our concern is to stay within a standard subset of Haskell, using
H98+FFI, we get unsafePerformIO with which we can write
unsafeCoerce.  Using simply String ids as in the referenced paper would
make this sort-of-safe, provided users don't give bogus instances of
Typeable.

--
 Hal Daume III                                   | hdaume@isi.edu
 "Arrest this man, he talks in maths."           | www.isi.edu/~hdaume

On Mon, 24 Mar 2003 oleg@pobox.com wrote:

> 
> Hello!
> 
> 	The paper
> 	http://research.microsoft.com/~simonpj/papers/hmap/
> by Ralf Laemmel and Simon Peyton Jones gave a reference
> implementation of a 'cast' function. Here's another implementation:
> 
> cast:: (Show a, Read b) => a -> Maybe b
> 
> cast = read_as . show
>  where
>    read_as s = case readsPrec 1 s of
>                 [(r,[])] -> Just r
> 		_        -> Nothing
> 		
>    
> -- Tests from the hmap paper
> 
> -- *Main> (cast 'a') :: Maybe Char
> -- Just 'a'
> -- *Main> (cast 'a') :: Maybe Int 
> -- Nothing
> -- *Main> (cast 'a') :: Maybe Bool
> -- Nothing
> -- *Main> (cast True) :: Maybe Bool
> -- Just True
> -- *Main> (cast "True") :: Maybe Bool
> -- Nothing
> -- *Main> (cast "True") :: Maybe Int 
> -- Nothing
> -- *Main> (cast "True") :: Maybe String
> -- Just "True"
> 
> -- Additional tests
> 
> -- *Main> (cast [1,2,3])::Maybe [Int]
> -- Just [1,2,3]
> -- *Main> (cast [1,2,3])::Maybe [Integer]
> -- Just [1,2,3]
> -- *Main> (cast [1,2,3])::Maybe [Float]
> -- Just [1.0,2.0,3.0]
> -- *Main> (cast (Just True)) :: Maybe Int
> -- Nothing
> -- *Main> (cast (Just True)) :: Maybe (Maybe Bool)
> -- Just (Just True)
> -- *Main> (cast (Nothing::Maybe Bool)) :: Maybe (Maybe Bool)
> -- Just Nothing
> -- *Main> (cast (Nothing::Maybe Bool)) :: Maybe (Maybe Int)
> -- Just Nothing
> -- *Main> (cast (Nothing::Maybe Bool)) :: Maybe (Maybe Char)
> -- Just Nothing
> 
> 
> Granted, the cast function here cannot handle exponential types. OTH,
> the cast function given here can cast an Int to an Integer or to a Float. Most
> of all, the cast function here is implemented entirely in Haskell 98,
> with no extensions whatsoever -- not existential types, let alone
> unsafeCoerce.
> 
> 
> An aside: OCaml has a function called Obj.magic: 'a -> 'b,
> which is unsafeCoerce with a positive name. If OCaml did not provide
> that function, it can be easily emulated:
> 
> # let door_to_hell x =
>      Marshal.from_string (Marshal.to_string () []) 0;;
> val door_to_hell : 'a -> 'b = <fun>
> 
> This is a terminating function with a signature a->b. It critically
> relies on marshalling and unmarshalling. BTW, the function breaks all
> kinds of free theorems:
> 
> #  let (fake_id: 'a->'a) = function x -> door_to_hell x;;
> val fake_id : 'a -> 'a = <fun>
> # fake_id 123;;
> - : int = 0
> 
> We can write a totally polymorphic terminating function a->a that is
> patently not the identity.
> _______________________________________________
> Haskell mailing list
> Haskell@haskell.org
> http://www.haskell.org/mailman/listinfo/haskell
>