discord_gleam - v2.1.1

discord_gleam/event_handler

Types

HandlerMessage

</>

The message type for the event handler with custom user messages

pub type HandlerMessage(user_message) {
  DiscordPacket(Packet)
  User(user_message)
}

Constructors 

  • DiscordPacket(Packet)
  • User(user_message)

InternalMessage

</>

The message type received from event loop

pub type InternalMessage(user_message) {
  InternalPacket(String)
  InternalUser(user_message)
}

Constructors 

  • InternalPacket(String)
  • InternalUser(user_message)

Mode

</>

The mode of the event handler

Simple mode is used for simple bots that don’t need to handle custom user state and messages. default_next and nil_state fields are required for proper type inference. Recommended to use Nil state and continue with no selector.

Normal mode is used for bots that need to handle custom user state and messages.

pub type Mode(user_state, user_message) {
  Simple(
    bot: bot.Bot,
    handlers: List(fn(bot.Bot, Packet) -> Nil),
    default_next: Next(user_state, user_message),
    nil_state: user_state,
  )
  Normal(
    bot: bot.Bot,
    name: process.Name(user_message),
    on_init: fn(process.Selector(user_message)) -> #(
      user_state,
      process.Selector(user_message),
    ),
    handler: fn(bot.Bot, user_state, HandlerMessage(user_message)) -> Next(
      user_state,
      user_message,
    ),
  )
}

Constructors

Next

</>

Instruction on how event loop actor should proceed after handling an event

pub type Next(new_state, user_message) {
  Continue(
    new_state,
    option.Option(process.Selector(user_message)),
  )
  Stop
  StopAbnormal(reason: String)
}

Constructors

Packet

</>

The supported discord packets

pub type Packet {
  ReadyPacket(ready.ReadyPacket)
  InteractionCreatePacket(
    interaction_create.InteractionCreatePacket,
  )
  MessageDeletePacket(message_delete.MessageDeletePacket)
  MessagePacket(message.MessagePacket)
  MessageUpdatePacket(message_update.MessageUpdatePacket)
  MessageDeleteBulkPacket(
    message_delete_bulk.MessageDeleteBulkPacket,
  )
  ChannelCreatePacket(channel_create.ChannelCreatePacket)
  ChannelDeletePacket(channel_delete.ChannelDeletePacket)
  ChannelUpdatePacket(channel_update.ChannelUpdatePacket)
  GuildBanAddPacket(guild_ban_add.GuildBanAddPacket)
  GuildBanRemovePacket(guild_ban_remove.GuildBanRemovePacket)
  GuildRoleCreatePacket(guild_role_create.GuildRoleCreatePacket)
  GuildRoleUpdatePacket(guild_role_update.GuildRoleUpdatePacket)
  GuildRoleDeletePacket(guild_role_delete.GuildRoleDeletePacket)
  GuildMemberAddPacket(guild_member_add.GuildMemberAdd)
  GuildMemberUpdatePacket(guild_member_update.GuildMemberUpdate)
  GuildMemberRemovePacket(guild_member_remove.GuildMemberRemove)
  GuildMembersChunkPacket(
    guild_members_chunk.GuildMembersChunkPacket,
  )
  PresenceUpdatePacket(presence_update.PresenceUpdatePacket)
  UnknownPacket(generic.GenericPacket)
}

Constructors

Values

bot_from_mode

</> 
pub fn bot_from_mode(
  mode: Mode(user_state, user_message),
) -> bot.Bot

Get the bot from all possible modes

handle_event

</> 
pub fn handle_event(
  bot: bot.Bot,
  user_state: user_state,
  msg: InternalMessage(user_message),
  mode: Mode(user_state, user_message),
  state_ets: booklet.Booklet(dict.Dict(String, String)),
) -> Next(user_state, user_message)

Handle an event from the Discord API, using a current handler mode, state and internal message.

name_from_mode

</> 
pub fn name_from_mode(
  mode: Mode(user_state, user_message),
) -> Result(process.Name(user_message), Nil)

Check if the mode is normal mode

set_bot

</> 
pub fn set_bot(
  mode: Mode(user_state, user_message),
  bot: bot.Bot,
) -> Mode(user_state, user_message)
✨ Search Document