{-# LANGUAGE OverloadedStrings #-}

-- |
-- 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 equipped 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 Swarm.Util (failT)
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 'Backup' command
    CBackup
  | -- | Execute the 'Path' command
    CPath
  | -- | Execute the 'Push' command
    CPush
  | -- | Execute the 'Stride' command
    CMovemultiple
  | -- | 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 'Ignite' command
    CIgnite
  | -- | Execute the 'Place' command
    CPlace
  | -- | Execute the 'Ping' command
    CPing
  | -- | Execute the 'Give' command
    CGive
  | -- | Execute the 'Equip' command
    CEquip
  | -- | Execute the 'Unequip' command
    CUnequip
  | -- | Execute the 'Make' command
    CMake
  | -- | Execute the 'Count' command
    CCount
  | -- | Execute the 'Scout' command. Reconnaissance along a line in a direction.
    CRecondir
  | -- | Execute the 'Build' command
    CBuild
  | -- | Execute the 'Salvage' command
    CSalvage
  | -- | Execute the 'Drill' command
    CDrill
  | -- | Execute the 'Waypoint' command
    CWaypoint
  | -- | Execute the 'Whereami' command
    CSenseloc
  | -- | Execute the 'Blocked' command
    CSensefront
  | -- | Execute the 'Ishere' and 'Isempty' commands
    CSensehere
  | -- | Execute the 'Detect' command
    CDetectloc
  | -- | Execute the 'Resonate' and 'Density' commands
    CDetectcount
  | -- | Execute the 'Sniff' command
    CDetectdistance
  | -- | Execute the 'Chirp' command
    CDetectdirection
  | -- | Execute the 'Watch' command
    CWakeself
  | -- | 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
  | -- | Format values as text
    CFormat
  | -- | Split text into two pieces
    CConcat
  | -- | Join two text values into one
    CSplit
  | -- | Count the characters in a text value
    CCharcount
  | -- | Convert between characters/text and Unicode values
    CCode
  | -- | 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
  | -- | Execute the `meet` and `meetAll` commands.
    CMeet
  | -- | 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
  | -- | Capability to obtain absolute time, namely via the `time` command.
    CTimeabs
  | -- | Capability to utilize relative passage of time, namely via the `wait` command.
    --   This is strictly weaker than "CTimeAbs".
    CTimerel
  | -- | Capability to execute `try`.
    CTry
  | -- | Capability for working with sum types.
    CSum
  | -- | Capability for working with product types.
    CProd
  | -- | Capability for working with record types.
    CRecord
  | -- | Debug capability.
    CDebug
  | -- | Capability to handle keyboard input.
    CHandleinput
  | -- | Capability to make other robots halt.
    CHalt
  | -- | 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 => [Text] -> m a
failT [Text
"Unknown capability", 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
Equipped -> 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
Backup -> forall a. a -> Maybe a
Just Capability
CBackup
  Const
Path -> forall a. a -> Maybe a
Just Capability
CPath
  Const
Push -> forall a. a -> Maybe a
Just Capability
CPush
  Const
Stride -> forall a. a -> Maybe a
Just Capability
CMovemultiple
  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
Ignite -> forall a. a -> Maybe a
Just Capability
CIgnite
  Const
Place -> forall a. a -> Maybe a
Just Capability
CPlace
  Const
Ping -> forall a. a -> Maybe a
Just Capability
CPing
  Const
Give -> forall a. a -> Maybe a
Just Capability
CGive
  Const
Equip -> forall a. a -> Maybe a
Just Capability
CEquip
  Const
Unequip -> forall a. a -> Maybe a
Just Capability
CUnequip
  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
Isempty -> 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
Meet -> forall a. a -> Maybe a
Just Capability
CMeet
  Const
MeetAll -> forall a. a -> Maybe a
Just Capability
CMeet
  Const
Drill -> forall a. a -> Maybe a
Just Capability
CDrill
  Const
Use -> forall a. Maybe a
Nothing -- Recipes alone shall dictate whether things can be "used"
  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
Instant -> forall a. a -> Maybe a
Just Capability
CGod
  Const
Time -> forall a. a -> Maybe a
Just Capability
CTimeabs
  Const
Wait -> forall a. a -> Maybe a
Just Capability
CTimerel
  Const
Scout -> forall a. a -> Maybe a
Just Capability
CRecondir
  Const
Whereami -> forall a. a -> Maybe a
Just Capability
CSenseloc
  Const
Waypoint -> forall a. a -> Maybe a
Just Capability
CWaypoint
  Const
Detect -> forall a. a -> Maybe a
Just Capability
CDetectloc
  Const
Resonate -> forall a. a -> Maybe a
Just Capability
CDetectcount
  Const
Density -> forall a. a -> Maybe a
Just Capability
CDetectcount
  Const
Sniff -> forall a. a -> Maybe a
Just Capability
CDetectdistance
  Const
Chirp -> forall a. a -> Maybe a
Just Capability
CDetectdirection
  Const
Watch -> forall a. a -> Maybe a
Just Capability
CWakeself
  Const
Heading -> forall a. a -> Maybe a
Just Capability
COrient
  Const
Key -> forall a. a -> Maybe a
Just Capability
CHandleinput
  Const
InstallKeyHandler -> forall a. a -> Maybe a
Just Capability
CHandleinput
  Const
Halt -> forall a. a -> Maybe a
Just Capability
CHalt
  -- ----------------------------------------------------------------
  -- Text operations
  Const
Format -> forall a. a -> Maybe a
Just Capability
CFormat
  Const
Concat -> forall a. a -> Maybe a
Just Capability
CConcat
  Const
Split -> forall a. a -> Maybe a
Just Capability
CSplit
  Const
Chars -> forall a. a -> Maybe a
Just Capability
CCharcount
  Const
CharAt -> forall a. a -> Maybe a
Just Capability
CCode
  Const
ToChar -> forall a. a -> Maybe a
Just Capability
CCode
  -- ----------------------------------------------------------------
  -- 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
  Const
Surveil -> 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
  -- TODO: #563 pair syntax (1,2,3...) 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
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.
  Const
View -> forall a. Maybe a
Nothing -- TODO: #17 should require equipping an antenna
  Const
Knows -> forall a. Maybe a
Nothing