Simplify Result(T)

So, if Result(T) is interface, why not just create two

type ok(type T) T
// Implement Result(T)

type err(type T) error
// Implement Result(T)

types implementing Result(T)?

• More similar to Rust's Result(T) (you can add type ok(T), err(T) constraint to prohibit any other implementations)
• Ok's size is equal to T and Err's size is equal to error

[kovetskiy]

That's an interesting idea, but it feels like I don't really get your idea, what can we achieve by having these two types implementing Result(T)?

it would be great to achieve pattern matching at some point.

I think we could have a method that returns either Ok(T) or Err(T), so we would be able to use it in type-switch:

    switch v := result.SomeMethod().(type) {
    case Ok(int):
        //
    case Err(int):
        ///
    }

But it still doesn't look really useful.

The Match() function already addresses this problem, but it requires passing two functions though.

• It reduces Result(T) size, e.g. Result(VeryBigStruct)'s err case contains only error
• Case resolves by type, you does not need to check it manually.

func (o ok(T)) Or(res Result(T)) Result(T) {
	return o
}

func (e err(T)) Or(res Result(T)) Result(T) {
	return res
}

instead of

func (result *result(T)) Or(res Result(T)) Result(T) {
	if result.ok {
		return result
	} else {
		return res
	}
}