-- |
-- Module      :  Swarm.Language.Capability
-- Copyright   :  Brent Yorgey
-- Maintainer  :  byorgey@gmail.com
--
-- SPDX-License-Identifier: BSD-3-Clause
--
-- Capabilities needed to evaluate and execute programs.  Language
-- constructs or commands require certain capabilities, and in turn
-- capabilities are provided by various devices.  A robot must have an
-- appropriate device installed in order to make use of each language
-- construct or command.
module Swarm.Language.Capability (
  Capability (..),
  capabilityName,
  constCaps,
) where

import Data.Aeson (FromJSONKey, ToJSONKey)
import Data.Char (toLower)
import Data.Data (Data)
import Data.Hashable (Hashable)
import Data.Text (Text)
import Data.Text qualified as T
import Data.Yaml
import GHC.Generics (Generic)
import Swarm.Language.Syntax
import Text.Read (readMaybe)
import Witch (from)
import Prelude hiding (lookup)

-- | Various capabilities which robots can have.
data Capability
  = -- | Be powered, i.e. execute anything at all
    CPower
  | -- | Execute the 'Move' command
    CMove
  | -- | Execute the 'Move' command for a heavy robot
    CMoveheavy
  | -- | Execute the 'Turn' command
    --
    -- NOTE: using cardinal directions is separate 'COrient' capability
    CTurn
  | -- | Execute the 'Selfdestruct' command
    CSelfdestruct
  | -- | Execute the 'Grab' command
    CGrab
  | -- | Execute the 'Harvest' command
    CHarvest
  | -- | Execute the 'Place' command
    CPlace
  | -- | Execute the 'Give' command
    CGive
  | -- | Execute the 'Install' command
    CInstall
  | -- | Execute the 'Make' command
    CMake
  | -- | Execute the 'Count' command
    CCount
  | -- | Execute the 'Build' command
    CBuild
  | -- | Execute the 'Salvage' command
    CSalvage
  | -- | Execute the 'Drill' command
    CDrill
  | -- | Execute the 'Whereami' command
    CSenseloc
  | -- | Execute the 'Blocked' command
    CSensefront
  | -- | Execute the 'Ishere' command
    CSensehere
  | -- | Execute the 'Scan' command
    CScan
  | -- | Execute the 'Random' command
    CRandom
  | -- | Execute the 'Appear' command
    CAppear
  | -- | Execute the 'Create' command
    CCreate
  | -- | Execute the 'Listen' command and passively log messages if also has 'CLog'
    CListen
  | -- | Execute the 'Log' command
    CLog
  | -- | Manipulate text values
    CText
  | -- | Don't drown in liquid
    CFloat
  | -- | Evaluate conditional expressions
    CCond
  | -- | Negate boolean value
    CNegation
  | -- | Evaluate comparison operations
    CCompare
  | -- | Use cardinal direction constants.
    COrient
  | -- | Evaluate arithmetic operations
    CArith
  | -- | Store and look up definitions in an environment
    CEnv
  | -- | Interpret lambda abstractions
    CLambda
  | -- | Enable recursive definitions
    CRecursion
  | -- | Execute the 'Reprogram' command
    CReprogram
  | -- | Capability to introspect and see its own name
    CWhoami
  | -- | Capability to set its own name
    CSetname
  | -- | Capability to move unrestricted to any place
    CTeleport
  | -- | Capability to run commands atomically
    CAtomic
  | -- | Capability to execute swap (grab and place atomically at the same time).
    CSwap
  | -- | Capabiltiy to do time-related things, like `wait` and get the
    --   current time.
    CTime
  | -- | Capability to execute `try`.
    CTry
  | -- | Capability for working with sum types.
    CSum
  | -- | Capability for working with product types.
    CProd
  | -- | God-like capabilities.  For e.g. commands intended only for
    --   checking challenge mode win conditions, and not for use by
    --   players.
    CGod
  deriving (Capability -> Capability -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Capability -> Capability -> Bool
$c/= :: Capability -> Capability -> Bool
== :: Capability -> Capability -> Bool
$c== :: Capability -> Capability -> Bool
Eq, Eq Capability
Capability -> Capability -> Bool
Capability -> Capability -> Ordering
Capability -> Capability -> Capability
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
min :: Capability -> Capability -> Capability
$cmin :: Capability -> Capability -> Capability
max :: Capability -> Capability -> Capability
$cmax :: Capability -> Capability -> Capability
>= :: Capability -> Capability -> Bool
$c>= :: Capability -> Capability -> Bool
> :: Capability -> Capability -> Bool
$c> :: Capability -> Capability -> Bool
<= :: Capability -> Capability -> Bool
$c<= :: Capability -> Capability -> Bool
< :: Capability -> Capability -> Bool
$c< :: Capability -> Capability -> Bool
compare :: Capability -> Capability -> Ordering
$ccompare :: Capability -> Capability -> Ordering
Ord, Int -> Capability -> ShowS
[Capability] -> ShowS
Capability -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Capability] -> ShowS
$cshowList :: [Capability] -> ShowS
show :: Capability -> String
$cshow :: Capability -> String
showsPrec :: Int -> Capability -> ShowS
$cshowsPrec :: Int -> Capability -> ShowS
Show, ReadPrec [Capability]
ReadPrec Capability
Int -> ReadS Capability
ReadS [Capability]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Capability]
$creadListPrec :: ReadPrec [Capability]
readPrec :: ReadPrec Capability
$creadPrec :: ReadPrec Capability
readList :: ReadS [Capability]
$creadList :: ReadS [Capability]
readsPrec :: Int -> ReadS Capability
$creadsPrec :: Int -> ReadS Capability
Read, Int -> Capability
Capability -> Int
Capability -> [Capability]
Capability -> Capability
Capability -> Capability -> [Capability]
Capability -> Capability -> Capability -> [Capability]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Capability -> Capability -> Capability -> [Capability]
$cenumFromThenTo :: Capability -> Capability -> Capability -> [Capability]
enumFromTo :: Capability -> Capability -> [Capability]
$cenumFromTo :: Capability -> Capability -> [Capability]
enumFromThen :: Capability -> Capability -> [Capability]
$cenumFromThen :: Capability -> Capability -> [Capability]
enumFrom :: Capability -> [Capability]
$cenumFrom :: Capability -> [Capability]
fromEnum :: Capability -> Int
$cfromEnum :: Capability -> Int
toEnum :: Int -> Capability
$ctoEnum :: Int -> Capability
pred :: Capability -> Capability
$cpred :: Capability -> Capability
succ :: Capability -> Capability
$csucc :: Capability -> Capability
Enum, Capability
forall a. a -> a -> Bounded a
maxBound :: Capability
$cmaxBound :: Capability
minBound :: Capability
$cminBound :: Capability
Bounded, forall x. Rep Capability x -> Capability
forall x. Capability -> Rep Capability x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Capability x -> Capability
$cfrom :: forall x. Capability -> Rep Capability x
Generic, Eq Capability
Int -> Capability -> Int
Capability -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Capability -> Int
$chash :: Capability -> Int
hashWithSalt :: Int -> Capability -> Int
$chashWithSalt :: Int -> Capability -> Int
Hashable, Typeable Capability
Capability -> DataType
Capability -> Constr
(forall b. Data b => b -> b) -> Capability -> Capability
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) -> Capability -> u
forall u. (forall d. Data d => d -> u) -> Capability -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Capability -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Capability -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Capability -> m Capability
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Capability -> m Capability
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Capability
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Capability -> c Capability
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Capability)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Capability)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Capability -> m Capability
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Capability -> m Capability
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Capability -> m Capability
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Capability -> m Capability
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Capability -> m Capability
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Capability -> m Capability
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Capability -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Capability -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Capability -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Capability -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Capability -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Capability -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Capability -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Capability -> r
gmapT :: (forall b. Data b => b -> b) -> Capability -> Capability
$cgmapT :: (forall b. Data b => b -> b) -> Capability -> Capability
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Capability)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Capability)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Capability)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Capability)
dataTypeOf :: Capability -> DataType
$cdataTypeOf :: Capability -> DataType
toConstr :: Capability -> Constr
$ctoConstr :: Capability -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Capability
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Capability
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Capability -> c Capability
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Capability -> c Capability
Data, FromJSONKeyFunction [Capability]
FromJSONKeyFunction Capability
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [Capability]
$cfromJSONKeyList :: FromJSONKeyFunction [Capability]
fromJSONKey :: FromJSONKeyFunction Capability
$cfromJSONKey :: FromJSONKeyFunction Capability
FromJSONKey, ToJSONKeyFunction [Capability]
ToJSONKeyFunction Capability
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [Capability]
$ctoJSONKeyList :: ToJSONKeyFunction [Capability]
toJSONKey :: ToJSONKeyFunction Capability
$ctoJSONKey :: ToJSONKeyFunction Capability
ToJSONKey)

capabilityName :: Capability -> Text
capabilityName :: Capability -> Text
capabilityName = forall source target. From source target => source -> target
from @String forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> [a] -> [a]
drop Int
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show

instance ToJSON Capability where
  toJSON :: Capability -> Value
toJSON = Text -> Value
String forall b c a. (b -> c) -> (a -> b) -> a -> c
. Capability -> Text
capabilityName

instance FromJSON Capability where
  parseJSON :: Value -> Parser Capability
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"Capability" Text -> Parser Capability
tryRead
   where
    tryRead :: Text -> Parser Capability
    tryRead :: Text -> Parser Capability
tryRead Text
t = case forall a. Read a => String -> Maybe a
readMaybe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall source target. From source target => source -> target
from forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Text -> Text
T.cons Char
'C' forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
T.toTitle forall a b. (a -> b) -> a -> b
$ Text
t of
      Just Capability
c -> forall (m :: * -> *) a. Monad m => a -> m a
return Capability
c
      Maybe Capability
Nothing -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Unknown capability " forall a. [a] -> [a] -> [a]
++ forall source target. From source target => source -> target
from Text
t

-- | Capabilities needed to evaluate or execute a constant.
constCaps :: Const -> Maybe Capability
constCaps :: Const -> Maybe Capability
constCaps = \case
  -- ----------------------------------------------------------------
  -- Some built-in constants that don't require any special capability.
  Const
Noop -> forall a. Maybe a
Nothing
  Const
AppF -> forall a. Maybe a
Nothing
  Const
Force -> forall a. Maybe a
Nothing
  Const
Return -> forall a. Maybe a
Nothing
  Const
Parent -> forall a. Maybe a
Nothing
  Const
Base -> forall a. Maybe a
Nothing
  Const
Setname -> forall a. Maybe a
Nothing
  Const
Undefined -> forall a. Maybe a
Nothing
  Const
Fail -> forall a. Maybe a
Nothing
  Const
Has -> forall a. Maybe a
Nothing
  Const
Installed -> forall a. Maybe a
Nothing
  -- speaking is natural to robots (unlike listening)
  Const
Say -> forall a. Maybe a
Nothing
  -- TODO: #495
  --   the require command will be inlined once the Issue is fixed
  --   so the capabilities of the run commands will be checked instead
  Const
Run -> forall a. Maybe a
Nothing
  -- ----------------------------------------------------------------
  -- Some straightforward ones.
  Const
Listen -> forall a. a -> Maybe a
Just Capability
CListen
  Const
Log -> forall a. a -> Maybe a
Just Capability
CLog
  Const
Selfdestruct -> forall a. a -> Maybe a
Just Capability
CSelfdestruct
  Const
Move -> forall a. a -> Maybe a
Just Capability
CMove
  Const
Turn -> forall a. a -> Maybe a
Just Capability
CTurn
  Const
Grab -> forall a. a -> Maybe a
Just Capability
CGrab
  Const
Harvest -> forall a. a -> Maybe a
Just Capability
CHarvest
  Const
Place -> forall a. a -> Maybe a
Just Capability
CPlace
  Const
Give -> forall a. a -> Maybe a
Just Capability
CGive
  Const
Install -> forall a. a -> Maybe a
Just Capability
CInstall
  Const
Make -> forall a. a -> Maybe a
Just Capability
CMake
  Const
Count -> forall a. a -> Maybe a
Just Capability
CCount
  Const
If -> forall a. a -> Maybe a
Just Capability
CCond
  Const
Blocked -> forall a. a -> Maybe a
Just Capability
CSensefront
  Const
Scan -> forall a. a -> Maybe a
Just Capability
CScan
  Const
Ishere -> forall a. a -> Maybe a
Just Capability
CSensehere
  Const
Upload -> forall a. a -> Maybe a
Just Capability
CScan
  Const
Build -> forall a. a -> Maybe a
Just Capability
CBuild
  Const
Salvage -> forall a. a -> Maybe a
Just Capability
CSalvage
  Const
Reprogram -> forall a. a -> Maybe a
Just Capability
CReprogram
  Const
Drill -> forall a. a -> Maybe a
Just Capability
CDrill
  Const
Neg -> forall a. a -> Maybe a
Just Capability
CArith
  Const
Add -> forall a. a -> Maybe a
Just Capability
CArith
  Const
Sub -> forall a. a -> Maybe a
Just Capability
CArith
  Const
Mul -> forall a. a -> Maybe a
Just Capability
CArith
  Const
Div -> forall a. a -> Maybe a
Just Capability
CArith
  Const
Exp -> forall a. a -> Maybe a
Just Capability
CArith
  Const
Whoami -> forall a. a -> Maybe a
Just Capability
CWhoami
  Const
Self -> forall a. a -> Maybe a
Just Capability
CWhoami
  Const
Swap -> forall a. a -> Maybe a
Just Capability
CSwap
  Const
Atomic -> forall a. a -> Maybe a
Just Capability
CAtomic
  Const
Time -> forall a. a -> Maybe a
Just Capability
CTime
  Const
Wait -> forall a. a -> Maybe a
Just Capability
CTime
  -- ----------------------------------------------------------------
  -- Text operations
  Const
Format -> forall a. a -> Maybe a
Just Capability
CText
  Const
Concat -> forall a. a -> Maybe a
Just Capability
CText
  Const
Split -> forall a. a -> Maybe a
Just Capability
CText
  Const
Chars -> forall a. a -> Maybe a
Just Capability
CText
  -- ----------------------------------------------------------------
  -- Some God-like abilities.
  Const
As -> forall a. a -> Maybe a
Just Capability
CGod
  Const
RobotNamed -> forall a. a -> Maybe a
Just Capability
CGod
  Const
RobotNumbered -> forall a. a -> Maybe a
Just Capability
CGod
  Const
Create -> forall a. a -> Maybe a
Just Capability
CGod
  -- ----------------------------------------------------------------
  -- arithmetic
  Const
Eq -> forall a. a -> Maybe a
Just Capability
CCompare
  Const
Neq -> forall a. a -> Maybe a
Just Capability
CCompare
  Const
Lt -> forall a. a -> Maybe a
Just Capability
CCompare
  Const
Gt -> forall a. a -> Maybe a
Just Capability
CCompare
  Const
Leq -> forall a. a -> Maybe a
Just Capability
CCompare
  Const
Geq -> forall a. a -> Maybe a
Just Capability
CCompare
  -- ----------------------------------------------------------------
  -- boolean logic
  Const
And -> forall a. a -> Maybe a
Just Capability
CCond
  Const
Or -> forall a. a -> Maybe a
Just Capability
CCond
  Const
Not -> forall a. a -> Maybe a
Just Capability
CNegation
  -- ----------------------------------------------------------------
  -- exceptions
  Const
Try -> forall a. a -> Maybe a
Just Capability
CTry
  -- ----------------------------------------------------------------
  -- type-level arithmetic
  Const
Inl -> forall a. a -> Maybe a
Just Capability
CSum
  Const
Inr -> forall a. a -> Maybe a
Just Capability
CSum
  Const
Case -> forall a. a -> Maybe a
Just Capability
CSum
  Const
Fst -> forall a. a -> Maybe a
Just Capability
CProd
  Const
Snd -> forall a. a -> Maybe a
Just Capability
CProd
  -- XXX pair syntax should require CProd too

  -- ----------------------------------------------------------------
  -- Some additional straightforward ones, which however currently
  -- cannot be used in classic mode since there is no craftable item
  -- which conveys their capability. TODO: #26
  Const
Teleport -> forall a. a -> Maybe a
Just Capability
CTeleport -- Some space-time machine like Tardis?
  Const
Appear -> forall a. a -> Maybe a
Just Capability
CAppear -- paint?
  Const
Whereami -> forall a. a -> Maybe a
Just Capability
CSenseloc -- GPS?
  Const
Random -> forall a. a -> Maybe a
Just Capability
CRandom -- randomness device (with bitcoins)?
  -- ----------------------------------------------------------------
  -- Some more constants which *ought* to have their own capability but
  -- currently don't. TODO: #26
  Const
View -> forall a. Maybe a
Nothing -- XXX this should also require something.
  Const
Knows -> forall a. Maybe a
Nothing