-- |
-- SPDX-License-Identifier: BSD-3-Clause
--
-- A device is an entity that provides capabilities.
--
-- Some capabilities have a cost to exercise.
-- Items will be consumed from the inventory for
-- invoking a command that utilizes a given capability.
module Swarm.Game.Device (
  SingleEntityCapabilities,
  MultiEntityCapabilities,
  Capabilities (..),
  DeviceUseCost (..),
  ExerciseCost (..),
  CommandsAndCost (..),
  getCapabilitySet,
  zeroCostCapabilities,
  commandsForDeviceCaps,
)
where

import Control.Applicative ((<|>))
import Data.Function (on)
import Data.Hashable
import Data.List.NonEmpty (NonEmpty (..))
import Data.Map (Map)
import Data.Map qualified as M
import Data.Set (Set)
import Data.Vector qualified as V
import Data.Yaml
import GHC.Generics (Generic)
import Swarm.Game.Ingredients
import Swarm.Language.Capability (Capability, constByCaps)
import Swarm.Language.Syntax (Const)

-- | The 'Capabilities e' wrapper type stores information of type @e@ for each
-- of some set of capabilities.
-- For example, @e@ could be a list of ingredients needed to exercise a
-- capability, or a set of devices capable of providing a capability.
newtype Capabilities e = Capabilities
  { forall e. Capabilities e -> Map Capability e
getMap :: Map Capability e
  }
  deriving (Int -> Capabilities e -> ShowS
[Capabilities e] -> ShowS
Capabilities e -> String
(Int -> Capabilities e -> ShowS)
-> (Capabilities e -> String)
-> ([Capabilities e] -> ShowS)
-> Show (Capabilities e)
forall e. Show e => Int -> Capabilities e -> ShowS
forall e. Show e => [Capabilities e] -> ShowS
forall e. Show e => Capabilities e -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall e. Show e => Int -> Capabilities e -> ShowS
showsPrec :: Int -> Capabilities e -> ShowS
$cshow :: forall e. Show e => Capabilities e -> String
show :: Capabilities e -> String
$cshowList :: forall e. Show e => [Capabilities e] -> ShowS
showList :: [Capabilities e] -> ShowS
Show, Capabilities e -> Capabilities e -> Bool
(Capabilities e -> Capabilities e -> Bool)
-> (Capabilities e -> Capabilities e -> Bool)
-> Eq (Capabilities e)
forall e. Eq e => Capabilities e -> Capabilities e -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall e. Eq e => Capabilities e -> Capabilities e -> Bool
== :: Capabilities e -> Capabilities e -> Bool
$c/= :: forall e. Eq e => Capabilities e -> Capabilities e -> Bool
/= :: Capabilities e -> Capabilities e -> Bool
Eq, (forall x. Capabilities e -> Rep (Capabilities e) x)
-> (forall x. Rep (Capabilities e) x -> Capabilities e)
-> Generic (Capabilities e)
forall x. Rep (Capabilities e) x -> Capabilities e
forall x. Capabilities e -> Rep (Capabilities e) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall e x. Rep (Capabilities e) x -> Capabilities e
forall e x. Capabilities e -> Rep (Capabilities e) x
$cfrom :: forall e x. Capabilities e -> Rep (Capabilities e) x
from :: forall x. Capabilities e -> Rep (Capabilities e) x
$cto :: forall e x. Rep (Capabilities e) x -> Capabilities e
to :: forall x. Rep (Capabilities e) x -> Capabilities e
Generic, [Capabilities e] -> Value
[Capabilities e] -> Encoding
Capabilities e -> Bool
Capabilities e -> Value
Capabilities e -> Encoding
(Capabilities e -> Value)
-> (Capabilities e -> Encoding)
-> ([Capabilities e] -> Value)
-> ([Capabilities e] -> Encoding)
-> (Capabilities e -> Bool)
-> ToJSON (Capabilities e)
forall e. ToJSON e => [Capabilities e] -> Value
forall e. ToJSON e => [Capabilities e] -> Encoding
forall e. ToJSON e => Capabilities e -> Bool
forall e. ToJSON e => Capabilities e -> Value
forall e. ToJSON e => Capabilities e -> Encoding
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: forall e. ToJSON e => Capabilities e -> Value
toJSON :: Capabilities e -> Value
$ctoEncoding :: forall e. ToJSON e => Capabilities e -> Encoding
toEncoding :: Capabilities e -> Encoding
$ctoJSONList :: forall e. ToJSON e => [Capabilities e] -> Value
toJSONList :: [Capabilities e] -> Value
$ctoEncodingList :: forall e. ToJSON e => [Capabilities e] -> Encoding
toEncodingList :: [Capabilities e] -> Encoding
$comitField :: forall e. ToJSON e => Capabilities e -> Bool
omitField :: Capabilities e -> Bool
ToJSON, Eq (Capabilities e)
Eq (Capabilities e) =>
(Int -> Capabilities e -> Int)
-> (Capabilities e -> Int) -> Hashable (Capabilities e)
Int -> Capabilities e -> Int
Capabilities e -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall e. Hashable e => Eq (Capabilities e)
forall e. Hashable e => Int -> Capabilities e -> Int
forall e. Hashable e => Capabilities e -> Int
$chashWithSalt :: forall e. Hashable e => Int -> Capabilities e -> Int
hashWithSalt :: Int -> Capabilities e -> Int
$chash :: forall e. Hashable e => Capabilities e -> Int
hash :: Capabilities e -> Int
Hashable, (forall a b. (a -> b) -> Capabilities a -> Capabilities b)
-> (forall a b. a -> Capabilities b -> Capabilities a)
-> Functor Capabilities
forall a b. a -> Capabilities b -> Capabilities a
forall a b. (a -> b) -> Capabilities a -> Capabilities b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Capabilities a -> Capabilities b
fmap :: forall a b. (a -> b) -> Capabilities a -> Capabilities b
$c<$ :: forall a b. a -> Capabilities b -> Capabilities a
<$ :: forall a b. a -> Capabilities b -> Capabilities a
Functor, (forall m. Monoid m => Capabilities m -> m)
-> (forall m a. Monoid m => (a -> m) -> Capabilities a -> m)
-> (forall m a. Monoid m => (a -> m) -> Capabilities a -> m)
-> (forall a b. (a -> b -> b) -> b -> Capabilities a -> b)
-> (forall a b. (a -> b -> b) -> b -> Capabilities a -> b)
-> (forall b a. (b -> a -> b) -> b -> Capabilities a -> b)
-> (forall b a. (b -> a -> b) -> b -> Capabilities a -> b)
-> (forall a. (a -> a -> a) -> Capabilities a -> a)
-> (forall a. (a -> a -> a) -> Capabilities a -> a)
-> (forall a. Capabilities a -> [a])
-> (forall a. Capabilities a -> Bool)
-> (forall a. Capabilities a -> Int)
-> (forall a. Eq a => a -> Capabilities a -> Bool)
-> (forall a. Ord a => Capabilities a -> a)
-> (forall a. Ord a => Capabilities a -> a)
-> (forall a. Num a => Capabilities a -> a)
-> (forall a. Num a => Capabilities a -> a)
-> Foldable Capabilities
forall a. Eq a => a -> Capabilities a -> Bool
forall a. Num a => Capabilities a -> a
forall a. Ord a => Capabilities a -> a
forall m. Monoid m => Capabilities m -> m
forall a. Capabilities a -> Bool
forall a. Capabilities a -> Int
forall a. Capabilities a -> [a]
forall a. (a -> a -> a) -> Capabilities a -> a
forall m a. Monoid m => (a -> m) -> Capabilities a -> m
forall b a. (b -> a -> b) -> b -> Capabilities a -> b
forall a b. (a -> b -> b) -> b -> Capabilities a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Capabilities m -> m
fold :: forall m. Monoid m => Capabilities m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Capabilities a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Capabilities a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Capabilities a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Capabilities a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Capabilities a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Capabilities a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Capabilities a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Capabilities a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Capabilities a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Capabilities a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Capabilities a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Capabilities a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Capabilities a -> a
foldr1 :: forall a. (a -> a -> a) -> Capabilities a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Capabilities a -> a
foldl1 :: forall a. (a -> a -> a) -> Capabilities a -> a
$ctoList :: forall a. Capabilities a -> [a]
toList :: forall a. Capabilities a -> [a]
$cnull :: forall a. Capabilities a -> Bool
null :: forall a. Capabilities a -> Bool
$clength :: forall a. Capabilities a -> Int
length :: forall a. Capabilities a -> Int
$celem :: forall a. Eq a => a -> Capabilities a -> Bool
elem :: forall a. Eq a => a -> Capabilities a -> Bool
$cmaximum :: forall a. Ord a => Capabilities a -> a
maximum :: forall a. Ord a => Capabilities a -> a
$cminimum :: forall a. Ord a => Capabilities a -> a
minimum :: forall a. Ord a => Capabilities a -> a
$csum :: forall a. Num a => Capabilities a -> a
sum :: forall a. Num a => Capabilities a -> a
$cproduct :: forall a. Num a => Capabilities a -> a
product :: forall a. Num a => Capabilities a -> a
Foldable, Functor Capabilities
Foldable Capabilities
(Functor Capabilities, Foldable Capabilities) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Capabilities a -> f (Capabilities b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Capabilities (f a) -> f (Capabilities a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Capabilities a -> m (Capabilities b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Capabilities (m a) -> m (Capabilities a))
-> Traversable Capabilities
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
Capabilities (m a) -> m (Capabilities a)
forall (f :: * -> *) a.
Applicative f =>
Capabilities (f a) -> f (Capabilities a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Capabilities a -> m (Capabilities b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Capabilities a -> f (Capabilities b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Capabilities a -> f (Capabilities b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Capabilities a -> f (Capabilities b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Capabilities (f a) -> f (Capabilities a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Capabilities (f a) -> f (Capabilities a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Capabilities a -> m (Capabilities b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Capabilities a -> m (Capabilities b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Capabilities (m a) -> m (Capabilities a)
sequence :: forall (m :: * -> *) a.
Monad m =>
Capabilities (m a) -> m (Capabilities a)
Traversable)

-- | Get the set of capabilities about which we are storing information.
getCapabilitySet :: Capabilities e -> Set Capability
getCapabilitySet :: forall e. Capabilities e -> Set Capability
getCapabilitySet (Capabilities Map Capability e
m) = Map Capability e -> Set Capability
forall k a. Map k a -> Set k
M.keysSet Map Capability e
m

-- | Records an 'ExerciseCost', i.e. list of consumed ingredients, per capability that can be exercised.  This represents information about a single entity/device, which can provide multiple capabilities (with a different exercise cost for each).
type SingleEntityCapabilities e = Capabilities (ExerciseCost e)

-- | Records a list of devices capable of providing each capability;
-- along with each device is recorded the 'ExerciseCost' needed to use
-- that device to achieve the given capability.
--
-- See 'DeviceUseCost' for explanation of type parameters.
type MultiEntityCapabilities e en = Capabilities (NonEmpty (DeviceUseCost e en))

-- | Create a default 'SingleEntityCapabilities' map for a device which provides capabilities with no associated costs.
zeroCostCapabilities :: Set Capability -> SingleEntityCapabilities e
zeroCostCapabilities :: forall e. Set Capability -> SingleEntityCapabilities e
zeroCostCapabilities = Map Capability (ExerciseCost e) -> Capabilities (ExerciseCost e)
forall e. Map Capability e -> Capabilities e
Capabilities (Map Capability (ExerciseCost e) -> Capabilities (ExerciseCost e))
-> (Set Capability -> Map Capability (ExerciseCost e))
-> Set Capability
-> Capabilities (ExerciseCost e)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Capability -> ExerciseCost e)
-> Set Capability -> Map Capability (ExerciseCost e)
forall k a. (k -> a) -> Set k -> Map k a
M.fromSet (ExerciseCost e -> Capability -> ExerciseCost e
forall a b. a -> b -> a
const (ExerciseCost e -> Capability -> ExerciseCost e)
-> ExerciseCost e -> Capability -> ExerciseCost e
forall a b. (a -> b) -> a -> b
$ IngredientList e -> ExerciseCost e
forall e. IngredientList e -> ExerciseCost e
ExerciseCost [])

-- | Package together a capability and exercise cost; only used temporarily for parsing this information from JSON format.
data CapabilityCost e = CapabilityCost
  { forall e. CapabilityCost e -> Capability
capability :: Capability
  , forall e. CapabilityCost e -> IngredientList e
cost :: IngredientList e
  }
  deriving ((forall x. CapabilityCost e -> Rep (CapabilityCost e) x)
-> (forall x. Rep (CapabilityCost e) x -> CapabilityCost e)
-> Generic (CapabilityCost e)
forall x. Rep (CapabilityCost e) x -> CapabilityCost e
forall x. CapabilityCost e -> Rep (CapabilityCost e) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall e x. Rep (CapabilityCost e) x -> CapabilityCost e
forall e x. CapabilityCost e -> Rep (CapabilityCost e) x
$cfrom :: forall e x. CapabilityCost e -> Rep (CapabilityCost e) x
from :: forall x. CapabilityCost e -> Rep (CapabilityCost e) x
$cto :: forall e x. Rep (CapabilityCost e) x -> CapabilityCost e
to :: forall x. Rep (CapabilityCost e) x -> CapabilityCost e
Generic, Maybe (CapabilityCost e)
Value -> Parser [CapabilityCost e]
Value -> Parser (CapabilityCost e)
(Value -> Parser (CapabilityCost e))
-> (Value -> Parser [CapabilityCost e])
-> Maybe (CapabilityCost e)
-> FromJSON (CapabilityCost e)
forall e. FromJSON e => Maybe (CapabilityCost e)
forall e. FromJSON e => Value -> Parser [CapabilityCost e]
forall e. FromJSON e => Value -> Parser (CapabilityCost e)
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: forall e. FromJSON e => Value -> Parser (CapabilityCost e)
parseJSON :: Value -> Parser (CapabilityCost e)
$cparseJSONList :: forall e. FromJSON e => Value -> Parser [CapabilityCost e]
parseJSONList :: Value -> Parser [CapabilityCost e]
$comittedField :: forall e. FromJSON e => Maybe (CapabilityCost e)
omittedField :: Maybe (CapabilityCost e)
FromJSON)

-- | First, attempt to parse capabilities as a list, interpreted as a set of capabilities with no exercise cost.
-- Otherwise, parse as a Map from capabilities to ingredients.
instance (FromJSON e) => FromJSON (SingleEntityCapabilities e) where
  parseJSON :: Value -> Parser (SingleEntityCapabilities e)
parseJSON Value
x =
    (Map Capability (ExerciseCost e) -> SingleEntityCapabilities e
forall e. Map Capability e -> Capabilities e
Capabilities (Map Capability (ExerciseCost e) -> SingleEntityCapabilities e)
-> Parser (Map Capability (ExerciseCost e))
-> Parser (SingleEntityCapabilities e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Map Capability (ExerciseCost e))
costMap) Parser (SingleEntityCapabilities e)
-> Parser (SingleEntityCapabilities e)
-> Parser (SingleEntityCapabilities e)
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (SingleEntityCapabilities e)
forall {e}. Parser (SingleEntityCapabilities e)
simpleList
   where
    simpleList :: Parser (SingleEntityCapabilities e)
simpleList = Set Capability -> SingleEntityCapabilities e
forall e. Set Capability -> SingleEntityCapabilities e
zeroCostCapabilities (Set Capability -> SingleEntityCapabilities e)
-> Parser (Set Capability) -> Parser (SingleEntityCapabilities e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser (Set Capability)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
x
    costMap :: Parser (Map Capability (ExerciseCost e))
costMap = String
-> (Array -> Parser (Map Capability (ExerciseCost e)))
-> Value
-> Parser (Map Capability (ExerciseCost e))
forall a. String -> (Array -> Parser a) -> Value -> Parser a
withArray String
"Capabilities" (([CapabilityCost e] -> Map Capability (ExerciseCost e))
-> Parser [CapabilityCost e]
-> Parser (Map Capability (ExerciseCost e))
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([(Capability, ExerciseCost e)] -> Map Capability (ExerciseCost e)
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(Capability, ExerciseCost e)] -> Map Capability (ExerciseCost e))
-> ([CapabilityCost e] -> [(Capability, ExerciseCost e)])
-> [CapabilityCost e]
-> Map Capability (ExerciseCost e)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CapabilityCost e -> (Capability, ExerciseCost e))
-> [CapabilityCost e] -> [(Capability, ExerciseCost e)]
forall a b. (a -> b) -> [a] -> [b]
map CapabilityCost e -> (Capability, ExerciseCost e)
forall {e}. CapabilityCost e -> (Capability, ExerciseCost e)
toMapEntry) (Parser [CapabilityCost e]
 -> Parser (Map Capability (ExerciseCost e)))
-> (Array -> Parser [CapabilityCost e])
-> Array
-> Parser (Map Capability (ExerciseCost e))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value -> Parser (CapabilityCost e))
-> [Value] -> Parser [CapabilityCost e]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Value -> Parser (CapabilityCost e)
forall a. FromJSON a => Value -> Parser a
parseJSON ([Value] -> Parser [CapabilityCost e])
-> (Array -> [Value]) -> Array -> Parser [CapabilityCost e]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array -> [Value]
forall a. Vector a -> [a]
V.toList) Value
x
    toMapEntry :: CapabilityCost e -> (Capability, ExerciseCost e)
toMapEntry (CapabilityCost Capability
a IngredientList e
b) = (Capability
a, IngredientList e -> ExerciseCost e
forall e. IngredientList e -> ExerciseCost e
ExerciseCost IngredientList e
b)

instance (Ord e, Semigroup e) => Semigroup (Capabilities e) where
  Capabilities Map Capability e
c1 <> :: Capabilities e -> Capabilities e -> Capabilities e
<> Capabilities Map Capability e
c2 =
    Map Capability e -> Capabilities e
forall e. Map Capability e -> Capabilities e
Capabilities (Map Capability e -> Capabilities e)
-> Map Capability e -> Capabilities e
forall a b. (a -> b) -> a -> b
$ (e -> e -> e)
-> Map Capability e -> Map Capability e -> Map Capability e
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
M.unionWith e -> e -> e
forall a. Semigroup a => a -> a -> a
(<>) Map Capability e
c1 Map Capability e
c2

instance (Ord e, Semigroup e) => Monoid (Capabilities e) where
  mempty :: Capabilities e
mempty = Map Capability e -> Capabilities e
forall e. Map Capability e -> Capabilities e
Capabilities Map Capability e
forall a. Monoid a => a
mempty

-- | Exercising a capability may have a cost, in the form of entities that must be consumed each time it is used.
newtype ExerciseCost e = ExerciseCost
  { forall e. ExerciseCost e -> IngredientList e
ingredients :: IngredientList e
  }
  deriving (ExerciseCost e -> ExerciseCost e -> Bool
(ExerciseCost e -> ExerciseCost e -> Bool)
-> (ExerciseCost e -> ExerciseCost e -> Bool)
-> Eq (ExerciseCost e)
forall e. Eq e => ExerciseCost e -> ExerciseCost e -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall e. Eq e => ExerciseCost e -> ExerciseCost e -> Bool
== :: ExerciseCost e -> ExerciseCost e -> Bool
$c/= :: forall e. Eq e => ExerciseCost e -> ExerciseCost e -> Bool
/= :: ExerciseCost e -> ExerciseCost e -> Bool
Eq, Int -> ExerciseCost e -> ShowS
[ExerciseCost e] -> ShowS
ExerciseCost e -> String
(Int -> ExerciseCost e -> ShowS)
-> (ExerciseCost e -> String)
-> ([ExerciseCost e] -> ShowS)
-> Show (ExerciseCost e)
forall e. Show e => Int -> ExerciseCost e -> ShowS
forall e. Show e => [ExerciseCost e] -> ShowS
forall e. Show e => ExerciseCost e -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall e. Show e => Int -> ExerciseCost e -> ShowS
showsPrec :: Int -> ExerciseCost e -> ShowS
$cshow :: forall e. Show e => ExerciseCost e -> String
show :: ExerciseCost e -> String
$cshowList :: forall e. Show e => [ExerciseCost e] -> ShowS
showList :: [ExerciseCost e] -> ShowS
Show, (forall x. ExerciseCost e -> Rep (ExerciseCost e) x)
-> (forall x. Rep (ExerciseCost e) x -> ExerciseCost e)
-> Generic (ExerciseCost e)
forall x. Rep (ExerciseCost e) x -> ExerciseCost e
forall x. ExerciseCost e -> Rep (ExerciseCost e) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall e x. Rep (ExerciseCost e) x -> ExerciseCost e
forall e x. ExerciseCost e -> Rep (ExerciseCost e) x
$cfrom :: forall e x. ExerciseCost e -> Rep (ExerciseCost e) x
from :: forall x. ExerciseCost e -> Rep (ExerciseCost e) x
$cto :: forall e x. Rep (ExerciseCost e) x -> ExerciseCost e
to :: forall x. Rep (ExerciseCost e) x -> ExerciseCost e
Generic, Maybe (ExerciseCost e)
Value -> Parser [ExerciseCost e]
Value -> Parser (ExerciseCost e)
(Value -> Parser (ExerciseCost e))
-> (Value -> Parser [ExerciseCost e])
-> Maybe (ExerciseCost e)
-> FromJSON (ExerciseCost e)
forall e. FromJSON e => Maybe (ExerciseCost e)
forall e. FromJSON e => Value -> Parser [ExerciseCost e]
forall e. FromJSON e => Value -> Parser (ExerciseCost e)
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: forall e. FromJSON e => Value -> Parser (ExerciseCost e)
parseJSON :: Value -> Parser (ExerciseCost e)
$cparseJSONList :: forall e. FromJSON e => Value -> Parser [ExerciseCost e]
parseJSONList :: Value -> Parser [ExerciseCost e]
$comittedField :: forall e. FromJSON e => Maybe (ExerciseCost e)
omittedField :: Maybe (ExerciseCost e)
FromJSON, [ExerciseCost e] -> Value
[ExerciseCost e] -> Encoding
ExerciseCost e -> Bool
ExerciseCost e -> Value
ExerciseCost e -> Encoding
(ExerciseCost e -> Value)
-> (ExerciseCost e -> Encoding)
-> ([ExerciseCost e] -> Value)
-> ([ExerciseCost e] -> Encoding)
-> (ExerciseCost e -> Bool)
-> ToJSON (ExerciseCost e)
forall e. ToJSON e => [ExerciseCost e] -> Value
forall e. ToJSON e => [ExerciseCost e] -> Encoding
forall e. ToJSON e => ExerciseCost e -> Bool
forall e. ToJSON e => ExerciseCost e -> Value
forall e. ToJSON e => ExerciseCost e -> Encoding
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: forall e. ToJSON e => ExerciseCost e -> Value
toJSON :: ExerciseCost e -> Value
$ctoEncoding :: forall e. ToJSON e => ExerciseCost e -> Encoding
toEncoding :: ExerciseCost e -> Encoding
$ctoJSONList :: forall e. ToJSON e => [ExerciseCost e] -> Value
toJSONList :: [ExerciseCost e] -> Value
$ctoEncodingList :: forall e. ToJSON e => [ExerciseCost e] -> Encoding
toEncodingList :: [ExerciseCost e] -> Encoding
$comitField :: forall e. ToJSON e => ExerciseCost e -> Bool
omitField :: ExerciseCost e -> Bool
ToJSON, Eq (ExerciseCost e)
Eq (ExerciseCost e) =>
(Int -> ExerciseCost e -> Int)
-> (ExerciseCost e -> Int) -> Hashable (ExerciseCost e)
Int -> ExerciseCost e -> Int
ExerciseCost e -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall e. Hashable e => Eq (ExerciseCost e)
forall e. Hashable e => Int -> ExerciseCost e -> Int
forall e. Hashable e => ExerciseCost e -> Int
$chashWithSalt :: forall e. Hashable e => Int -> ExerciseCost e -> Int
hashWithSalt :: Int -> ExerciseCost e -> Int
$chash :: forall e. Hashable e => ExerciseCost e -> Int
hash :: ExerciseCost e -> Int
Hashable, (forall a b. (a -> b) -> ExerciseCost a -> ExerciseCost b)
-> (forall a b. a -> ExerciseCost b -> ExerciseCost a)
-> Functor ExerciseCost
forall a b. a -> ExerciseCost b -> ExerciseCost a
forall a b. (a -> b) -> ExerciseCost a -> ExerciseCost b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ExerciseCost a -> ExerciseCost b
fmap :: forall a b. (a -> b) -> ExerciseCost a -> ExerciseCost b
$c<$ :: forall a b. a -> ExerciseCost b -> ExerciseCost a
<$ :: forall a b. a -> ExerciseCost b -> ExerciseCost a
Functor, (forall m. Monoid m => ExerciseCost m -> m)
-> (forall m a. Monoid m => (a -> m) -> ExerciseCost a -> m)
-> (forall m a. Monoid m => (a -> m) -> ExerciseCost a -> m)
-> (forall a b. (a -> b -> b) -> b -> ExerciseCost a -> b)
-> (forall a b. (a -> b -> b) -> b -> ExerciseCost a -> b)
-> (forall b a. (b -> a -> b) -> b -> ExerciseCost a -> b)
-> (forall b a. (b -> a -> b) -> b -> ExerciseCost a -> b)
-> (forall a. (a -> a -> a) -> ExerciseCost a -> a)
-> (forall a. (a -> a -> a) -> ExerciseCost a -> a)
-> (forall a. ExerciseCost a -> [a])
-> (forall a. ExerciseCost a -> Bool)
-> (forall a. ExerciseCost a -> Int)
-> (forall a. Eq a => a -> ExerciseCost a -> Bool)
-> (forall a. Ord a => ExerciseCost a -> a)
-> (forall a. Ord a => ExerciseCost a -> a)
-> (forall a. Num a => ExerciseCost a -> a)
-> (forall a. Num a => ExerciseCost a -> a)
-> Foldable ExerciseCost
forall a. Eq a => a -> ExerciseCost a -> Bool
forall a. Num a => ExerciseCost a -> a
forall a. Ord a => ExerciseCost a -> a
forall m. Monoid m => ExerciseCost m -> m
forall a. ExerciseCost a -> Bool
forall a. ExerciseCost a -> Int
forall a. ExerciseCost a -> [a]
forall a. (a -> a -> a) -> ExerciseCost a -> a
forall m a. Monoid m => (a -> m) -> ExerciseCost a -> m
forall b a. (b -> a -> b) -> b -> ExerciseCost a -> b
forall a b. (a -> b -> b) -> b -> ExerciseCost a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => ExerciseCost m -> m
fold :: forall m. Monoid m => ExerciseCost m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ExerciseCost a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ExerciseCost a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ExerciseCost a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> ExerciseCost a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> ExerciseCost a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ExerciseCost a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ExerciseCost a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ExerciseCost a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ExerciseCost a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ExerciseCost a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ExerciseCost a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> ExerciseCost a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> ExerciseCost a -> a
foldr1 :: forall a. (a -> a -> a) -> ExerciseCost a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ExerciseCost a -> a
foldl1 :: forall a. (a -> a -> a) -> ExerciseCost a -> a
$ctoList :: forall a. ExerciseCost a -> [a]
toList :: forall a. ExerciseCost a -> [a]
$cnull :: forall a. ExerciseCost a -> Bool
null :: forall a. ExerciseCost a -> Bool
$clength :: forall a. ExerciseCost a -> Int
length :: forall a. ExerciseCost a -> Int
$celem :: forall a. Eq a => a -> ExerciseCost a -> Bool
elem :: forall a. Eq a => a -> ExerciseCost a -> Bool
$cmaximum :: forall a. Ord a => ExerciseCost a -> a
maximum :: forall a. Ord a => ExerciseCost a -> a
$cminimum :: forall a. Ord a => ExerciseCost a -> a
minimum :: forall a. Ord a => ExerciseCost a -> a
$csum :: forall a. Num a => ExerciseCost a -> a
sum :: forall a. Num a => ExerciseCost a -> a
$cproduct :: forall a. Num a => ExerciseCost a -> a
product :: forall a. Num a => ExerciseCost a -> a
Foldable, Functor ExerciseCost
Foldable ExerciseCost
(Functor ExerciseCost, Foldable ExerciseCost) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ExerciseCost a -> f (ExerciseCost b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ExerciseCost (f a) -> f (ExerciseCost a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ExerciseCost a -> m (ExerciseCost b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ExerciseCost (m a) -> m (ExerciseCost a))
-> Traversable ExerciseCost
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
ExerciseCost (m a) -> m (ExerciseCost a)
forall (f :: * -> *) a.
Applicative f =>
ExerciseCost (f a) -> f (ExerciseCost a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ExerciseCost a -> m (ExerciseCost b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ExerciseCost a -> f (ExerciseCost b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ExerciseCost a -> f (ExerciseCost b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ExerciseCost a -> f (ExerciseCost b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ExerciseCost (f a) -> f (ExerciseCost a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ExerciseCost (f a) -> f (ExerciseCost a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ExerciseCost a -> m (ExerciseCost b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ExerciseCost a -> m (ExerciseCost b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ExerciseCost (m a) -> m (ExerciseCost a)
sequence :: forall (m :: * -> *) a.
Monad m =>
ExerciseCost (m a) -> m (ExerciseCost a)
Traversable)

-- | Sort 'ExerciseCost's by the total count of ingredients consumed.
instance (Eq e) => Ord (ExerciseCost e) where
  compare :: ExerciseCost e -> ExerciseCost e -> Ordering
compare = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Int -> Int -> Ordering)
-> (ExerciseCost e -> Int)
-> ExerciseCost e
-> ExerciseCost e
-> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` (IngredientList e -> Int
forall e. IngredientList e -> Int
getCost (IngredientList e -> Int)
-> (ExerciseCost e -> IngredientList e) -> ExerciseCost e -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExerciseCost e -> IngredientList e
forall e. ExerciseCost e -> IngredientList e
ingredients)

-- | A device paired with a cost to use it.
--
-- At scenario parse time, the type parameters @e@ and @en@ will stand for
-- 'Entity' and 'EntityName'.
-- This is because `ExerciseCost` is a member of the 'Entity' datatype, and
-- therefore can only refer to another 'Entity' by name before all 'Entity's
-- are parsed.
--
-- However, after parse time, we are able to look up actual 'Entity' objects
-- by name, and therefore can instantiate 'ExerciseCost' with 'Entity' as
-- the type parameter.
-- Then the two type parameters of 'DeviceUseCost' are both of 'Entity' type.
data DeviceUseCost e en = DeviceUseCost
  { forall e en. DeviceUseCost e en -> e
device :: e
  , forall e en. DeviceUseCost e en -> ExerciseCost en
useCost :: ExerciseCost en
  }
  deriving (DeviceUseCost e en -> DeviceUseCost e en -> Bool
(DeviceUseCost e en -> DeviceUseCost e en -> Bool)
-> (DeviceUseCost e en -> DeviceUseCost e en -> Bool)
-> Eq (DeviceUseCost e en)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall e en.
(Eq e, Eq en) =>
DeviceUseCost e en -> DeviceUseCost e en -> Bool
$c== :: forall e en.
(Eq e, Eq en) =>
DeviceUseCost e en -> DeviceUseCost e en -> Bool
== :: DeviceUseCost e en -> DeviceUseCost e en -> Bool
$c/= :: forall e en.
(Eq e, Eq en) =>
DeviceUseCost e en -> DeviceUseCost e en -> Bool
/= :: DeviceUseCost e en -> DeviceUseCost e en -> Bool
Eq, Eq (DeviceUseCost e en)
Eq (DeviceUseCost e en) =>
(DeviceUseCost e en -> DeviceUseCost e en -> Ordering)
-> (DeviceUseCost e en -> DeviceUseCost e en -> Bool)
-> (DeviceUseCost e en -> DeviceUseCost e en -> Bool)
-> (DeviceUseCost e en -> DeviceUseCost e en -> Bool)
-> (DeviceUseCost e en -> DeviceUseCost e en -> Bool)
-> (DeviceUseCost e en -> DeviceUseCost e en -> DeviceUseCost e en)
-> (DeviceUseCost e en -> DeviceUseCost e en -> DeviceUseCost e en)
-> Ord (DeviceUseCost e en)
DeviceUseCost e en -> DeviceUseCost e en -> Bool
DeviceUseCost e en -> DeviceUseCost e en -> Ordering
DeviceUseCost e en -> DeviceUseCost e en -> DeviceUseCost e en
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
forall e en. (Ord e, Eq en) => Eq (DeviceUseCost e en)
forall e en.
(Ord e, Eq en) =>
DeviceUseCost e en -> DeviceUseCost e en -> Bool
forall e en.
(Ord e, Eq en) =>
DeviceUseCost e en -> DeviceUseCost e en -> Ordering
forall e en.
(Ord e, Eq en) =>
DeviceUseCost e en -> DeviceUseCost e en -> DeviceUseCost e en
$ccompare :: forall e en.
(Ord e, Eq en) =>
DeviceUseCost e en -> DeviceUseCost e en -> Ordering
compare :: DeviceUseCost e en -> DeviceUseCost e en -> Ordering
$c< :: forall e en.
(Ord e, Eq en) =>
DeviceUseCost e en -> DeviceUseCost e en -> Bool
< :: DeviceUseCost e en -> DeviceUseCost e en -> Bool
$c<= :: forall e en.
(Ord e, Eq en) =>
DeviceUseCost e en -> DeviceUseCost e en -> Bool
<= :: DeviceUseCost e en -> DeviceUseCost e en -> Bool
$c> :: forall e en.
(Ord e, Eq en) =>
DeviceUseCost e en -> DeviceUseCost e en -> Bool
> :: DeviceUseCost e en -> DeviceUseCost e en -> Bool
$c>= :: forall e en.
(Ord e, Eq en) =>
DeviceUseCost e en -> DeviceUseCost e en -> Bool
>= :: DeviceUseCost e en -> DeviceUseCost e en -> Bool
$cmax :: forall e en.
(Ord e, Eq en) =>
DeviceUseCost e en -> DeviceUseCost e en -> DeviceUseCost e en
max :: DeviceUseCost e en -> DeviceUseCost e en -> DeviceUseCost e en
$cmin :: forall e en.
(Ord e, Eq en) =>
DeviceUseCost e en -> DeviceUseCost e en -> DeviceUseCost e en
min :: DeviceUseCost e en -> DeviceUseCost e en -> DeviceUseCost e en
Ord, Int -> DeviceUseCost e en -> ShowS
[DeviceUseCost e en] -> ShowS
DeviceUseCost e en -> String
(Int -> DeviceUseCost e en -> ShowS)
-> (DeviceUseCost e en -> String)
-> ([DeviceUseCost e en] -> ShowS)
-> Show (DeviceUseCost e en)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall e en.
(Show e, Show en) =>
Int -> DeviceUseCost e en -> ShowS
forall e en. (Show e, Show en) => [DeviceUseCost e en] -> ShowS
forall e en. (Show e, Show en) => DeviceUseCost e en -> String
$cshowsPrec :: forall e en.
(Show e, Show en) =>
Int -> DeviceUseCost e en -> ShowS
showsPrec :: Int -> DeviceUseCost e en -> ShowS
$cshow :: forall e en. (Show e, Show en) => DeviceUseCost e en -> String
show :: DeviceUseCost e en -> String
$cshowList :: forall e en. (Show e, Show en) => [DeviceUseCost e en] -> ShowS
showList :: [DeviceUseCost e en] -> ShowS
Show, (forall x. DeviceUseCost e en -> Rep (DeviceUseCost e en) x)
-> (forall x. Rep (DeviceUseCost e en) x -> DeviceUseCost e en)
-> Generic (DeviceUseCost e en)
forall x. Rep (DeviceUseCost e en) x -> DeviceUseCost e en
forall x. DeviceUseCost e en -> Rep (DeviceUseCost e en) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall e en x. Rep (DeviceUseCost e en) x -> DeviceUseCost e en
forall e en x. DeviceUseCost e en -> Rep (DeviceUseCost e en) x
$cfrom :: forall e en x. DeviceUseCost e en -> Rep (DeviceUseCost e en) x
from :: forall x. DeviceUseCost e en -> Rep (DeviceUseCost e en) x
$cto :: forall e en x. Rep (DeviceUseCost e en) x -> DeviceUseCost e en
to :: forall x. Rep (DeviceUseCost e en) x -> DeviceUseCost e en
Generic, Maybe (DeviceUseCost e en)
Value -> Parser [DeviceUseCost e en]
Value -> Parser (DeviceUseCost e en)
(Value -> Parser (DeviceUseCost e en))
-> (Value -> Parser [DeviceUseCost e en])
-> Maybe (DeviceUseCost e en)
-> FromJSON (DeviceUseCost e en)
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
forall e en.
(FromJSON e, FromJSON en) =>
Maybe (DeviceUseCost e en)
forall e en.
(FromJSON e, FromJSON en) =>
Value -> Parser [DeviceUseCost e en]
forall e en.
(FromJSON e, FromJSON en) =>
Value -> Parser (DeviceUseCost e en)
$cparseJSON :: forall e en.
(FromJSON e, FromJSON en) =>
Value -> Parser (DeviceUseCost e en)
parseJSON :: Value -> Parser (DeviceUseCost e en)
$cparseJSONList :: forall e en.
(FromJSON e, FromJSON en) =>
Value -> Parser [DeviceUseCost e en]
parseJSONList :: Value -> Parser [DeviceUseCost e en]
$comittedField :: forall e en.
(FromJSON e, FromJSON en) =>
Maybe (DeviceUseCost e en)
omittedField :: Maybe (DeviceUseCost e en)
FromJSON, [DeviceUseCost e en] -> Value
[DeviceUseCost e en] -> Encoding
DeviceUseCost e en -> Bool
DeviceUseCost e en -> Value
DeviceUseCost e en -> Encoding
(DeviceUseCost e en -> Value)
-> (DeviceUseCost e en -> Encoding)
-> ([DeviceUseCost e en] -> Value)
-> ([DeviceUseCost e en] -> Encoding)
-> (DeviceUseCost e en -> Bool)
-> ToJSON (DeviceUseCost e en)
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
forall e en. (ToJSON en, ToJSON e) => [DeviceUseCost e en] -> Value
forall e en.
(ToJSON en, ToJSON e) =>
[DeviceUseCost e en] -> Encoding
forall e en. (ToJSON en, ToJSON e) => DeviceUseCost e en -> Bool
forall e en. (ToJSON en, ToJSON e) => DeviceUseCost e en -> Value
forall e en.
(ToJSON en, ToJSON e) =>
DeviceUseCost e en -> Encoding
$ctoJSON :: forall e en. (ToJSON en, ToJSON e) => DeviceUseCost e en -> Value
toJSON :: DeviceUseCost e en -> Value
$ctoEncoding :: forall e en.
(ToJSON en, ToJSON e) =>
DeviceUseCost e en -> Encoding
toEncoding :: DeviceUseCost e en -> Encoding
$ctoJSONList :: forall e en. (ToJSON en, ToJSON e) => [DeviceUseCost e en] -> Value
toJSONList :: [DeviceUseCost e en] -> Value
$ctoEncodingList :: forall e en.
(ToJSON en, ToJSON e) =>
[DeviceUseCost e en] -> Encoding
toEncodingList :: [DeviceUseCost e en] -> Encoding
$comitField :: forall e en. (ToJSON en, ToJSON e) => DeviceUseCost e en -> Bool
omitField :: DeviceUseCost e en -> Bool
ToJSON, (forall a b. (a -> b) -> DeviceUseCost e a -> DeviceUseCost e b)
-> (forall a b. a -> DeviceUseCost e b -> DeviceUseCost e a)
-> Functor (DeviceUseCost e)
forall a b. a -> DeviceUseCost e b -> DeviceUseCost e a
forall a b. (a -> b) -> DeviceUseCost e a -> DeviceUseCost e b
forall e a b. a -> DeviceUseCost e b -> DeviceUseCost e a
forall e a b. (a -> b) -> DeviceUseCost e a -> DeviceUseCost e b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall e a b. (a -> b) -> DeviceUseCost e a -> DeviceUseCost e b
fmap :: forall a b. (a -> b) -> DeviceUseCost e a -> DeviceUseCost e b
$c<$ :: forall e a b. a -> DeviceUseCost e b -> DeviceUseCost e a
<$ :: forall a b. a -> DeviceUseCost e b -> DeviceUseCost e a
Functor, (forall m. Monoid m => DeviceUseCost e m -> m)
-> (forall m a. Monoid m => (a -> m) -> DeviceUseCost e a -> m)
-> (forall m a. Monoid m => (a -> m) -> DeviceUseCost e a -> m)
-> (forall a b. (a -> b -> b) -> b -> DeviceUseCost e a -> b)
-> (forall a b. (a -> b -> b) -> b -> DeviceUseCost e a -> b)
-> (forall b a. (b -> a -> b) -> b -> DeviceUseCost e a -> b)
-> (forall b a. (b -> a -> b) -> b -> DeviceUseCost e a -> b)
-> (forall a. (a -> a -> a) -> DeviceUseCost e a -> a)
-> (forall a. (a -> a -> a) -> DeviceUseCost e a -> a)
-> (forall a. DeviceUseCost e a -> [a])
-> (forall a. DeviceUseCost e a -> Bool)
-> (forall a. DeviceUseCost e a -> Int)
-> (forall a. Eq a => a -> DeviceUseCost e a -> Bool)
-> (forall a. Ord a => DeviceUseCost e a -> a)
-> (forall a. Ord a => DeviceUseCost e a -> a)
-> (forall a. Num a => DeviceUseCost e a -> a)
-> (forall a. Num a => DeviceUseCost e a -> a)
-> Foldable (DeviceUseCost e)
forall a. Eq a => a -> DeviceUseCost e a -> Bool
forall a. Num a => DeviceUseCost e a -> a
forall a. Ord a => DeviceUseCost e a -> a
forall m. Monoid m => DeviceUseCost e m -> m
forall a. DeviceUseCost e a -> Bool
forall a. DeviceUseCost e a -> Int
forall a. DeviceUseCost e a -> [a]
forall a. (a -> a -> a) -> DeviceUseCost e a -> a
forall e a. Eq a => a -> DeviceUseCost e a -> Bool
forall e a. Num a => DeviceUseCost e a -> a
forall e a. Ord a => DeviceUseCost e a -> a
forall e m. Monoid m => DeviceUseCost e m -> m
forall m a. Monoid m => (a -> m) -> DeviceUseCost e a -> m
forall e a. DeviceUseCost e a -> Bool
forall e a. DeviceUseCost e a -> Int
forall e a. DeviceUseCost e a -> [a]
forall b a. (b -> a -> b) -> b -> DeviceUseCost e a -> b
forall a b. (a -> b -> b) -> b -> DeviceUseCost e a -> b
forall e a. (a -> a -> a) -> DeviceUseCost e a -> a
forall e m a. Monoid m => (a -> m) -> DeviceUseCost e a -> m
forall e b a. (b -> a -> b) -> b -> DeviceUseCost e a -> b
forall e a b. (a -> b -> b) -> b -> DeviceUseCost e a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall e m. Monoid m => DeviceUseCost e m -> m
fold :: forall m. Monoid m => DeviceUseCost e m -> m
$cfoldMap :: forall e m a. Monoid m => (a -> m) -> DeviceUseCost e a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> DeviceUseCost e a -> m
$cfoldMap' :: forall e m a. Monoid m => (a -> m) -> DeviceUseCost e a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> DeviceUseCost e a -> m
$cfoldr :: forall e a b. (a -> b -> b) -> b -> DeviceUseCost e a -> b
foldr :: forall a b. (a -> b -> b) -> b -> DeviceUseCost e a -> b
$cfoldr' :: forall e a b. (a -> b -> b) -> b -> DeviceUseCost e a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> DeviceUseCost e a -> b
$cfoldl :: forall e b a. (b -> a -> b) -> b -> DeviceUseCost e a -> b
foldl :: forall b a. (b -> a -> b) -> b -> DeviceUseCost e a -> b
$cfoldl' :: forall e b a. (b -> a -> b) -> b -> DeviceUseCost e a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> DeviceUseCost e a -> b
$cfoldr1 :: forall e a. (a -> a -> a) -> DeviceUseCost e a -> a
foldr1 :: forall a. (a -> a -> a) -> DeviceUseCost e a -> a
$cfoldl1 :: forall e a. (a -> a -> a) -> DeviceUseCost e a -> a
foldl1 :: forall a. (a -> a -> a) -> DeviceUseCost e a -> a
$ctoList :: forall e a. DeviceUseCost e a -> [a]
toList :: forall a. DeviceUseCost e a -> [a]
$cnull :: forall e a. DeviceUseCost e a -> Bool
null :: forall a. DeviceUseCost e a -> Bool
$clength :: forall e a. DeviceUseCost e a -> Int
length :: forall a. DeviceUseCost e a -> Int
$celem :: forall e a. Eq a => a -> DeviceUseCost e a -> Bool
elem :: forall a. Eq a => a -> DeviceUseCost e a -> Bool
$cmaximum :: forall e a. Ord a => DeviceUseCost e a -> a
maximum :: forall a. Ord a => DeviceUseCost e a -> a
$cminimum :: forall e a. Ord a => DeviceUseCost e a -> a
minimum :: forall a. Ord a => DeviceUseCost e a -> a
$csum :: forall e a. Num a => DeviceUseCost e a -> a
sum :: forall a. Num a => DeviceUseCost e a -> a
$cproduct :: forall e a. Num a => DeviceUseCost e a -> a
product :: forall a. Num a => DeviceUseCost e a -> a
Foldable, Functor (DeviceUseCost e)
Foldable (DeviceUseCost e)
(Functor (DeviceUseCost e), Foldable (DeviceUseCost e)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> DeviceUseCost e a -> f (DeviceUseCost e b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    DeviceUseCost e (f a) -> f (DeviceUseCost e a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> DeviceUseCost e a -> m (DeviceUseCost e b))
-> (forall (m :: * -> *) a.
    Monad m =>
    DeviceUseCost e (m a) -> m (DeviceUseCost e a))
-> Traversable (DeviceUseCost e)
forall e. Functor (DeviceUseCost e)
forall e. Foldable (DeviceUseCost e)
forall e (m :: * -> *) a.
Monad m =>
DeviceUseCost e (m a) -> m (DeviceUseCost e a)
forall e (f :: * -> *) a.
Applicative f =>
DeviceUseCost e (f a) -> f (DeviceUseCost e a)
forall e (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DeviceUseCost e a -> m (DeviceUseCost e b)
forall e (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DeviceUseCost e a -> f (DeviceUseCost e b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
DeviceUseCost e (m a) -> m (DeviceUseCost e a)
forall (f :: * -> *) a.
Applicative f =>
DeviceUseCost e (f a) -> f (DeviceUseCost e a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DeviceUseCost e a -> m (DeviceUseCost e b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DeviceUseCost e a -> f (DeviceUseCost e b)
$ctraverse :: forall e (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DeviceUseCost e a -> f (DeviceUseCost e b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DeviceUseCost e a -> f (DeviceUseCost e b)
$csequenceA :: forall e (f :: * -> *) a.
Applicative f =>
DeviceUseCost e (f a) -> f (DeviceUseCost e a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
DeviceUseCost e (f a) -> f (DeviceUseCost e a)
$cmapM :: forall e (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DeviceUseCost e a -> m (DeviceUseCost e b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DeviceUseCost e a -> m (DeviceUseCost e b)
$csequence :: forall e (m :: * -> *) a.
Monad m =>
DeviceUseCost e (m a) -> m (DeviceUseCost e a)
sequence :: forall (m :: * -> *) a.
Monad m =>
DeviceUseCost e (m a) -> m (DeviceUseCost e a)
Traversable)

-- * Utils

-- | A nonempty list of commands together with an exercise cost for using any of them (typically these will be a list of commands all requiring the same capability).
data CommandsAndCost e = CommandsAndCost
  { forall e. CommandsAndCost e -> ExerciseCost e
commandCost :: ExerciseCost e
  , forall e. CommandsAndCost e -> NonEmpty Const
enabledCommands :: NonEmpty Const
  }

-- | Given mapping from capabilities to their exercise costs provided by a single device, turn it into an mapping from capabilities to their exercise cost and enabled commands.
--
-- NOTE: Because each 'Const' is mapped to at most one
-- 'Capability' by the 'constCaps' function, we know that
-- a given 'Const' will not appear more than once as a value in the 'Map' produced by
-- this function, i.e. for the  capabilities provided by a single 'Entity`
-- ('SingleEntityCapabilities').
commandsForDeviceCaps :: SingleEntityCapabilities e -> Capabilities (CommandsAndCost e)
commandsForDeviceCaps :: forall e.
SingleEntityCapabilities e -> Capabilities (CommandsAndCost e)
commandsForDeviceCaps = Map Capability (CommandsAndCost e)
-> Capabilities (CommandsAndCost e)
forall e. Map Capability e -> Capabilities e
Capabilities (Map Capability (CommandsAndCost e)
 -> Capabilities (CommandsAndCost e))
-> (SingleEntityCapabilities e
    -> Map Capability (CommandsAndCost e))
-> SingleEntityCapabilities e
-> Capabilities (CommandsAndCost e)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Capability -> ExerciseCost e -> Maybe (CommandsAndCost e))
-> Map Capability (ExerciseCost e)
-> Map Capability (CommandsAndCost e)
forall k a b. (k -> a -> Maybe b) -> Map k a -> Map k b
M.mapMaybeWithKey Capability -> ExerciseCost e -> Maybe (CommandsAndCost e)
forall {e}.
Capability -> ExerciseCost e -> Maybe (CommandsAndCost e)
f (Map Capability (ExerciseCost e)
 -> Map Capability (CommandsAndCost e))
-> (SingleEntityCapabilities e -> Map Capability (ExerciseCost e))
-> SingleEntityCapabilities e
-> Map Capability (CommandsAndCost e)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SingleEntityCapabilities e -> Map Capability (ExerciseCost e)
forall e. Capabilities e -> Map Capability e
getMap
 where
  f :: Capability -> ExerciseCost e -> Maybe (CommandsAndCost e)
f Capability
cap ExerciseCost e
xc =
    ExerciseCost e -> NonEmpty Const -> CommandsAndCost e
forall e. ExerciseCost e -> NonEmpty Const -> CommandsAndCost e
CommandsAndCost ExerciseCost e
xc (NonEmpty Const -> CommandsAndCost e)
-> Maybe (NonEmpty Const) -> Maybe (CommandsAndCost e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Capability
-> Map Capability (NonEmpty Const) -> Maybe (NonEmpty Const)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Capability
cap Map Capability (NonEmpty Const)
constByCaps