Data.Lazify

Record types in Haskell can be made lazy through lazy pattern matching. This module offers functions for making them lazy generically.

Documentation

class Lazifiable a where

A class for types that can be lazified. A generic default is provided for convenience. To lazify a type using its generic representation, use genericLazify.

Methods

lazify :: a -> a

Lazily rewrap a record. Applying lazify to a record and then pattern matching on it strictly is equivalent to pattern matching on it lazily.

strictFirst :: (a -> a') -> (a, b) -> (a', b)
strictFirst f (a, b) = (f a, b)

lazyFirst :: (a -> a') -> (a, b) -> (a', b)
lazyFirst f = strictFirst f . lazify
-- Equivalently
lazyFirst f ~(a, b) = (f a, b)

lazify :: (Generic a, GLazifiable (Rep a)) => a -> a

Lazily rewrap a record. Applying lazify to a record and then pattern matching on it strictly is equivalent to pattern matching on it lazily.

strictFirst :: (a -> a') -> (a, b) -> (a', b)
strictFirst f (a, b) = (f a, b)

lazyFirst :: (a -> a') -> (a, b) -> (a', b)
lazyFirst f = strictFirst f . lazify
-- Equivalently
lazyFirst f ~(a, b) = (f a, b)

Instances

Lazifiable ()

Methods

lazify :: () -> ()

Lazifiable a => Lazifiable (Min a)

Methods

lazify :: Min a -> Min a

Lazifiable a => Lazifiable (Max a)

Methods

lazify :: Max a -> Max a

Lazifiable a => Lazifiable (First a)

Methods

lazify :: First a -> First a

Lazifiable a => Lazifiable (Last a)

Methods

lazify :: Last a -> Last a

Lazifiable a => Lazifiable (Identity a)

Methods

lazify :: Identity a -> Identity a

Lazifiable a => Lazifiable (Sum a)

Methods

lazify :: Sum a -> Sum a

Lazifiable a => Lazifiable (Product a)

Methods

lazify :: Product a -> Product a

Typeable k a => Lazifiable (TypeRep k a)

Methods

lazify :: TypeRep k a -> TypeRep k a

Lazifiable (a, b)

Methods

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

Lazifiable (Arg a b)

Methods

lazify :: Arg a b -> Arg a b

Lazifiable (Proxy k a)

Methods

lazify :: Proxy k a -> Proxy k a

Lazifiable (a, b, c)

Methods

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

Lazifiable a => Lazifiable (Const k a b)

Methods

lazify :: Const k a b -> Const k a b

Lazifiable (f a) => Lazifiable (Alt k f a)

Methods

lazify :: Alt k f a -> Alt k f a

Coercible k a b => Lazifiable (Coercion k a b)

Methods

lazify :: Coercion k a b -> Coercion k a b

(~) k a b => Lazifiable ((:~:) k a b)

Methods

lazify :: (k :~: a) b -> (k :~: a) b

Lazifiable (a, b, c, d)

Methods

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

Lazifiable (Product k f g a)

Methods

lazify :: Product k f g a -> Product k f g a

(~~) k1 k2 a b => Lazifiable ((:~~:) k1 k2 a b)

Methods

lazify :: (k1 :~~: k2) a b -> (k1 :~~: k2) a b

Lazifiable (a, b, c, d, e)

Methods

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

Lazifiable (f (g a)) => Lazifiable (Compose k k1 f g a)

Methods

lazify :: Compose k k1 f g a -> Compose k k1 f g a

Lazifiable (a, b, c, d, e, f)

Methods

lazify :: (a, b, c, d, e, f) -> (a, b, c, d, e, f)

Lazifiable (a, b, c, d, e, f, g)

Methods

lazify :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

Lazifiable (a, b, c, d, e, f, g, h)

Methods

lazify :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h)

Lazifiable (a, b, c, d, e, f, g, h, i)

Methods

lazify :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i)

Lazifiable (a, b, c, d, e, f, g, h, i, j)

Methods

lazify :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j)

genericLazify :: (Generic a, GLazifiable (Rep a)) => a -> a

Lazify a record using its generic representation.

Note that newtypes are treated specially: a newtype is lazified by lazifying its underlying type using its Lazifiable instance.

($~) :: forall rep a (b :: TYPE rep). Lazifiable a => (a -> b) -> a -> b

Apply a function to a lazified value.