Nix.Thunk

Documentation

data Deferred m v

Constructors

Deferred (m v)

Computed v

Instances

Functor m => Functor (Deferred m)

Methods

fmap :: (a -> b) -> Deferred m a -> Deferred m b

(<$) :: a -> Deferred m b -> Deferred m a

Foldable m => Foldable (Deferred m)

Methods

fold :: Monoid m => Deferred m m -> m

foldMap :: Monoid m => (a -> m) -> Deferred m a -> m

foldr :: (a -> b -> b) -> b -> Deferred m a -> b

foldr' :: (a -> b -> b) -> b -> Deferred m a -> b

foldl :: (b -> a -> b) -> b -> Deferred m a -> b

foldl' :: (b -> a -> b) -> b -> Deferred m a -> b

foldr1 :: (a -> a -> a) -> Deferred m a -> a

foldl1 :: (a -> a -> a) -> Deferred m a -> a

toList :: Deferred m a -> [a]

null :: Deferred m a -> Bool

length :: Deferred m a -> Int

elem :: Eq a => a -> Deferred m a -> Bool

maximum :: Ord a => Deferred m a -> a

minimum :: Ord a => Deferred m a -> a

sum :: Num a => Deferred m a -> a

product :: Num a => Deferred m a -> a

Traversable m => Traversable (Deferred m)

Methods

traverse :: Applicative f => (a -> f b) -> Deferred m a -> f (Deferred m b)

sequenceA :: Applicative f => Deferred m (f a) -> f (Deferred m a)

mapM :: Monad m => (a -> m b) -> Deferred m a -> m (Deferred m b)

sequence :: Monad m => Deferred m (m a) -> m (Deferred m a)

class Monad m => MonadVar m where

Minimal complete definition

newVar, readVar, writeVar, atomicModifyVar

Associated Types

type Var m :: * -> *

Methods

newVar :: a -> m (Var m a)

readVar :: Var m a -> m a

writeVar :: Var m a -> a -> m ()

atomicModifyVar :: Var m a -> (a -> (a, b)) -> m b

Instances

MonadVar (Lint s)

Associated Types

type Var (Lint s :: * -> *) :: * -> *

Methods

newVar :: a -> Lint s (Var (Lint s) a)

readVar :: Var (Lint s) a -> Lint s a

writeVar :: Var (Lint s) a -> a -> Lint s ()

atomicModifyVar :: Var (Lint s) a -> (a -> (a, b)) -> Lint s b

MonadIO m => MonadVar (Lazy m)

Associated Types

type Var (Lazy m :: * -> *) :: * -> *

Methods

newVar :: a -> Lazy m (Var (Lazy m) a)

readVar :: Var (Lazy m) a -> Lazy m a

writeVar :: Var (Lazy m) a -> a -> Lazy m ()

atomicModifyVar :: Var (Lazy m) a -> (a -> (a, b)) -> Lazy m b

class Monad m => MonadThunk v t m | v -> m, v -> t, t -> m, t -> v where

Minimal complete definition

thunk, force, value

Methods

thunk :: m v -> m t

force :: t -> (v -> m r) -> m r

value :: v -> t

Instances

MonadLint e m => MonadThunk (Symbolic m) (SThunk m) m

Methods

thunk :: m (Symbolic m) -> m (SThunk m)

force :: SThunk m -> (Symbolic m -> m r) -> m r

value :: Symbolic m -> SThunk m

data Thunk m v

Constructors

Value v

Thunk Int (Var m Bool) (Var m (Deferred m v))

newtype ThunkLoop

Constructors

ThunkLoop (Maybe Int)

Instances

Show ThunkLoop

Methods

showsPrec :: Int -> ThunkLoop -> ShowS

show :: ThunkLoop -> String

showList :: [ThunkLoop] -> ShowS

Exception ThunkLoop

Methods

toException :: ThunkLoop -> SomeException

fromException :: SomeException -> Maybe ThunkLoop

displayException :: ThunkLoop -> String

valueRef :: v -> Thunk m v

buildThunk :: MonadVar m => m v -> m (Thunk m v)

forceThunk :: (MonadVar m, MonadThrow m) => Thunk m v -> (v -> m a) -> m a

forceEffects :: MonadVar m => Thunk m v -> (v -> m a) -> m a