The Complete Production SOP: How to Deploy and Run Arrow-kt Functional Programming & Typed Error Handling in Autonomous AI Agents

---
name: "arrow-kt-functional-programming-either"
description: "Eliminate unexpected runtime exceptions using typed Either, Raise, and Option in Kotlin."
metadata:
  author: "Arrow"
  version: "1.0.0"
  runtime_compatibility:
    - "codex"
    - "claude-code"
    - "cursor"
    - "windsurf"
triggers:
  - "use arrow either kotlin"
  - "raise dsl arrow-kt"
  - "typed error handling kotlin"
permissions:
  fs_read: true
  fs_write: "workspace"
  shell_exec: false
  net_access: false
---

# Arrow-kt Functional Programming & Typed Error Handling

Implements functional programming with Arrow-kt: Either<Error, Success>, Raise DSL (raise/ensure), converting exceptions into typed errors, accumulating validation errors (Either.zipOrAccumulate), and resource safety.

## When to Invoke
Invoke this skill whenever you need to:
- use arrow either kotlin
- raise dsl arrow-kt
- typed error handling kotlin

## Execution SOP & Rules
1. Define domain errors: sealed interface UserError; data class InvalidEmail(val msg: String) : UserError.
2. Write function with Raise: fun Raise<UserError>.createUser(email: String): User { ensure(email.contains('@')) { InvalidEmail('Invalid') }; ... }.
3. Call and unwrap: either { createUser(email) }.fold(ifLeft = { handleError(it) }, ifRight = { showUser(it) }).
4. Eliminate unexpected 500 server crashes by turning all failure modes into explicit compiler-enforced types.

## Verification Checklist
- Run local linting, syntax validation, and type-checks before reporting completion.
- Ensure all created or modified files adhere to workspace boundaries and avoid uncommitted secrets.
- Verify tests or build commands exit cleanly with return code 0.

dependencies {
    implementation(platform("io.arrow-kt:arrow-stack:1.2.4"))
    implementation("io.arrow-kt:arrow-core")
    implementation("io.arrow-kt:arrow-fx-coroutines")
    testImplementation("io.kotest.extensions:kotest-assertions-arrow:1.4.0")
}

package domain.user

import arrow.core.Either
import arrow.core.raise.Raise
import arrow.core.raise.either
import arrow.core.raise.ensure

sealed interface RegistrationError {
    data class InvalidEmail(val reason: String) : RegistrationError
    data class WeakPassword(val details: String) : RegistrationError
    data class UserAlreadyExists(val email: String) : RegistrationError
}

data class User(val id: String, val email: String)

class UserService {
    fun Raise<RegistrationError>.validateAndRegister(email: String, pass: String): User {
        ensure(email.isNotBlank() && email.contains("@")) {
            RegistrationError.InvalidEmail("Malformed email address: $email")
        }
        ensure(pass.length >= 8) {
            RegistrationError.WeakPassword("Password must be at least 8 characters")
        }
        return User(id = "usr_" + email.hashCode(), email = email)
    }

    fun register(email: String, pass: String): Either<RegistrationError, User> = either {
        validateAndRegister(email, pass)
    }
}

package domain.user

import io.kotest.assertions.arrow.core.shouldBeLeft
import io.kotest.assertions.arrow.core.shouldBeRight
import io.kotest.core.spec.style.StringSpec

class UserServiceTest : StringSpec({
    val service = UserService()

    "should return Left(InvalidEmail) when email is malformed" {
        val result = service.register("invalid-email", "ValidPassword123!")
        result shouldBeLeft RegistrationError.InvalidEmail("Malformed email address: invalid-email")
    }

    "should return Right(User) on valid registration credentials" {
        val result = service.register("[email protected]", "StrongPassword123!")
        result.shouldBeRight()
    }
})