-- |
-- SPDX-License-Identifier: BSD-3-Clause
--
-- A requirement is something that is needed in order to successfully
-- build a robot running a certain program.
module Swarm.Language.Requirements.Type (
  -- * Requirements

  -- ** The 'Requirement' type
  Requirement (..),

  -- ** The 'Requirements' type and utility functions
  Requirements (..),
  singleton,
  singletonCap,
  singletonDev,
  singletonInv,
  insert,
  ReqCtx,
) where

import Data.Aeson (FromJSON, ToJSON)
import Data.Data (Data)
import Data.Hashable (Hashable)
import Data.Map (Map)
import Data.Map qualified as M
import Data.Set (Set)
import Data.Set qualified as S
import Data.Text (Text)
import GHC.Generics (Generic)
import Swarm.Language.Capability (Capability (..))
import Swarm.Language.Context (Ctx)
import Swarm.Language.Var

-- | A /requirement/ is something a robot must have when it is
--   built. There are three types:
--   - A robot can require a certain 'Capability', which should be fulfilled
--     by equipping an appropriate device.
--   - A robot can require a specific /device/, which should be equipped.
--   - A robot can stock some number of a specific entity in its inventory.
data Requirement
  = -- | Require a specific capability.  This must be fulfilled by
    --   equipping an appropriate device.  Requiring the same
    --   capability multiple times is the same as requiring it once.
    ReqCap Capability
  | -- | Require a specific device to be equipped.  Note that at this
    --   point it is only a name, and has not been resolved to an actual
    --   'Swarm.Game.Entity.Entity'.  That's because programs have to be type- and
    --   capability-checked independent of an 'Swarm.Game.Entity.EntityMap'.  The name
    --   will be looked up at runtime, when actually executing a 'Swarm.Language.Syntax.Build'
    --   or 'Swarm.Language.Syntax.Reprogram' command, and an appropriate exception thrown if
    --   a device with the given name does not exist.
    --
    --   Requiring the same device multiple times is the same as
    --   requiring it once.
    ReqDev Text
  | -- | Stock a certain number of a specific entity to be available
    --   in the inventory.  The same comments apply re: resolving the
    --   entity name to an actual 'Swarm.Game.Entity.Entity'.
    --
    --   Inventory requirements are additive, that is, say, requiring 5
    --   of entity @"e"@ and later requiring 7 is the same as requiring
    --   12.
    ReqInv Int Text
  deriving (Requirement -> Requirement -> Bool
(Requirement -> Requirement -> Bool)
-> (Requirement -> Requirement -> Bool) -> Eq Requirement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Requirement -> Requirement -> Bool
== :: Requirement -> Requirement -> Bool
$c/= :: Requirement -> Requirement -> Bool
/= :: Requirement -> Requirement -> Bool
Eq, Eq Requirement
Eq Requirement =>
(Requirement -> Requirement -> Ordering)
-> (Requirement -> Requirement -> Bool)
-> (Requirement -> Requirement -> Bool)
-> (Requirement -> Requirement -> Bool)
-> (Requirement -> Requirement -> Bool)
-> (Requirement -> Requirement -> Requirement)
-> (Requirement -> Requirement -> Requirement)
-> Ord Requirement
Requirement -> Requirement -> Bool
Requirement -> Requirement -> Ordering
Requirement -> Requirement -> Requirement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Requirement -> Requirement -> Ordering
compare :: Requirement -> Requirement -> Ordering
$c< :: Requirement -> Requirement -> Bool
< :: Requirement -> Requirement -> Bool
$c<= :: Requirement -> Requirement -> Bool
<= :: Requirement -> Requirement -> Bool
$c> :: Requirement -> Requirement -> Bool
> :: Requirement -> Requirement -> Bool
$c>= :: Requirement -> Requirement -> Bool
>= :: Requirement -> Requirement -> Bool
$cmax :: Requirement -> Requirement -> Requirement
max :: Requirement -> Requirement -> Requirement
$cmin :: Requirement -> Requirement -> Requirement
min :: Requirement -> Requirement -> Requirement
Ord, Int -> Requirement -> ShowS
[Requirement] -> ShowS
Requirement -> String
(Int -> Requirement -> ShowS)
-> (Requirement -> String)
-> ([Requirement] -> ShowS)
-> Show Requirement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Requirement -> ShowS
showsPrec :: Int -> Requirement -> ShowS
$cshow :: Requirement -> String
show :: Requirement -> String
$cshowList :: [Requirement] -> ShowS
showList :: [Requirement] -> ShowS
Show, (forall x. Requirement -> Rep Requirement x)
-> (forall x. Rep Requirement x -> Requirement)
-> Generic Requirement
forall x. Rep Requirement x -> Requirement
forall x. Requirement -> Rep Requirement x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Requirement -> Rep Requirement x
from :: forall x. Requirement -> Rep Requirement x
$cto :: forall x. Rep Requirement x -> Requirement
to :: forall x. Rep Requirement x -> Requirement
Generic, Eq Requirement
Eq Requirement =>
(Int -> Requirement -> Int)
-> (Requirement -> Int) -> Hashable Requirement
Int -> Requirement -> Int
Requirement -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Requirement -> Int
hashWithSalt :: Int -> Requirement -> Int
$chash :: Requirement -> Int
hash :: Requirement -> Int
Hashable, Typeable Requirement
Typeable Requirement =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Requirement -> c Requirement)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Requirement)
-> (Requirement -> Constr)
-> (Requirement -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Requirement))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Requirement))
-> ((forall b. Data b => b -> b) -> Requirement -> Requirement)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Requirement -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Requirement -> r)
-> (forall u. (forall d. Data d => d -> u) -> Requirement -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Requirement -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Requirement -> m Requirement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Requirement -> m Requirement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Requirement -> m Requirement)
-> Data Requirement
Requirement -> Constr
Requirement -> DataType
(forall b. Data b => b -> b) -> Requirement -> Requirement
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Requirement -> u
forall u. (forall d. Data d => d -> u) -> Requirement -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Requirement -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Requirement -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Requirement -> m Requirement
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Requirement -> m Requirement
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Requirement
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Requirement -> c Requirement
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Requirement)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Requirement)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Requirement -> c Requirement
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Requirement -> c Requirement
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Requirement
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Requirement
$ctoConstr :: Requirement -> Constr
toConstr :: Requirement -> Constr
$cdataTypeOf :: Requirement -> DataType
dataTypeOf :: Requirement -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Requirement)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Requirement)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Requirement)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Requirement)
$cgmapT :: (forall b. Data b => b -> b) -> Requirement -> Requirement
gmapT :: (forall b. Data b => b -> b) -> Requirement -> Requirement
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Requirement -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Requirement -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Requirement -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Requirement -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Requirement -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Requirement -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Requirement -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Requirement -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Requirement -> m Requirement
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Requirement -> m Requirement
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Requirement -> m Requirement
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Requirement -> m Requirement
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Requirement -> m Requirement
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Requirement -> m Requirement
Data, Maybe Requirement
Value -> Parser [Requirement]
Value -> Parser Requirement
(Value -> Parser Requirement)
-> (Value -> Parser [Requirement])
-> Maybe Requirement
-> FromJSON Requirement
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Requirement
parseJSON :: Value -> Parser Requirement
$cparseJSONList :: Value -> Parser [Requirement]
parseJSONList :: Value -> Parser [Requirement]
$comittedField :: Maybe Requirement
omittedField :: Maybe Requirement
FromJSON, [Requirement] -> Value
[Requirement] -> Encoding
Requirement -> Bool
Requirement -> Value
Requirement -> Encoding
(Requirement -> Value)
-> (Requirement -> Encoding)
-> ([Requirement] -> Value)
-> ([Requirement] -> Encoding)
-> (Requirement -> Bool)
-> ToJSON Requirement
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Requirement -> Value
toJSON :: Requirement -> Value
$ctoEncoding :: Requirement -> Encoding
toEncoding :: Requirement -> Encoding
$ctoJSONList :: [Requirement] -> Value
toJSONList :: [Requirement] -> Value
$ctoEncodingList :: [Requirement] -> Encoding
toEncodingList :: [Requirement] -> Encoding
$comitField :: Requirement -> Bool
omitField :: Requirement -> Bool
ToJSON)

-- | It is tempting to define @Requirements = Set Requirement@, but
--   that would be wrong, since two identical 'ReqInv' should have
--   their counts added rather than simply being deduplicated.
--
--   Since we will eventually need to deal with the different types of
--   requirements separately, it makes sense to store them separately
--   anyway.
data Requirements = Requirements
  { Requirements -> Set Capability
capReqs :: Set Capability
  , Requirements -> Set Text
devReqs :: Set Text
  , Requirements -> Map Text Int
invReqs :: Map Text Int
  }
  deriving (Requirements -> Requirements -> Bool
(Requirements -> Requirements -> Bool)
-> (Requirements -> Requirements -> Bool) -> Eq Requirements
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Requirements -> Requirements -> Bool
== :: Requirements -> Requirements -> Bool
$c/= :: Requirements -> Requirements -> Bool
/= :: Requirements -> Requirements -> Bool
Eq, Eq Requirements
Eq Requirements =>
(Requirements -> Requirements -> Ordering)
-> (Requirements -> Requirements -> Bool)
-> (Requirements -> Requirements -> Bool)
-> (Requirements -> Requirements -> Bool)
-> (Requirements -> Requirements -> Bool)
-> (Requirements -> Requirements -> Requirements)
-> (Requirements -> Requirements -> Requirements)
-> Ord Requirements
Requirements -> Requirements -> Bool
Requirements -> Requirements -> Ordering
Requirements -> Requirements -> Requirements
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Requirements -> Requirements -> Ordering
compare :: Requirements -> Requirements -> Ordering
$c< :: Requirements -> Requirements -> Bool
< :: Requirements -> Requirements -> Bool
$c<= :: Requirements -> Requirements -> Bool
<= :: Requirements -> Requirements -> Bool
$c> :: Requirements -> Requirements -> Bool
> :: Requirements -> Requirements -> Bool
$c>= :: Requirements -> Requirements -> Bool
>= :: Requirements -> Requirements -> Bool
$cmax :: Requirements -> Requirements -> Requirements
max :: Requirements -> Requirements -> Requirements
$cmin :: Requirements -> Requirements -> Requirements
min :: Requirements -> Requirements -> Requirements
Ord, Int -> Requirements -> ShowS
[Requirements] -> ShowS
Requirements -> String
(Int -> Requirements -> ShowS)
-> (Requirements -> String)
-> ([Requirements] -> ShowS)
-> Show Requirements
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Requirements -> ShowS
showsPrec :: Int -> Requirements -> ShowS
$cshow :: Requirements -> String
show :: Requirements -> String
$cshowList :: [Requirements] -> ShowS
showList :: [Requirements] -> ShowS
Show, Typeable Requirements
Typeable Requirements =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Requirements -> c Requirements)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Requirements)
-> (Requirements -> Constr)
-> (Requirements -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Requirements))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Requirements))
-> ((forall b. Data b => b -> b) -> Requirements -> Requirements)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Requirements -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Requirements -> r)
-> (forall u. (forall d. Data d => d -> u) -> Requirements -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Requirements -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Requirements -> m Requirements)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Requirements -> m Requirements)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Requirements -> m Requirements)
-> Data Requirements
Requirements -> Constr
Requirements -> DataType
(forall b. Data b => b -> b) -> Requirements -> Requirements
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Requirements -> u
forall u. (forall d. Data d => d -> u) -> Requirements -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Requirements -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Requirements -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Requirements -> m Requirements
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Requirements -> m Requirements
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Requirements
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Requirements -> c Requirements
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Requirements)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Requirements)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Requirements -> c Requirements
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Requirements -> c Requirements
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Requirements
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Requirements
$ctoConstr :: Requirements -> Constr
toConstr :: Requirements -> Constr
$cdataTypeOf :: Requirements -> DataType
dataTypeOf :: Requirements -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Requirements)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Requirements)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Requirements)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Requirements)
$cgmapT :: (forall b. Data b => b -> b) -> Requirements -> Requirements
gmapT :: (forall b. Data b => b -> b) -> Requirements -> Requirements
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Requirements -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Requirements -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Requirements -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Requirements -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Requirements -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Requirements -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Requirements -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Requirements -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Requirements -> m Requirements
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Requirements -> m Requirements
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Requirements -> m Requirements
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Requirements -> m Requirements
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Requirements -> m Requirements
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Requirements -> m Requirements
Data, (forall x. Requirements -> Rep Requirements x)
-> (forall x. Rep Requirements x -> Requirements)
-> Generic Requirements
forall x. Rep Requirements x -> Requirements
forall x. Requirements -> Rep Requirements x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Requirements -> Rep Requirements x
from :: forall x. Requirements -> Rep Requirements x
$cto :: forall x. Rep Requirements x -> Requirements
to :: forall x. Rep Requirements x -> Requirements
Generic, Maybe Requirements
Value -> Parser [Requirements]
Value -> Parser Requirements
(Value -> Parser Requirements)
-> (Value -> Parser [Requirements])
-> Maybe Requirements
-> FromJSON Requirements
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Requirements
parseJSON :: Value -> Parser Requirements
$cparseJSONList :: Value -> Parser [Requirements]
parseJSONList :: Value -> Parser [Requirements]
$comittedField :: Maybe Requirements
omittedField :: Maybe Requirements
FromJSON, [Requirements] -> Value
[Requirements] -> Encoding
Requirements -> Bool
Requirements -> Value
Requirements -> Encoding
(Requirements -> Value)
-> (Requirements -> Encoding)
-> ([Requirements] -> Value)
-> ([Requirements] -> Encoding)
-> (Requirements -> Bool)
-> ToJSON Requirements
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Requirements -> Value
toJSON :: Requirements -> Value
$ctoEncoding :: Requirements -> Encoding
toEncoding :: Requirements -> Encoding
$ctoJSONList :: [Requirements] -> Value
toJSONList :: [Requirements] -> Value
$ctoEncodingList :: [Requirements] -> Encoding
toEncodingList :: [Requirements] -> Encoding
$comitField :: Requirements -> Bool
omitField :: Requirements -> Bool
ToJSON, Eq Requirements
Eq Requirements =>
(Int -> Requirements -> Int)
-> (Requirements -> Int) -> Hashable Requirements
Int -> Requirements -> Int
Requirements -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Requirements -> Int
hashWithSalt :: Int -> Requirements -> Int
$chash :: Requirements -> Int
hash :: Requirements -> Int
Hashable)

instance Semigroup Requirements where
  Requirements Set Capability
c1 Set Text
d1 Map Text Int
i1 <> :: Requirements -> Requirements -> Requirements
<> Requirements Set Capability
c2 Set Text
d2 Map Text Int
i2 =
    Set Capability -> Set Text -> Map Text Int -> Requirements
Requirements (Set Capability
c1 Set Capability -> Set Capability -> Set Capability
forall a. Semigroup a => a -> a -> a
<> Set Capability
c2) (Set Text
d1 Set Text -> Set Text -> Set Text
forall a. Semigroup a => a -> a -> a
<> Set Text
d2) ((Int -> Int -> Int) -> Map Text Int -> Map Text Int -> Map Text Int
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
M.unionWith Int -> Int -> Int
forall a. Num a => a -> a -> a
(+) Map Text Int
i1 Map Text Int
i2)

instance Monoid Requirements where
  mempty :: Requirements
mempty = Set Capability -> Set Text -> Map Text Int -> Requirements
Requirements Set Capability
forall a. Set a
S.empty Set Text
forall a. Set a
S.empty Map Text Int
forall k a. Map k a
M.empty

-- | Create a 'Requirements' set with a single 'Requirement'.
singleton :: Requirement -> Requirements
singleton :: Requirement -> Requirements
singleton (ReqCap Capability
c) = Set Capability -> Set Text -> Map Text Int -> Requirements
Requirements (Capability -> Set Capability
forall a. a -> Set a
S.singleton Capability
c) Set Text
forall a. Set a
S.empty Map Text Int
forall k a. Map k a
M.empty
singleton (ReqDev Text
d) = Set Capability -> Set Text -> Map Text Int -> Requirements
Requirements Set Capability
forall a. Set a
S.empty (Text -> Set Text
forall a. a -> Set a
S.singleton Text
d) Map Text Int
forall k a. Map k a
M.empty
singleton (ReqInv Int
n Text
e) = Set Capability -> Set Text -> Map Text Int -> Requirements
Requirements Set Capability
forall a. Set a
S.empty Set Text
forall a. Set a
S.empty (Text -> Int -> Map Text Int
forall k a. k -> a -> Map k a
M.singleton Text
e Int
n)

-- | For convenience, create a 'Requirements' set with a single
--   'Capability' requirement.
singletonCap :: Capability -> Requirements
singletonCap :: Capability -> Requirements
singletonCap = Requirement -> Requirements
singleton (Requirement -> Requirements)
-> (Capability -> Requirement) -> Capability -> Requirements
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Capability -> Requirement
ReqCap

-- | For convenience, create a 'Requirements' set with a single
--   device requirement.
singletonDev :: Text -> Requirements
singletonDev :: Text -> Requirements
singletonDev = Requirement -> Requirements
singleton (Requirement -> Requirements)
-> (Text -> Requirement) -> Text -> Requirements
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Requirement
ReqDev

-- | For convenience, create a 'Requirements' set with a single
--   inventory requirement.
singletonInv :: Int -> Text -> Requirements
singletonInv :: Int -> Text -> Requirements
singletonInv Int
n Text
e = Requirement -> Requirements
singleton (Int -> Text -> Requirement
ReqInv Int
n Text
e)

insert :: Requirement -> Requirements -> Requirements
insert :: Requirement -> Requirements -> Requirements
insert = Requirements -> Requirements -> Requirements
forall a. Semigroup a => a -> a -> a
(<>) (Requirements -> Requirements -> Requirements)
-> (Requirement -> Requirements)
-> Requirement
-> Requirements
-> Requirements
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Requirement -> Requirements
singleton

-- | A requirement context records the requirements for the
--   definitions bound to variables.
type ReqCtx = Ctx Var Requirements