Initial overview of unions #7967

BillWagner · 2024-02-25T21:57:00Z

This represents a first attempt at how I plan to explain discriminated unions to our customers.

BillWagner · 2024-02-25T21:59:31Z

For discussion at our working group meeting tomorrow.

meetings/working-groups/discriminated-unions/conceptual-overview.md

IhnatKlimchuk · 2024-03-23T20:08:44Z

Does it make sense to extend this to strings? Imagine that you defined next:

public class Domain
{
    public (Data? result, "NotFound" | "NotAllowed" | string? errorCode)> Magic() {...code...}
}

That from compiler and runtime should be same as

public class Domain
{
    public (Data? result, string? errorCode)> Magic() {...code...}
}

But code analyzer in IDE can support this information, to provide useful highlight about possible cases for pattern matching. I guess that case with generics will help the most. Example:

public class Domain
{
    public (Data? result, Error<string>? error) GetData(int id)
    {
         var (record, error)= GetRecordById(id); // returns (Record? record, Error<"NotFound">? error)
         if (error != null)
         {
             return (null, error);
         }
         if (record.IsPrivateData)
         {
             return (null, new Error<"NotAllowed">());
         }
         return (record.data, null);
    }
    
    ...
    
    var (result, error) = GetData(1);
    if (error != null)
    {
        // suggested pattern matching
        var statusCode = return error.Code switch
        {
            "NotFound" => 404,
            "NotAllowed" => 401,
            _ = 400,
        }
        ...
    }
}

This could help a lot in complex domain services to use result patterns and reduce amount of throwing exceptions.

This represents a first attempt at how I plan to explain discriminated unions to our customers.

KathleenDollard · 2024-04-15T13:10:44Z

meetings/working-groups/discriminated-unions/conceptual-overview.md

+>
+> The language is intended to be less formal than the specification and serve as an introduction for customers.
+
+*Discriminated unions* provide a new way to express the concept that *an expression may be one of a fixed set of types or values*.


Does this imply exhaustiveness? Have we settled on being exhaustive (it's fine with me, but I think Cyrus had some Roslyn scenarios for open)

KathleenDollard · 2024-04-15T13:12:07Z

meetings/working-groups/discriminated-unions/conceptual-overview.md

+
+*Discriminated unions* provide a new way to express the concept that *an expression may be one of a fixed set of types or values*.
+
+C# already provides syntax for special cases of discriminated unions. Nullable types express one example: A `int?` is either an `int`, or `null`. A `string?` is either a `string` value or `null`. Another example is `enum` types. An `enum` type represents a closed set of values. The expression is limited to one of those values.


Again, is "closed" the right word, as it seems to indicate that only values that are enums can be held in enums.

Examples are good, this is just a comment on wording

KathleenDollard · 2024-04-15T13:15:38Z

meetings/working-groups/discriminated-unions/conceptual-overview.md

+
+C# developers often use *inheritance* to express that an expression is *one of many types*. You declare that an expression is of a base class, and it could be any class derived from that type. Inheritance differs from union types in two ways. Most importantly, a union represents one of a *known* set of types. An inheritance hierarchy likely includes derived classes beyond the known set of derived types. Secondly, a union doesn't require an inheritance relationship. A union can represent *one of many known `struct` types*, or even a union of some `struct` types and some `class` types. Inheritance and unions have some overlap in expressiveness, but both have unique features as well.
+
+Union types may optimize memory storage based on knowledge of the closed set of types allowed in that union. 


Suggested change

Union types may optimize memory storage based on knowledge of the closed set of types allowed in that union.

Union types may also be able to optimize memory storage based on knowledge of the closed set of types allowed in that union.

KathleenDollard · 2024-04-15T13:26:46Z

meetings/working-groups/discriminated-unions/conceptual-overview.md

+
+### Option - Value or "nothing"
+
+Honest question: How much do we expect this to be used instead of nullable types?


Good question, let's replace with OneOrMany as an example of OneOf 😉

KathleenDollard · 2024-04-15T13:27:40Z

meetings/working-groups/discriminated-unions/conceptual-overview.md

+A *Result* type is a union that contains one of two types: the result of some operation, or an error type that provides detailed information about the failure. The code could look something like the following:
+
+```csharp
+var result = SomeOperation();


Do we want to include the signature for SomeOperation for clarity?

KathleenDollard · 2024-04-15T13:28:52Z

meetings/working-groups/discriminated-unions/conceptual-overview.md

+
+### Finite state machines
+
+A union can model a sophisticated finite state machine. At each state, a different type can represent the properties of that state. Each input moves the state machine to a new state. The properties for that new state may be different values, or even represented by different types.


I would be super excited to see us flesh out this example more.

KennethHoff · 2024-04-15T13:47:32Z

Does it make sense to extend this to strings? Imagine that you defined next
[...]

Literal types are something else entirely that I'd love to have but feels out of scope. Literal types don't make sense in a world without unions, but unions make sense without literal types.

BillWagner requested a review from a team as a code owner February 25, 2024 21:57

BillWagner marked this pull request as draft February 25, 2024 21:57

BillWagner requested review from 333fred, mattwar, CyrusNajmabadi, KathleenDollard, MadsTorgersen and cston and removed request for a team February 25, 2024 21:58

cston reviewed Feb 26, 2024

View reviewed changes

meetings/working-groups/discriminated-unions/conceptual-overview.md Outdated Show resolved Hide resolved

cston reviewed Feb 26, 2024

View reviewed changes

meetings/working-groups/discriminated-unions/conceptual-overview.md Outdated Show resolved Hide resolved

KathleenDollard reviewed Feb 26, 2024

View reviewed changes

meetings/working-groups/discriminated-unions/conceptual-overview.md Show resolved Hide resolved

BillWagner added 2 commits April 8, 2024 10:17

Initial overview of unions

3b211a6

This represents a first attempt at how I plan to explain discriminated unions to our customers.

Start on samples.

9cf50b7

BillWagner force-pushed the discrimated-unions-conceptual-intro branch from 38d6c94 to 9cf50b7 Compare April 8, 2024 15:32

KathleenDollard reviewed Apr 15, 2024

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Initial overview of unions #7967

Initial overview of unions #7967

BillWagner commented Feb 25, 2024

BillWagner commented Feb 25, 2024

IhnatKlimchuk commented Mar 23, 2024 •

edited

Loading

KathleenDollard Apr 15, 2024

KathleenDollard Apr 15, 2024

KathleenDollard Apr 15, 2024

KathleenDollard Apr 15, 2024

KathleenDollard Apr 15, 2024

KathleenDollard Apr 15, 2024

KennethHoff commented Apr 15, 2024


		Discriminated unions provide a new way to express the concept that an expression may be one of a fixed set of types or values.

		C# already provides syntax for special cases of discriminated unions. Nullable types express one example: A `int?` is either an `int`, or `null`. A `string?` is either a `string` value or `null`. Another example is `enum` types. An `enum` type represents a closed set of values. The expression is limited to one of those values.


		C# developers often use inheritance to express that an expression is one of many types. You declare that an expression is of a base class, and it could be any class derived from that type. Inheritance differs from union types in two ways. Most importantly, a union represents one of a known set of types. An inheritance hierarchy likely includes derived classes beyond the known set of derived types. Secondly, a union doesn't require an inheritance relationship. A union can represent one of many known `struct` types, or even a union of some `struct` types and some `class` types. Inheritance and unions have some overlap in expressiveness, but both have unique features as well.

		Union types may optimize memory storage based on knowledge of the closed set of types allowed in that union.

	Union types may optimize memory storage based on knowledge of the closed set of types allowed in that union.
	Union types may also be able to optimize memory storage based on knowledge of the closed set of types allowed in that union.


		### Option - Value or "nothing"

		Honest question: How much do we expect this to be used instead of nullable types?


		### Finite state machines

		A union can model a sophisticated finite state machine. At each state, a different type can represent the properties of that state. Each input moves the state machine to a new state. The properties for that new state may be different values, or even represented by different types.

Initial overview of unions #7967

Are you sure you want to change the base?

Initial overview of unions #7967

Conversation

BillWagner commented Feb 25, 2024

BillWagner commented Feb 25, 2024

IhnatKlimchuk commented Mar 23, 2024 • edited Loading

KathleenDollard Apr 15, 2024

Choose a reason for hiding this comment

KathleenDollard Apr 15, 2024

Choose a reason for hiding this comment

KathleenDollard Apr 15, 2024

Choose a reason for hiding this comment

KathleenDollard Apr 15, 2024

Choose a reason for hiding this comment

KathleenDollard Apr 15, 2024

Choose a reason for hiding this comment

KathleenDollard Apr 15, 2024

Choose a reason for hiding this comment

KennethHoff commented Apr 15, 2024

IhnatKlimchuk commented Mar 23, 2024 •

edited

Loading