Unexpected behavior of `Some(None)`

I expect the Some “constructor” (actually just a function) to only return Somes.

However, given None:

>>> from returns.maybe import Some
>>> Some(None)
<returns.maybe._Nothing object at 0x7f345dcaa1c8>

For reference, another language that has null pointers, Java, raises an exception on Optional.of(null).

In general, I expect the explicitly requested creation of a Some to fail if no actual value to wrap in it is supplied.

If one explicitly wants to let Maybe decide whether to create a Some or None given a thing, there still is Maybe.new (to which Some just delegates).

[sobolevn]

My idea was that you might sometime need to explicitly represent that real None exists somewhere. Think of this example:

d = {'a': 1, 'b': None}
md = maybe(d.get)

a = md('a')  # Some(1)
b = md('b')  # Some(None)
c = md('c')  # Nothing

We can see that ‘b’ and ‘c’ are different. And previously it was impossible to tell this difference. Now it is.

[sobolevn]

Nope, this won’t do.

from returns.maybe import Some, Nothing, Maybe, maybe

source = {'a': 1, 'b': None}
def md(key: str) -> Maybe[int]:
    try:
        return Some(source[key])
    except KeyError:
        return Nothing

reveal_type(md('a'))  # ok: Revealed type is 'returns.maybe.Maybe[builtins.int]'
reveal_type(md('b').unwrap())  # not ok: Revealed type is 'builtins.int*'

Because in real life md('b').unwrap() would be None. And I don’t want to have Maybe[Optional[int]] this is really ugly.

Proposed solution: use Result when you care about value / None/ error things. Like so:

from returns.result import safe

source = {'a': 1, 'b': None}

@safe
def md(key: str) -> int:
    return source[key])

reveal_type(md('a'))  # Revealed type is 'returns.result.Result[builtins.int, Exception]'
reveal_type(md('b').unwrap())  # ok: Revealed type is 'builtins.int*'

We would have:

• Success(1) or Success(None) for 'a' and 'b'
• Failure(KeyError) for 'c'

We can always use result_to_maybe or maybe_to_result converters.