Safe Haskell | None |
---|

Reimplementation of Dynamic that supports dynBind

We don't have access to the internal representation of Dynamic, otherwise we would not have to redefine it completely. Note that we use this only internally, so the incompatibility with our Dynamic from the standard Dynamic is not important.

- data Dynamic = Dynamic TypeRep Any
- toDyn :: Typeable a => a -> Dynamic
- fromDyn :: Typeable a => Dynamic -> a -> a
- fromDynamic :: forall a. Typeable a => Dynamic -> Maybe a
- dynTypeRep :: Dynamic -> TypeRep
- dynApply :: Dynamic -> Dynamic -> Maybe Dynamic
- dynApp :: Dynamic -> Dynamic -> Dynamic
- dynBind :: TyCon -> (forall a b. m a -> (a -> m b) -> m b) -> Dynamic -> Dynamic -> Maybe Dynamic
- dynBind' :: TyCon -> (forall a b. m a -> (a -> m b) -> m b) -> Dynamic -> Dynamic -> Dynamic
- dynKleisli :: TyCon -> (forall a b c. (a -> m b) -> (b -> m c) -> a -> m c) -> Dynamic -> Dynamic -> Maybe Dynamic
- unsafeCoerce# :: a -> b

# Documentation

fromDynamic :: forall a. Typeable a => Dynamic -> Maybe aSource

dynTypeRep :: Dynamic -> TypeRepSource

dynBind :: TyCon -> (forall a b. m a -> (a -> m b) -> m b) -> Dynamic -> Dynamic -> Maybe DynamicSource

dynKleisli :: TyCon -> (forall a b c. (a -> m b) -> (b -> m c) -> a -> m c) -> Dynamic -> Dynamic -> Maybe DynamicSource

Dynamically typed Kleisli composition

unsafeCoerce# :: a -> b

The function `unsafeCoerce#`

allows you to side-step the typechecker entirely. That
is, it allows you to coerce any type into any other type. If you use this function,
you had better get it right, otherwise segmentation faults await. It is generally
used when you want to write a program that you know is well-typed, but where Haskell's
type system is not expressive enough to prove that it is well typed.

The following uses of `unsafeCoerce#`

are supposed to work (i.e. not lead to
spurious compile-time or run-time crashes):

- Casting any lifted type to
`Any`

- Casting
`Any`

back to the real type - Casting an unboxed type to another unboxed type of the same size (but not coercions between floating-point and integral types)
- Casting between two types that have the same runtime representation. One case is when
the two types differ only in "phantom" type parameters, for example
`Ptr Int`

to`Ptr Float`

, or`[Int]`

to`[Float]`

when the list is known to be empty. Also, a`newtype`

of a type`T`

has the same representation at runtime as`T`

.

Other uses of `unsafeCoerce#`

are undefined. In particular, you should not use
`unsafeCoerce#`

to cast a T to an algebraic data type D, unless T is also
an algebraic data type. For example, do not cast `Int->Int`

to `Bool`

, even if
you later cast that `Bool`

back to `Int->Int`

before applying it. The reasons
have to do with GHC's internal representation details (for the congnoscenti, data values
can be entered but function closures cannot). If you want a safe type to cast things
to, use `Any`

, which is not an algebraic data type.