{-# OPTIONS_GHC -fno-warn-orphans #-}

-- | 'ParameterParser' instances for calamity models
module Calamity.Commands.CalamityParsers () where

import Calamity.Cache.Eff
import Calamity.Commands.Context
import Calamity.Types.Model.Channel (Channel, GuildChannel)
import Calamity.Types.Model.Guild (Emoji, Guild, Member, Partial (PartialEmoji), RawEmoji (..), Role)
import Calamity.Types.Model.User (User)
import Calamity.Types.Partial
import Calamity.Types.Snowflake
import CalamityCommands.ParameterInfo
import CalamityCommands.Parser
import Optics
import Control.Monad
import Control.Monad.Trans (lift)
import Data.Maybe (fromMaybe, isJust)
import qualified Data.Text as T
import Data.Typeable
import qualified Polysemy as P
import qualified Polysemy.Reader as P
import Text.Megaparsec hiding (parse)
import Text.Megaparsec.Char.Lexer (decimal)
import Text.Megaparsec.Error.Builder (errFancy, fancy)

parserName :: forall a c r. ParameterParser a c r => T.Text
parserName :: forall a c (r :: [(* -> *) -> * -> *]).
ParameterParser a c r =>
Text
parserName =
  let ParameterInfo (forall a. a -> Maybe a -> a
fromMaybe Text
"" -> Text
name) TypeRep
type_ Text
_ = forall a c (r :: [(* -> *) -> * -> *]).
ParameterParser a c r =>
ParameterInfo
parameterInfo @a @c @r
   in Text
name forall a. Semigroup a => a -> a -> a
<> Text
":" forall a. Semigroup a => a -> a -> a
<> String -> Text
T.pack (forall a. Show a => a -> String
show TypeRep
type_)

instance Typeable (Snowflake a) => ParameterParser (Snowflake a) c r where
  parse :: Sem (ParserEffs c r) (ParserResult (Snowflake a))
parse = forall c (r :: [(* -> *) -> * -> *]) a.
Text
-> ParsecT SpannedError Text (Sem (Reader c : r)) a
-> Sem (ParserEffs c r) a
parseMP (forall a c (r :: [(* -> *) -> * -> *]).
ParameterParser a c r =>
Text
parserName @(Snowflake a)) forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake
  parameterDescription :: Text
parameterDescription = Text
"discord id"

-- | Accepts both plain IDs and mentions
instance {-# OVERLAPS #-} ParameterParser (Snowflake User) c r where
  parse :: Sem (ParserEffs c r) (ParserResult (Snowflake User))
parse = forall c (r :: [(* -> *) -> * -> *]) a.
Text
-> ParsecT SpannedError Text (Sem (Reader c : r)) a
-> Sem (ParserEffs c r) a
parseMP (forall a c (r :: [(* -> *) -> * -> *]).
ParameterParser a c r =>
Text
parserName @(Snowflake User)) (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (forall e (m :: * -> *) a.
MonadParsec e Text m =>
Text -> m (Snowflake a)
ping Text
"@") forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake)
  parameterDescription :: Text
parameterDescription = Text
"user mention or id"

-- | Accepts both plain IDs and mentions
instance {-# OVERLAPS #-} ParameterParser (Snowflake Member) c r where
  parse :: Sem (ParserEffs c r) (ParserResult (Snowflake Member))
parse = forall c (r :: [(* -> *) -> * -> *]) a.
Text
-> ParsecT SpannedError Text (Sem (Reader c : r)) a
-> Sem (ParserEffs c r) a
parseMP (forall a c (r :: [(* -> *) -> * -> *]).
ParameterParser a c r =>
Text
parserName @(Snowflake Member)) (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (forall e (m :: * -> *) a.
MonadParsec e Text m =>
Text -> m (Snowflake a)
ping Text
"@") forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake)
  parameterDescription :: Text
parameterDescription = Text
"user mention or id"

-- | Accepts both plain IDs and mentions
instance {-# OVERLAPS #-} ParameterParser (Snowflake Channel) c r where
  parse :: Sem (ParserEffs c r) (ParserResult (Snowflake Channel))
parse = forall c (r :: [(* -> *) -> * -> *]) a.
Text
-> ParsecT SpannedError Text (Sem (Reader c : r)) a
-> Sem (ParserEffs c r) a
parseMP (forall a c (r :: [(* -> *) -> * -> *]).
ParameterParser a c r =>
Text
parserName @(Snowflake Channel)) (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (forall e (m :: * -> *) a.
MonadParsec e Text m =>
Text -> m (Snowflake a)
ping Text
"#") forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake)
  parameterDescription :: Text
parameterDescription = Text
"channel mention or id"

-- | Accepts both plain IDs and mentions
instance {-# OVERLAPS #-} ParameterParser (Snowflake Role) c r where
  parse :: Sem (ParserEffs c r) (ParserResult (Snowflake Role))
parse = forall c (r :: [(* -> *) -> * -> *]) a.
Text
-> ParsecT SpannedError Text (Sem (Reader c : r)) a
-> Sem (ParserEffs c r) a
parseMP (forall a c (r :: [(* -> *) -> * -> *]).
ParameterParser a c r =>
Text
parserName @(Snowflake Role)) (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (forall e (m :: * -> *) a.
MonadParsec e Text m =>
Text -> m (Snowflake a)
ping Text
"@&") forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake)
  parameterDescription :: Text
parameterDescription = Text
"role mention or id"

-- | Accepts both plain IDs and uses of emoji
instance {-# OVERLAPS #-} ParameterParser (Snowflake Emoji) c r where
  parse :: Sem (ParserEffs c r) (ParserResult (Snowflake Emoji))
parse = forall c (r :: [(* -> *) -> * -> *]) a.
Text
-> ParsecT SpannedError Text (Sem (Reader c : r)) a
-> Sem (ParserEffs c r) a
parseMP (forall a c (r :: [(* -> *) -> * -> *]).
ParameterParser a c r =>
Text
parserName @(Snowflake Emoji)) (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
emoji forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake)
  parameterDescription :: Text
parameterDescription = Text
"emoji or id"

mapParserMaybeM :: (Monad m, Stream s) => ParsecT SpannedError s m a -> T.Text -> (a -> m (Maybe b)) -> ParsecT SpannedError s m b
mapParserMaybeM :: forall (m :: * -> *) s a b.
(Monad m, Stream s) =>
ParsecT SpannedError s m a
-> Text -> (a -> m (Maybe b)) -> ParsecT SpannedError s m b
mapParserMaybeM ParsecT SpannedError s m a
m Text
e a -> m (Maybe b)
f = do
  Int
offs <- forall e s (m :: * -> *). MonadParsec e s m => m Int
getOffset
  Maybe b
r <- ParsecT SpannedError s m a
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> m (Maybe b)
f
  Int
offe <- forall e s (m :: * -> *). MonadParsec e s m => m Int
getOffset
  case Maybe b
r of
    Just b
r' -> forall (f :: * -> *) a. Applicative f => a -> f a
pure b
r'
    Maybe b
Nothing -> forall e s (m :: * -> *) a.
MonadParsec e s m =>
ParseError s e -> m a
parseError forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall e s. Int -> EF e -> ParseError s e
errFancy Int
offs forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall e. ErrorFancy e -> EF e
fancy forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall e. e -> ErrorFancy e
ErrorCustom forall a b. (a -> b) -> a -> b
$ Text -> Int -> Int -> SpannedError
SpannedError Text
e Int
offs Int
offe

{- | ParameterParser for members in the guild the command was invoked in, this only looks
 in the cache. Use @'Snowflake' 'Member'@ and use
 'Calamity.Types.Upgradeable.upgrade' if you want to allow fetching from http.
-}
instance (P.Member CacheEff r, CalamityCommandContext c) => ParameterParser Member c r where
  parse :: Sem (ParserEffs c r) (ParserResult Member)
parse =
    forall c (r :: [(* -> *) -> * -> *]) a.
Text
-> ParsecT SpannedError Text (Sem (Reader c : r)) a
-> Sem (ParserEffs c r) a
parseMP (forall a c (r :: [(* -> *) -> * -> *]).
ParameterParser a c r =>
Text
parserName @Member @c @r) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) s a b.
(Monad m, Stream s) =>
ParsecT SpannedError s m a
-> Text -> (a -> m (Maybe b)) -> ParsecT SpannedError s m b
mapParserMaybeM
        (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (forall e (m :: * -> *) a.
MonadParsec e Text m =>
Text -> m (Snowflake a)
ping Text
"@") forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake)
        Text
"Couldn't find a Member with this id"
        ( \Snowflake Member
mid -> do
            c
ctx <- forall i (r :: [(* -> *) -> * -> *]).
Member (Reader i) r =>
Sem r i
P.ask
            Maybe Guild
guild <- forall (m :: * -> *) a. Monad m => m (m a) -> m a
join forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (r :: [(* -> *) -> * -> *]).
Member CacheEff r =>
Snowflake Guild -> Sem r (Maybe Guild)
getGuild forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
`traverse` forall c. CalamityCommandContext c => c -> Maybe (Snowflake Guild)
ctxGuildID c
ctx
            forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Maybe Guild
guild forall k s (is :: IxList) a.
Is k An_AffineFold =>
s -> Optic' k is s a -> Maybe a
^? forall a b. Prism (Maybe a) (Maybe b) a b
_Just forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% forall a. IsLabel "members" a => a
#members forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% forall m. Ixed m => Index m -> Optic' (IxKind m) NoIx m (IxValue m)
ix Snowflake Member
mid
        )
  parameterDescription :: Text
parameterDescription = Text
"user mention or id"

{- | ParameterParser for users, this only looks in the cache. Use @'Snowflake'
 'User'@ and use 'Calamity.Types.Upgradeable.upgrade' if you want to allow
 fetching from http.
-}
instance P.Member CacheEff r => ParameterParser User c r where
  parse :: Sem (ParserEffs c r) (ParserResult User)
parse =
    forall c (r :: [(* -> *) -> * -> *]) a.
Text
-> ParsecT SpannedError Text (Sem (Reader c : r)) a
-> Sem (ParserEffs c r) a
parseMP (forall a c (r :: [(* -> *) -> * -> *]).
ParameterParser a c r =>
Text
parserName @User @c @r) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) s a b.
(Monad m, Stream s) =>
ParsecT SpannedError s m a
-> Text -> (a -> m (Maybe b)) -> ParsecT SpannedError s m b
mapParserMaybeM
        (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (forall e (m :: * -> *) a.
MonadParsec e Text m =>
Text -> m (Snowflake a)
ping Text
"@") forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake)
        Text
"Couldn't find a User with this id"
        forall (r :: [(* -> *) -> * -> *]).
Member CacheEff r =>
Snowflake User -> Sem r (Maybe User)
getUser
  parameterDescription :: Text
parameterDescription = Text
"user mention or id"

{- | ParameterParser for channels in the guild the command was invoked in, this only
 looks in the cache. Use @'Snowflake' 'Channel'@ and use
 'Calamity.Types.Upgradeable.upgrade' if you want to allow fetching from http.
-}
instance (P.Member CacheEff r, CalamityCommandContext c) => ParameterParser GuildChannel c r where
  parse :: Sem (ParserEffs c r) (ParserResult GuildChannel)
parse =
    forall c (r :: [(* -> *) -> * -> *]) a.
Text
-> ParsecT SpannedError Text (Sem (Reader c : r)) a
-> Sem (ParserEffs c r) a
parseMP (forall a c (r :: [(* -> *) -> * -> *]).
ParameterParser a c r =>
Text
parserName @GuildChannel @c @r) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) s a b.
(Monad m, Stream s) =>
ParsecT SpannedError s m a
-> Text -> (a -> m (Maybe b)) -> ParsecT SpannedError s m b
mapParserMaybeM
        (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (forall e (m :: * -> *) a.
MonadParsec e Text m =>
Text -> m (Snowflake a)
ping Text
"#") forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake)
        Text
"Couldn't find a GuildChannel with this id"
        ( \Snowflake GuildChannel
cid -> do
            c
ctx <- forall i (r :: [(* -> *) -> * -> *]).
Member (Reader i) r =>
Sem r i
P.ask
            Maybe Guild
guild <- forall (m :: * -> *) a. Monad m => m (m a) -> m a
join forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (r :: [(* -> *) -> * -> *]).
Member CacheEff r =>
Snowflake Guild -> Sem r (Maybe Guild)
getGuild forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
`traverse` forall c. CalamityCommandContext c => c -> Maybe (Snowflake Guild)
ctxGuildID c
ctx
            forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Maybe Guild
guild forall k s (is :: IxList) a.
Is k An_AffineFold =>
s -> Optic' k is s a -> Maybe a
^? forall a b. Prism (Maybe a) (Maybe b) a b
_Just forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% forall a. IsLabel "channels" a => a
#channels forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% forall m. Ixed m => Index m -> Optic' (IxKind m) NoIx m (IxValue m)
ix Snowflake GuildChannel
cid
        )
  parameterDescription :: Text
parameterDescription = Text
"channel mention or id"

{- | ParameterParser for guilds, this only looks in the cache. Use @'Snowflake' 'Guild'@
 and use 'Calamity.Types.Upgradeable.upgrade' if you want to allow fetching
 from http.
-}
instance P.Member CacheEff r => ParameterParser Guild c r where
  parse :: Sem (ParserEffs c r) (ParserResult Guild)
parse =
    forall c (r :: [(* -> *) -> * -> *]) a.
Text
-> ParsecT SpannedError Text (Sem (Reader c : r)) a
-> Sem (ParserEffs c r) a
parseMP (forall a c (r :: [(* -> *) -> * -> *]).
ParameterParser a c r =>
Text
parserName @Guild @c @r) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) s a b.
(Monad m, Stream s) =>
ParsecT SpannedError s m a
-> Text -> (a -> m (Maybe b)) -> ParsecT SpannedError s m b
mapParserMaybeM
        forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake
        Text
"Couldn't find a Guild with this id"
        forall (r :: [(* -> *) -> * -> *]).
Member CacheEff r =>
Snowflake Guild -> Sem r (Maybe Guild)
getGuild
  parameterDescription :: Text
parameterDescription = Text
"guild id"

{- | ParameterParser for emojis in the guild the command was invoked in, this only
 looks in the cache. Use @'Snowflake' 'Emoji'@ and use
 'Calamity.Types.Upgradeable.upgrade' if you want to allow fetching from http.
-}
instance (P.Member CacheEff r, CalamityCommandContext c) => ParameterParser Emoji c r where
  parse :: Sem (ParserEffs c r) (ParserResult Emoji)
parse =
    forall c (r :: [(* -> *) -> * -> *]) a.
Text
-> ParsecT SpannedError Text (Sem (Reader c : r)) a
-> Sem (ParserEffs c r) a
parseMP (forall a c (r :: [(* -> *) -> * -> *]).
ParameterParser a c r =>
Text
parserName @Emoji @c @r) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) s a b.
(Monad m, Stream s) =>
ParsecT SpannedError s m a
-> Text -> (a -> m (Maybe b)) -> ParsecT SpannedError s m b
mapParserMaybeM
        (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
emoji forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake)
        Text
"Couldn't find an Emoji with this id"
        ( \Snowflake Emoji
eid -> do
            c
ctx <- forall i (r :: [(* -> *) -> * -> *]).
Member (Reader i) r =>
Sem r i
P.ask
            Maybe Guild
guild <- forall (m :: * -> *) a. Monad m => m (m a) -> m a
join forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (r :: [(* -> *) -> * -> *]).
Member CacheEff r =>
Snowflake Guild -> Sem r (Maybe Guild)
getGuild forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
`traverse` forall c. CalamityCommandContext c => c -> Maybe (Snowflake Guild)
ctxGuildID c
ctx
            forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Maybe Guild
guild forall k s (is :: IxList) a.
Is k An_AffineFold =>
s -> Optic' k is s a -> Maybe a
^? forall a b. Prism (Maybe a) (Maybe b) a b
_Just forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% forall a. IsLabel "emojis" a => a
#emojis forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% forall m. Ixed m => Index m -> Optic' (IxKind m) NoIx m (IxValue m)
ix Snowflake Emoji
eid
        )
  parameterDescription :: Text
parameterDescription = Text
"emoji or id"

-- | Parses both discord emojis, and unicode emojis
instance ParameterParser RawEmoji c r where
  parse :: Sem (ParserEffs c r) (ParserResult RawEmoji)
parse = forall c (r :: [(* -> *) -> * -> *]) a.
Text
-> ParsecT SpannedError Text (Sem (Reader c : r)) a
-> Sem (ParserEffs c r) a
parseMP (forall a c (r :: [(* -> *) -> * -> *]).
ParameterParser a c r =>
Text
parserName @RawEmoji) (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall {f :: * -> *} {e}. MonadParsec e Text f => f RawEmoji
parseCustomEmoji forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Text -> RawEmoji
UnicodeEmoji forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> Int -> m (Tokens s)
takeP (forall a. a -> Maybe a
Just String
"A unicode emoji") Int
1)
   where
    parseCustomEmoji :: f RawEmoji
parseCustomEmoji = Partial Emoji -> RawEmoji
CustomEmoji forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e (m :: * -> *). MonadParsec e Text m => m (Partial Emoji)
partialEmoji
  parameterDescription :: Text
parameterDescription = Text
"emoji"

{- | ParameterParser for roles in the guild the command was invoked in, this only
 looks in the cache. Use @'Snowflake' 'Role'@ and use
 'Calamity.Types.Upgradeable.upgrade' if you want to allow fetching from http.
-}
instance (P.Member CacheEff r, CalamityCommandContext c) => ParameterParser Role c r where
  parse :: Sem (ParserEffs c r) (ParserResult Role)
parse =
    forall c (r :: [(* -> *) -> * -> *]) a.
Text
-> ParsecT SpannedError Text (Sem (Reader c : r)) a
-> Sem (ParserEffs c r) a
parseMP (forall a c (r :: [(* -> *) -> * -> *]).
ParameterParser a c r =>
Text
parserName @Role @c @r) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) s a b.
(Monad m, Stream s) =>
ParsecT SpannedError s m a
-> Text -> (a -> m (Maybe b)) -> ParsecT SpannedError s m b
mapParserMaybeM
        (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (forall e (m :: * -> *) a.
MonadParsec e Text m =>
Text -> m (Snowflake a)
ping Text
"@&") forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake)
        Text
"Couldn't find an Emoji with this id"
        ( \Snowflake Role
rid -> do
            c
ctx <- forall i (r :: [(* -> *) -> * -> *]).
Member (Reader i) r =>
Sem r i
P.ask
            Maybe Guild
guild <- forall (m :: * -> *) a. Monad m => m (m a) -> m a
join forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (r :: [(* -> *) -> * -> *]).
Member CacheEff r =>
Snowflake Guild -> Sem r (Maybe Guild)
getGuild forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
`traverse` forall c. CalamityCommandContext c => c -> Maybe (Snowflake Guild)
ctxGuildID c
ctx
            forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Maybe Guild
guild forall k s (is :: IxList) a.
Is k An_AffineFold =>
s -> Optic' k is s a -> Maybe a
^? forall a b. Prism (Maybe a) (Maybe b) a b
_Just forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% forall a. IsLabel "roles" a => a
#roles forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% forall m. Ixed m => Index m -> Optic' (IxKind m) NoIx m (IxValue m)
ix Snowflake Role
rid
        )
  parameterDescription :: Text
parameterDescription = Text
"role mention or id"

-- skipN :: (Stream s, Ord e) => Int -> ParsecT e s m ()
-- skipN n = void $ takeP Nothing n

ping :: MonadParsec e T.Text m => T.Text -> m (Snowflake a)
ping :: forall e (m :: * -> *) a.
MonadParsec e Text m =>
Text -> m (Snowflake a)
ping Text
c = forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (Text
"<" forall a. Semigroup a => a -> a -> a
<> Text
c) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"!") forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
">"

ping' :: MonadParsec e T.Text m => m () -> m (Snowflake a)
ping' :: forall e (m :: * -> *) a.
MonadParsec e Text m =>
m () -> m (Snowflake a)
ping' m ()
m = forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"<" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m ()
m forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
">"

snowflake :: MonadParsec e T.Text m => m (Snowflake a)
snowflake :: forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake = forall t. Word64 -> Snowflake t
Snowflake forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
decimal

partialEmoji :: MonadParsec e T.Text m => m (Partial Emoji)
partialEmoji :: forall e (m :: * -> *). MonadParsec e Text m => m (Partial Emoji)
partialEmoji = do
  Bool
animated <- forall a. Maybe a -> Bool
isJust forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"<" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"a"))
  Text
name <- forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
":") (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
":") (forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
takeWhileP (forall a. a -> Maybe a
Just String
"Emoji name") (forall a. Eq a => a -> a -> Bool
/= Char
':'))
  Snowflake Emoji
id <- forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
snowflake
  forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
">"
  forall (f :: * -> *) a. Applicative f => a -> f a
pure (Snowflake Emoji -> Text -> Bool -> Partial Emoji
PartialEmoji Snowflake Emoji
id Text
name Bool
animated)

emoji :: MonadParsec e T.Text m => m (Snowflake a)
emoji :: forall e (m :: * -> *) a. MonadParsec e Text m => m (Snowflake a)
emoji = forall e (m :: * -> *) a.
MonadParsec e Text m =>
m () -> m (Snowflake a)
ping' (forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
"a") forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
":") (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk Tokens Text
":") (forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
takeWhileP forall a. Maybe a
Nothing (forall a. Eq a => a -> a -> Bool
/= Char
':')))

-- trackOffsets :: MonadParsec e s m => m a -> m (a, Int)
-- trackOffsets m = do
--   offs <- getOffset
--   a <- m
--   offe <- getOffset
--   pure (a, offe - offs)

-- item :: MonadParsec e L.Text m => m L.Text
-- item = try quotedString <|> someNonWS

-- manySingle :: MonadParsec e s m => m (Tokens s)
-- manySingle = takeWhileP (Just "Any character") (const True)

-- someSingle :: MonadParsec e s m => m (Tokens s)
-- someSingle = takeWhile1P (Just "any character") (const True)

-- quotedString :: MonadParsec e L.Text m => m L.Text
-- quotedString = try (between (chunk "'") (chunk "'") (takeWhileP (Just "any character") (/= '\''))) <|>
--                between (chunk "\"") (chunk "\"") (takeWhileP (Just "any character") (/= '"'))

-- -- manyNonWS :: (Token s ~ Char, MonadParsec e s m) => m (Tokens s)
-- -- manyNonWS = takeWhileP (Just "Any Non-Whitespace") (not . isSpace)

-- someNonWS :: (Token s ~ Char, MonadParsec e s m) => m (Tokens s)
-- someNonWS = takeWhile1P (Just "any non-whitespace") (not . isSpace)