Help: returning a different OneOf from within a Match

Hi Harry

I’m new to OneOf and am having a play with it at work, mainly using it as an Option type via OneOf<T, None>.

I have a couple of questions - 1. how do we avoid massive nesting within Matches when you need to do something and then something else and then something else and then something else?

1. How do I return a different OneOf<> from within a Match? My use case is this:

private async Task<OneOf<string, None>> GetContent(string requestUri, CorrelationId correlationId)
{
    var response = await client.GetAsync(requestUri); // client is an HttpClient

    var content = response.Content == null ? string.Empty : await response.Content.ReadAsStringAsync();

    if (response.IsSuccessStatusCode)
    {
        return content;
    }

    return new None();
}

public async Task<OneOf<Address, None>> AddressSearch(string term, CorrelationId correlationId)
{
    var requestUri = AddressSearchUri
        .AddQueryParam("client_id", clientId)
        .AddQueryParam("term", term);

    var content = await GetContent(requestUri, correlationId);

    return content.Match(
        str => 
        {
            var addressSearchResponse = str.FromJson<AddressSearchResponse>();

            if (addressSearchResponse?.RetrieveLocationResponse?.BusinessResult?.Success != "Y")
            {
                return new None();
            }

            if (addressSearchResponse?.RetrieveLocationResponse?.TypeAheadSearch == null)
            {
                return new None();
            }

            return new Address( // this line fails to compile - "Cannot implicitly convert type Address to OneOf.Types.None"
                addressSearchResponse.RetrieveLocationResponse.TypeAheadSearch[0].Elid,
                addressSearchResponse.RetrieveLocationResponse.TypeAheadSearch[0].Label);
        },
        none => new None()
    );
}

[rtkelly13]

@mattfrear didn’t see your message before I replied, you’re welcome!

I would say early return would not be particularly idiomatic in a functional language if we want to compare this to F#. Even though there are some parts of the language where multiple return statements are used. https://fsharpforfunandprofit.com/series/computationexpressions.html

If you try to use the the IsTX methods you loose most of the type safety benefits of this library. They shouldn’t really be used for purposes other than extensions such as Serialisation. They should be hidden somehow in my option as them being there encourages people to miss-use this library.

My guidelines would be to be when you are creating a OneOf type use multiple return statements, but when you are consuming them you should use only one return statements. This forces the consumer to handle all the cases inside the OneOf! Avoiding the pitfalls of the is/as or multiple if statement approach!

[mcintyre321]

@mattfrear last day at RP today actually! Glad to hear you hit the ground running.

I reckon the .TryPickTX methods are what you are after. This is from the readme:

        OneOf<Thing, NotFound, Error> thingOrNotFoundOrError = GetThingFromDb(string id);

	if (thingOrNotFoundOrError.TryPickT1(out NotFound notFound, out var thingOrError)) //thingOrError is a OneOf<Thing, Error>
		return StatusCode(404);

	if (thingOrError.TryPickT1(out var error, out var thing)) //note that thing is a Thing rather than a OneOf<Thing>
	{
		_logger.LogError(error.Message);
		return StatusCode(500);
	}

	return Ok(thing);

This lets you remove a single case at a time, and process the OneOf without deep nesting