:: Int -> Float -package:LambdaHack -package:combinatorial package:rebase
Highly, terribly dangerous coercion from one representation type to
another. Misuse of this function can invite the garbage collector to
trounce upon your data and then laugh in your face. You don't want
this function. Really.
Coerce a value from one type to another, bypassing the type-checker.
There are several legitimate ways to use
unsafeCoerce:
- To coerce e.g. Int to HValue, put it in a list
of HValue, and then later coerce it back to Int
before using it.
- To produce e.g. (a+b) :~: (b+a) from unsafeCoerce
Refl. Here the two sides really are the same type -- so nothing
unsafe is happening -- but GHC is not clever enough to see it.
- In Data.Typeable we have
eqTypeRep :: forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -> TypeRep b -> Maybe (a :~~: b)
eqTypeRep a b
| sameTypeRep a b = Just (unsafeCoerce HRefl)
| otherwise = Nothing
Here again, the
unsafeCoerce HRefl is safe, because the two
types really are the same -- but the proof of that relies on the
complex, trusted implementation of
Typeable.
- The "reflection trick", which takes advantage of the fact that in
class C a where { op :: ty }, we can safely coerce between
C a and ty (which have different kinds!) because
it's really just a newtype. Note: there is no guarantee, at all
that this behavior will be supported into perpetuity.
For safe zero-cost coercions you can instead use the
coerce
function from
Data.Coerce.