Data.Dynamic

base-4.10.1.0: Basic libraries

Copyright | (c) The University of Glasgow 2001
License | BSD-style (see the file libraries/base/LICENSE)
Maintainer | libraries@haskell.org
Stability | experimental
Portability | portable
Safe Haskell | Trustworthy
Language | Haskell2010

Data.Dynamic

Contents

- The `Dynamic` type
- Converting to and from `Dynamic`
- Applying functions of dynamic type
- Convenience re-exports

Description

The Dynamic interface provides basic support for dynamic types.

Operations for injecting values of arbitrary type into a dynamically typed value, Dynamic, are provided, together with operations for converting dynamic values into a concrete (monomorphic) type.

Synopsis

- data Dynamic where
  - Dynamic :: forall a. TypeRep a -> a -> Dynamic
- toDyn :: Typeable a => a -> Dynamic
- fromDyn :: Typeable a => Dynamic -> a -> a
- fromDynamic :: forall a. Typeable a => Dynamic -> Maybe a
- dynApply :: Dynamic -> Dynamic -> Maybe Dynamic
- dynApp :: Dynamic -> Dynamic -> Dynamic
- dynTypeRep :: Dynamic -> SomeTypeRep
- class Typeable (a :: k)

# The `Dynamic` type

data Dynamic where Source #

A value of type `Dynamic` is an object encapsulated together with its type.

A `Dynamic` may only represent a monomorphic value; an attempt to create a value of type `Dynamic` from a polymorphically-typed expression will result in an ambiguity error (see `toDyn`).

`Show`ing a value of type `Dynamic` returns a pretty-printed representation of the object's type; useful for debugging.

Constructors

Dynamic :: forall a. TypeRep a -> a -> Dynamic |

Instances

Show Dynamic # | Since: 2.1
Methods showsPrec :: Int -> Dynamic -> ShowS Source # show :: Dynamic -> String Source # showList :: [Dynamic] -> ShowS Source #
Exception Dynamic # | Since: 4.0.0.0
Methods toException :: Dynamic -> SomeException Source # fromException :: SomeException -> Maybe Dynamic Source # displayException :: Dynamic -> String Source #

# Converting to and from `Dynamic`

toDyn :: Typeable a => a -> Dynamic Source #

Converts an arbitrary value into an object of type `Dynamic`.

The type of the object must be an instance of `Typeable`, which ensures that only monomorphically-typed objects may be converted to `Dynamic`. To convert a polymorphic object into `Dynamic`, give it a monomorphic type signature. For example:

       toDyn (id :: Int -> Int)

fromDyn Source #

Arguments

:: Typeable a |
=> Dynamic | the dynamically-typed object
-> a | a default value
-> a | returns: the value of the first argument, if it has the correct type, otherwise the value of the second argument.

Converts a `Dynamic` object back into an ordinary Haskell value of the correct type. See also `fromDynamic`.

fromDynamic Source #

Arguments

:: Typeable a |
=> Dynamic | the dynamically-typed object
-> Maybe a | returns: ``Just` a`, if the dynamically-typed object has the correct type (and `a` is its value), or `Nothing` otherwise.

Converts a `Dynamic` object back into an ordinary Haskell value of the correct type. See also `fromDyn`.

# Applying functions of dynamic type

dynApply :: Dynamic -> Dynamic -> Maybe Dynamic Source #

dynApp :: Dynamic -> Dynamic -> Dynamic Source #

dynTypeRep :: Dynamic -> SomeTypeRep Source #

# Convenience re-exports

class Typeable (a :: k) Source #

The class `Typeable` allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#