theiterators / sealed-monad

Scala library for nice business logic oriented, for-comprehension-style error handling

sealed-monad

Scala library for nice business logic oriented, for-comprehension-style error handling. Write logic that even your manager can understand!

Or in more technical terms, think of EitherT on steroids, with more human-readable method names.

Installation

Add the following to your build.sbt:

libraryDependencies += "pl.iterators" %% "sealed-monad" % "1.3.0"

Available for Scala 2.12.x, 2.13.x and 3.x.

Usage

  def createTodo(userId: UUID, organizationId: UUID, request: CreateTodoRequest): IO[CreateTodoResponse] = {
    (for {
      user <- userRepository
        .find(userId) // IO[Option[User]]
        .valueOr(CreateTodoResponse.UserNotFound) // extracts User or returns UserNotFound
      _ <- organizationRepository
        .findFor(userId) // IO[Option[Organization]]
        .valueOr(CreateTodoResponse.UserNotInOrganization) // extracts Organization or returns UserNotInOrganization
        .ensure(_.canCreateTodos(user), CreateTodoResponse.UserNotAllowedToCreateTodos) // checks if user can create todos or returns UserNotAllowedToCreateTodos
      _ <- todoRepository
        .find(request.title) // IO[Option[Todo]]
        .ensure(_.isEmpty, CreateTodoResponse.TodoAlreadyExists) // checks if todo already exists or returns TodoAlreadyExists
      _ <- Todo
        .from(request)
        .pure[IO] // IO[Todo]
        .ensure(_.title.nonEmpty, CreateTodoResponse.TodoTitleEmpty) // checks if todo title is non-empty or returns TodoTitleEmpty
      todo <- todoRepository.insert(Todo(UUID.randomUUID(), request.title)).seal // todo created!
    } yield CreateTodoResponse.Created(todo)).run // compile to IO[CreateTodoResponse]
  }

Documentation

Please refer to the docs site.

License

This project is licensed under the Apache 2.0 License - see the LICENSE file for details.

sealed-monad's Issues

Add missing method variants: boolean and F-methods

I've came across couple of methods missing, e.g.:

• noValueOr
• noValueOrF
• flatTapWhenNot
• ensureNotF

Add `rethrow` to `SealedFAEitherOps`

Research: decouple sealed-monad from Cats, create integrations for Future and cats.Monad

Make documentation more usable

Current documentation lives under: https://theiterators.github.io/sealed-monad/ and is very limited. Ideally it should:

• show case some beautiful code example on the intro page,
• tell more about ADT-centric error handling,
• show more use cases,
• main GH page (https://github.com/theiterators/sealed-monad) could feature more details from the docs,
• travis badge doesn't work anymore,
• logo should be updated.

Add mdoc

https://github.com/scalameta/mdoc

Add Sealed.unit method

Improve documentation

The project is currently undocumented - adding descriptions, tips and example (typechecked) usages to functions exposed to the user will be extremely helpful.

Feature request - add `.void` method

Hi,

It would be great to have .void as alias to .map(_ => ())

Add release-drafter

https://github.com/release-drafter/release-drafter

Add sbt-ci-release

https://github.com/olafurpg/sbt-ci-release

`ensure` is missing `ensureF` variant

As in title, not sure if "effectful" ensure is a good idea 🤷

Add support for Scala.js and Scala Native

...or see if it's possible.

Add effectful version of `ensure`

We could use an alternative to this function, preferably named ensureF:

def ensure[ADT](pred: A => Boolean, orElse: => ADT): Sealed[F, A, ADT]     = seal[ADT].ensure(pred, orElse)

This could cut off some boilerplate compared to the following usage of attemptF:

private def setFailed(obj: SomeObj): F[Result] = ???

private def ensureSomething(obj: SomeObj): StepF[Unit] =
    transactor
      .execute(someDbCall())
      .attemptF[Result, Unit] {
        case list if !list.exists(_.id != obj.id) => F.pure(Right(()))
        case _ =>
          setFailed(obj)
            .map(result => Left(result))
      }

versus potential ensureF:

private def ensureSomething(obj: SomeObj): StepF[Unit] =
    transactor
      .execute(someDbCall())
      .ensureF(!_.exists(_.id != deployment.id), setFailed(obj))

`inspect` is missing `inspectF`

Similar to #188

`attemptF` - inconsistent type parameter order

Hi,

I have encountered an inconsistency with the order of type parameters in the attemptF method within which could potentially cause confusion.

final class SealedFAOps {
  def attemptF[ADT, B]
}

// When using attemptF:
attemptF[FooResult, Unit]

sealed trait Sealed {
  def attemptF[B, ADT1 >: ADT]
}

// When using attemptF:
attemptF[Unit, FooResult]