Helpers for ensuring that values are wrapped in a certain type

[ghost]

The counterparts of fns like from-maybe, take a value and ensure that they are wrapped in the correct type.

An example of how it'd behave for Maybe:

(require '[cats.monad.maybe :as maybe])

(maybe/to-maybe (maybe/just 42))
;; => #<Just 42>

(maybe/to-maybe 3)
;; => #<Just 3>

(maybe/to-maybe nil)
;; => #<Nothing>

(maybe/to-maybe (maybe/nothing))
;; => #<Nothing>

[muhuk]

Perhaps also:

(maybe/to-maybe (either/right :foo))
;; => <Just :foo?>

[ghost]

Definitely, although we may want to be more explicit with that one with something like either->maybe? I think of to-maybe to something akin to Clojure core's ensure-reduced for Reduced so ensure-maybe may be a better name.

[muhuk]

So it would work like this?

(maybe/to-maybe (either/right :foo))
;; => #<Just #<Left :foo?>>

(maybe/just nil)
;; => #<Just nil>
(maybe/to-maybe nil)
;; => #<Nothing>

[ghost]

Exactly, that's what I had in mind. I don't know if is the best option though, suggestions welcome.

[yurrriq]

I like that and maybe something like this:

(either->maybe (either/right :foo))
;; => #<Just :foo>

(either->maybe (either/left :bar))
;; => #<Nothing>

I'm not sure that makes sense, though..

Pertinent and interestring:

-- | The 'listToMaybe' function returns 'Nothing' on an empty list
-- or @'Just' a@ where @a@ is the first element of the list.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> listToMaybe []
-- Nothing
--
-- >>> listToMaybe [9]
-- Just 9
--
-- >>> listToMaybe [1,2,3]
-- Just 1
--
-- Composing 'maybeToList' with 'listToMaybe' should be the identity
-- on singleton/empty lists:
--
-- >>> maybeToList $ listToMaybe [5]
-- [5]
-- >>> maybeToList $ listToMaybe []
-- []
--
-- But not on lists with more than one element:
--
-- >>> maybeToList $ listToMaybe [1,2,3]
-- [1]
--
listToMaybe           :: [a] -> Maybe a
listToMaybe []        =  Nothing
listToMaybe (a:_)     =  Just a

[ghost]

Yep, converting an Either to a Maybe loses information.

[muhuk]

I'm just playing with the idea. With dynamic typing, things are quite different.

This bothers me a bit:

(bind (maybe/just nil) maybe/to-maybe)
;; => #<Nothing>

I guess I would write (maybe/just 3) instead of (maybe/to-maybe 3) and (maybe/nothing) instead of (maybe/to-maybe nil). And if I had some random value:

(if (some? x)
  (maybe/just x)
  (maybe/nothing))

Which is essentially to-maybe I guess, but clearer {{Citation needed}}.

I guess what bothers me in the end is the ambiguity between nil, (maybe/just nil) & (maybe/to-maybe nil).

[yurrriq]

Maybe we could implement this as a protocol, e.g. MaybeTransformable, and then implement ->maybe for different monads.

Something like:

(defprotocol MaybeTransformable
  (->maybe [mv] "Transform a given monadic value into a Maybe."))

(extend-type Left
  MaybeTransformable
  (->maybe [_] (maybe/nothing)))

(extend-type Right
  MaybeTransformable
  (->maybe [mv] (maybe/just (.-v mv))))

[muhuk]

Maybe we could implement this as a protocol, e.g. MaybeTransformable and then implement ->maybe for different monads.

I sometimes mzero on either and left-branch later to attach an error message. It would be cool if it would support either as well.

---

Edit: just checked, I don't call mzero directly.

[ghost]

I guess what bothers me in the end is the ambiguity between nil, (maybe/just nil) & (maybe/to-maybe nil).

The point of maybe is to get rid of the possibility of every value being null, nil in Clojure's case, so wrapping a nil in a Just is useless and shouldn't be done. I'd go that far to add an assert to the constructor. In Maybe monad's context nil is treated like Nothing.

[muhuk]

That makes perfect sense. to-maybe would make a good addition if nil isn't allowed as a parameter to maybe/just.