armcn/maybe

The Maybe Monad in R

maybe's Issues

Add function type checks in map_maybe and and_then

Throw an error if the function provided to map_maybe returns a maybe value or the function provided to and_then doesn't return a maybe value.

Add more predicates

Add more predicates including:

• not_any_na
• not_all_na

Add maybe equals function

Add result type

Example code:

ok <- function(a) {
  as_result(list(type = "ok", content = a))
}

err <- function(e) {
  as_result(list(type = "err", content = e))
}

as_result <- function(a) {
  structure(a, class = "result")
}

result <- function(.f, allow_warning = FALSE) {
  function(...) {
    on_warning <-
      function(w)
        if (isTRUE(allow_warning))
          ok(.f(...))

        else
          err(w)

    tryCatch(
      ok(.f(...)),
      error = err,
      warning = on_warning
    )
  }
}

with_default.result <- function(.r, default) {
  assert_is_result(.r)

  if (is_ok(.m))
    from_ok(.m)

  else
    default
}

is_result <- function(a) {
  identical(class(a), "result")
}

is_ok <- function(a) {
  and(is_result, function(b) identical(b$type, "ok"))(a)
}

is_err <- function(a) {
  and(is_result, function(b) identical(b$type, "err"))(a)
}

result_extract <- function(.r, .f) {
  if (is_err(.r))
    .f(.r$content)

  else
    .r$content
}

Add case statement with functions for just (1 param) and nothing (0 param)

Add maybe_map3, and_then2, and_then3

add `from_just`

Hello,

In Haskell there is the fromJust function. I find it useful. In your package it would be:

from_just <- function(x){
  if(is_just(x)){
    x[["content"]]
  }else{
    stop("`x` is not a 'Just' value.")
  }
}

Cheers.

Use purrr::as_mapper

Generic infix operators?

I'm working on an experimental package monad to provide generics and associated operators for monads. When looking for existing implementations, I came across your very clean implementation of the Maybe monad here.

Would you be interested in coordinating to use generic versions of fmap(), bind() and join() to get infix pipe operators? Since you already have the method implementations in {maybe} (with the same names even), it should be quite straightforward:

library(monad) # pak::pak("mikmart/monad")

# Signatures are not currently compatible
wrap <- \(fn) \(m, f, ...) fn(m, f, ...)
S7::method(fmap, S7::new_S3_class("maybe")) <- wrap(maybe::fmap)
S7::method(bind, S7::new_S3_class("maybe")) <- wrap(maybe::bind)
S7::method(join, S7::new_S3_class("maybe")) <- \(m) maybe::join(m)

# %>>% = fmap generic operator
# %>-% = bind generic operator
maybe::just(1) %>>% `+`(1) %>>% `*`(2)
#> Just
#> [1] 4
maybe::just(1) %>-% \(x) maybe::nothing()
#> Nothing
maybe::nothing() %>>% `+`(1) %>>% `*`(2)
#> Nothing
maybe::nothing() %>-% \(x) maybe::just(1)
#> Nothing