Alternative implementation of Maybe#concat

I think this may be just an alternative implementation of Maybe#concat rather than a bug, but the concat method is biased towards Nothing and will result in the expression evaluating to Nothing if one is present.

Just([1]).concat(Nothing())

Actual: Nothing()
Expected: Just([1])

In haskell if we do the same: Just [1] <> Nothing will evaluate to Just [1].

My particular use case for the proposed implementation is to build up an object from several Maybe Assign({}) and have it evaluate to a Just even if a Nothing is encountered.

E.g.

Just(Assign({a: 1})).concat(Just(Assign({b: 2}))).concat(Nothing())

Wanted: Just(Assign({a: 1, b: 2}))

[evilsoft]

So in playing with this for a while now, I cannot get around the laws for anything like this. This issue is the empty or Monoid portion. It is okay with Semigroup because it speaks to the value the Maybe is wrapping, but adding implicit empty with Nothing, we would then to to transport the context of the inner Semigroup type to the Outer Maybe type.

So because we have alt and can transport that inner context to the outer, I am going to have to pass on this alternative. Even though other libraries allow it, I see it as having other implications for such an non-common case.

[jonwhelan]

@evilsoft Thanks for the thorough explanation! If I’m understanding it correctly, essentially all the Maybes are getting mapped over and the Nothings are defaulted to an empty Just(Assign.empty()) by virtue of alt, thus allowing the reduce to encounter all Justs.

My solution was similar but I was just mapping over with a function like the following prior to reducing: either(constant(Just(Assign.empty())), Just). But I like the elegance of using alt as you and @dalefrancis88 have suggested.