FRP.Yampa.Forceable

Deprecated: Use DeepSeq instead

Hyperstrict evaluation.

Documentation

class Forceable a where

A deep strict evalaution class.

Minimal complete definition

force

Methods

force :: a -> a

Evaluate completely.

Instances

Forceable Bool

Deep strict evaluation for Bool.

Methods

force :: Bool -> Bool

Forceable Char

Deep strict evaluation for Char.

Methods

force :: Char -> Char

Forceable Double

Deep strict evaluation for Double.

Methods

force :: Double -> Double

Forceable Float

Deep strict evaluation for Float.

Methods

force :: Float -> Float

Forceable Int

Deep strict evaluation for Int.

Methods

force :: Int -> Int

Forceable Integer

Deep strict evaluation for Integer.

Methods

force :: Integer -> Integer

Forceable ()

Deep strict evaluation for '()'.

Methods

force :: () -> ()

Forceable a => Forceable [a]

Deep strict evaluation for lists.

Methods

force :: [a] -> [a]

Forceable a => Forceable (Maybe a)

Deep strict evaluation for Maybe.

Methods

force :: Maybe a -> Maybe a

Forceable a => Forceable (Event a)

Forceable instance

Methods

force :: Event a -> Event a

RealFloat a => Forceable (Vector3 a)

Methods

force :: Vector3 a -> Vector3 a

RealFloat a => Forceable (Vector2 a)

Methods

force :: Vector2 a -> Vector2 a

RealFloat a => Forceable (Point3 a)

Methods

force :: Point3 a -> Point3 a

RealFloat a => Forceable (Point2 a)

Methods

force :: Point2 a -> Point2 a

(Forceable a, Forceable b) => Forceable (a, b)

Deep strict evaluation for pairs.

Methods

force :: (a, b) -> (a, b)

(Forceable a, Forceable b, Forceable c) => Forceable (a, b, c)

Deep strict evaluation for triples.

Methods

force :: (a, b, c) -> (a, b, c)

(Forceable a, Forceable b, Forceable c, Forceable d) => Forceable (a, b, c, d)

Deep strict evaluation for tuples of four elements.

Methods

force :: (a, b, c, d) -> (a, b, c, d)

(Forceable a, Forceable b, Forceable c, Forceable d, Forceable e) => Forceable (a, b, c, d, e)

Deep strict evaluation for tuples of five elements.

Methods

force :: (a, b, c, d, e) -> (a, b, c, d, e)