Data.Deps

Documentation

newtype Deps a

Dependency map

Constructors

Deps

Fields

• _depsMap :: Map a [a]

Instances

Show a => Show (Deps a)

Methods

showsPrec :: Int -> Deps a -> ShowS

show :: Deps a -> String

showList :: [Deps a] -> ShowS

Ord a => Monoid (Deps a)

Methods

mempty :: Deps a

mappend :: Deps a -> Deps a -> Deps a

mconcat :: [Deps a] -> Deps a

Ord a => Ixed (Deps a)

Methods

ix :: Index (Deps a) -> Traversal' (Deps a) (IxValue (Deps a))

Ord a => At (Deps a)

Methods

at :: Index (Deps a) -> Lens' (Deps a) (Maybe (IxValue (Deps a)))

type Index (Deps a)

type Index (Deps a) = a

type IxValue (Deps a)

type IxValue (Deps a) = [a]

depsMap :: Lens (Deps a) (Deps b) (Map a [a]) (Map b [b])

mapDeps :: Ord b => (a -> b) -> Deps a -> Deps b

dep :: a -> a -> Deps a

Make single dependency

deps :: a -> [a] -> Deps a

Make dependency for one target, note that order of dependencies is matter

inverse :: Ord a => Deps a -> Deps a

Inverse dependencies, i.e. make map where keys are dependencies and elements are targets depends on it

newtype DepsError a

Constructors

CyclicDeps [a]

Dependency cycle, list is cycle, where last item depends on first

Instances

Eq a => Eq (DepsError a)

Methods

(==) :: DepsError a -> DepsError a -> Bool

(/=) :: DepsError a -> DepsError a -> Bool

Ord a => Ord (DepsError a)

Methods

compare :: DepsError a -> DepsError a -> Ordering

(<) :: DepsError a -> DepsError a -> Bool

(<=) :: DepsError a -> DepsError a -> Bool

(>) :: DepsError a -> DepsError a -> Bool

(>=) :: DepsError a -> DepsError a -> Bool

max :: DepsError a -> DepsError a -> DepsError a

min :: DepsError a -> DepsError a -> DepsError a

Read a => Read (DepsError a)

Methods

readsPrec :: Int -> ReadS (DepsError a)

readList :: ReadS [DepsError a]

readPrec :: ReadPrec (DepsError a)

readListPrec :: ReadPrec [DepsError a]

Show a => Show (DepsError a)

Methods

showsPrec :: Int -> DepsError a -> ShowS

show :: DepsError a -> String

showList :: [DepsError a] -> ShowS

flatten :: Ord a => Deps a -> Either (DepsError a) (Deps a)

Flatten dependencies so that there will be no indirect dependencies

selfDepend :: Deps a -> Deps a

linearize :: Ord a => Deps a -> Either (DepsError a) [a]

Linearize dependencies so that all items can be processed in this order, i.e. for each item all its dependencies goes before