Reimplement !vc parsing with Either

src/main/kotlin/moe/kageru/kagebot/features/TempVCFeature.kt

@@ -1,5 +1,9 @@
 package moe.kageru.kagebot.features
 
+import arrow.core.Either
+import arrow.core.filterOrElse
+import arrow.core.flatMap
+import arrow.core.rightIfNotNull
 import com.fasterxml.jackson.annotation.JsonProperty
 import moe.kageru.kagebot.Log
 import moe.kageru.kagebot.Util.asOption
@@ -10,24 +14,22 @@ import org.javacord.api.DiscordApi
 import org.javacord.api.entity.channel.ChannelCategory
 import org.javacord.api.entity.channel.ServerVoiceChannel
 import org.javacord.api.event.message.MessageCreateEvent
-import java.util.concurrent.CompletionException
 
 class TempVCFeature(@JsonProperty("category") category: String? = null) : EventFeature, MessageFeature {
     private val category: ChannelCategory? = category?.let { Config.server.categoriesByName(it).first() }
 
-    override fun handle(message: MessageCreateEvent) {
+    override fun handle(message: MessageCreateEvent): Unit = with(message) {
-        if (" " !in message.readableMessageContent) {
+        Either.cond(' ' in readableMessageContent,
-            message.channel.sendMessage("Invalid syntax, expected 2 arguments")
+            { readableMessageContent.split(' ', limit = 2).last() },
-            return
+            { "Invalid syntax, expected `<command> <userlimit>`" })
-        }
+            .flatMap { limit ->
-        val (_, limit) = message.readableMessageContent.split(" ", limit = 2)
+                limit.toIntOrNull().rightIfNotNull { "Invalid syntax, expected a number as limit, got $limit" }
-        limit.toLongOrNull()?.let { parsedLimit ->
+            }.filterOrElse({ it < 99 }, { "Error: can’t create a channel with that many users." })
-            if (parsedLimit > 99) {
+            .fold({ err -> channel.sendMessage(err) },
-                message.channel.sendMessage("You can’t create a channel with that many users.")
+                { limit ->
-            }
+                    createChannel(message, limit)
-            createChannel(message, parsedLimit)
+                    channel.sendMessage("Done")
-            message.channel.sendMessage("Done")
+                })
-        } ?: message.channel.sendMessage("Invalid syntax, expected a number, got $limit")
     }
 
     override fun register(api: DiscordApi) {
@@ -44,22 +46,16 @@ class TempVCFeature(@JsonProperty("category") category: String? = null) : EventF
             { Dao.removeTemporaryVC(channel.idAsString) }
         )
 
-    private fun createChannel(message: MessageCreateEvent, limit: Long) {
+    private fun createChannel(message: MessageCreateEvent, limit: Int): Unit =
-        val creation = Config.server.createVoiceChannelBuilder().apply {
+        Config.server.createVoiceChannelBuilder().apply {
-            setUserlimit(limit.toInt())
+            setUserlimit(limit)
             setName(generateChannelName(message))
             setAuditLogReason("Created temporary VC for user ${message.messageAuthor.discriminatedName}")
-            category?.let { setCategory(it) }
+            setCategory(category)
-        }.create()
+        }.create().asOption().fold(
-        try {
+            { Log.warn("Attempted to create temporary VC without the necessary permissions") },
-            val channel = creation.join()
+            { channel -> Dao.addTemporaryVC(channel.idAsString) })
-            Dao.addTemporaryVC(channel.idAsString)
-        } catch (e: CompletionException) {
-            Log.warn("Attempted to create temporary VC without the necessary permissions")
-        }
-    }
 
-    private fun generateChannelName(message: MessageCreateEvent): String {
+    private fun generateChannelName(message: MessageCreateEvent): String =
-        return "${message.messageAuthor.name}’s volatile corner"
+        "${message.messageAuthor.name}’s volatile corner"
-    }
+}
-}

src/main/kotlin/moe/kageru/kagebot/features/TimeoutFeature.kt

@@ -1,6 +1,5 @@
 package moe.kageru.kagebot.features
 
-import arrow.Kind
 import arrow.core.*
 import arrow.core.extensions.either.applicative.applicative
 import arrow.core.extensions.either.monad.flatMap