Proposal: Anonymous discriminated unions

[LarsKemmann]

Scenario: I'm currently factoring out the entity manipulation code from a web application into a standalone library for reuse and easier maintenance. A lot of it takes the following form (totally mangling the details):

[HttpPost]
public ActionResult CreateFoo(CreateFooArguments args)
{
    if (ArgumentsAreValid(args))
    {
        using (var context = SomeDbContext())
        {
            var userInfo = GetUserInfo(context, this.UserId);

            if (UserHasAppropriateAccess(userInfo))
            {
                var newFooId = DoWorkToCreateFoo(userInfo, model.name);
                return new JsonResult(newFooId);
            }
            else
            {
                return new HttpStatusCodeResult(HttpStatusCode.NotAllowed, "The user does not have access.");
            }
        }
    }
    else
    {
        return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
    }
}

To factor out the entity creation along with the validation requires that the CreateFoo method have a way to map multiple return types into the appropriate HttpStatusCodeResult or JsonResult. Anonymous discriminated unions would be the ideal solution for this, since I get the convenience of having everything defined as part of the method.

[HttpPost]
public ActionResult CreateFoo(CreateFooArguments args)
{
    switch (ExternalCreateFoo(args.name, this.UserId))
    {
        case FooCreated(int id):
            return new JsonResult(id);
        case UserHasNoAccess:
            return new HttpStatusCodeResult(HttpStatusCode.NotAllowed, "The user does not have access.");
        case ArgumentsAreInvalid:
            return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
    }
}

public FooCreated(int id) | UserHasNoAccess | ArgumentsAreInvalid ExternalCreateFoo(string name, int userId)
{
    if (ArgumentsAreValid(args))
    {
        using (var context = SomeDbContext())
        {
            var userInfo = GetUserInfo(context, userId);

            if (UserHasAppropriateAccess(userInfo))
            {
                var newFooId = DoWorkToCreateFoo(userInfo, model.name);
                return FooCreated(newFooId);
            }
            else
            {
                return UserHasNoAccess;
            }
        }
    }
    else
    {
        return ArgumentsAreInvalid;
    }
}

[LarsKemmann]

And I apologize in advance for not using correct terminology. I've built one compiler in my life and it only dealt with integers. :)

[svick]

So, you're basically asking for anonymous discriminated unions?

Also, why should such type be available only as a method return type, and not also everywhere else where a normal type can appear?

[LarsKemmann]

Yes, exactly!

They could certainly be available more generally. The method return type was the scenario that seemed most useful when I wrote this up.

[dsaf]

I can easily imagine F# doing this if it did not (over-)use type inference.

BTW it also sounds a bit like http://en.wikipedia.org/wiki/Postcondition

[Richiban]

What you've described is very very close to F#'s active patterns. I rewrote your example in F#, tell me if it's close to what you wanted in readability, then maybe the feature can be ported over!

    let (| FooCreated | UserHasNoAccess | ArgumentsAreInvalid |) (name : string, userId : int) =
        if ArgumentsAreValid (name, userId)
        then
            use context = SomeDbContext()
            let userInfo = GetUserInfo(context, userId);

            if UserHasAppropriateAccess userInfo
            then
                let newFooId = DoWorkToCreateFoo (userInfo, name)
                FooCreated newFooId
            else
                UserHasNoAccess
        else
            ArgumentsAreInvalid


    [HttpPost]
    member this.CreateFoo (args : CreateFooArguments) =

        match args.name, this.UserId with
        | FooCreated id ->
                JsonResult id
        | UserHasNoAccess ->
                HttpStatusCodeResult (HttpStatusCode.NotAllowed, "The user does not have access.")
        | ArgumentsAreInvalid ->
                HttpStatusCodeResult HttpStatusCode.BadRequest

[mcintyre321]

I (like several others) have made a library for doing this, called OneOf which achieves this using implicit operators e.g.

public OneOf<User, InvalidName, NameTaken> CreateUser(string username)
{
    ...
}

I would love this to be a language feature though, as OneOf has some limitations (e.g. implicit operators don't work on interface types)

[gafter]

Issue moved to dotnet/csharplang #468 via ZenHub