SumType is a generic sum type for modern D. It is designed to be an improved
alternative to `std.variant.Algebraic`.

Features:
  - Pattern matching, including:
    - Match-by-introspection ("if it compiles, it matches") (★)
    - Multiple dispatch (★)
  - Support for self-referential types (`This`).
  - Works with `pure`, `@safe`, `@nogc`, `nothrow`, and `immutable` (★)
  - Compatible with `-betterC` and `-dip1000` (★)
  - Zero runtime overhead compared to hand-written C
      - No heap allocation
      - Does not rely on runtime type information (`TypeInfo`) (★)

Starred features (★) are those that are missing from `Algebraic`.

The big new feature in this release is multiple dispatch: you can pass multiple
SumType arguments to a single `match` call, and it will pass each of those
SumTypes' values as a separate argument to the selected handler.

If you're used to calling `match` with UFCS, the syntax for passing multiple
arguments may take some getting used to. I recommend the following idiom:

    bool sameDimensions(Point p1, Point p2)
    {
        // Set up your handlers first
        alias doMatch = match!(
            (Point2D _1, Point2D _2) => true,
            (Point3D _1, Point3D _2) => true,
            (_1, _2) => false
        );

        // Now make the actual call
        return doMatch(p1, p2);
    }

Other improvements since 0.9.0, the last announced version:
  - SumTypes can be used as keys in associative arrays
  - isSumType!T is now true if T implicitly converts to a SumType
  - sumtype's license has been changed from MIT to Boost 1.0
  - Member types with non-const `opEquals` overloads finally work correctly
  - Various other bug fixes and documentation improvements

Links:
  - Documentation: https://pbackus.github.io/sumtype/sumtype.html
  - DUB: https://sumtype.dub.pm
  - Github: https://github.com/pbackus/sumtype

On Thursday, 24 September 2020 at 02:28:11 UTC, Paul Backus wrote:
> SumType is a generic sum type for modern D. It is designed to be an improved
> alternative to `std.variant.Algebraic`.
>
> [...]

Sure looks like a strong advance.  Hope it sees a lot of use.

On Thursday, 24 September 2020 at 02:28:11 UTC, Paul Backus wrote:
> [...]
>   - DUB: https://sumtype.dub.pm
>   - Github: https://github.com/pbackus/sumtype

Seems like dub.pm is still down, has been broken since like 6 months now :/

But your library looks really powerful, would love to see sumtype be included in phobos!

On Thursday, 24 September 2020 at 02:28:11 UTC, Paul Backus wrote:
> SumType is a generic sum type for modern D. It is designed to be an improved
> alternative to `std.variant.Algebraic`.
>
> Features:
>   - Pattern matching, including:
>     - Match-by-introspection ("if it compiles, it matches") (★)
>     - Multiple dispatch (★)
>   - Support for self-referential types (`This`).
>   - Works with `pure`, `@safe`, `@nogc`, `nothrow`, and `immutable` (★)
>   - Compatible with `-betterC` and `-dip1000` (★)
>   - Zero runtime overhead compared to hand-written C
>       - No heap allocation
>       - Does not rely on runtime type information (`TypeInfo`) (★)
>
> Starred features (★) are those that are missing from `Algebraic`.
>
> The big new feature in this release is multiple dispatch: you can pass multiple
> SumType arguments to a single `match` call, and it will pass each of those
> SumTypes' values as a separate argument to the selected handler.
>
> If you're used to calling `match` with UFCS, the syntax for passing multiple
> arguments may take some getting used to. I recommend the following idiom:
>
>     bool sameDimensions(Point p1, Point p2)
>     {
>         // Set up your handlers first
>         alias doMatch = match!(
>             (Point2D _1, Point2D _2) => true,
>             (Point3D _1, Point3D _2) => true,
>             (_1, _2) => false
>         );
>
>         // Now make the actual call
>         return doMatch(p1, p2);
>     }
>
> Other improvements since 0.9.0, the last announced version:
>   - SumTypes can be used as keys in associative arrays
>   - isSumType!T is now true if T implicitly converts to a SumType
>   - sumtype's license has been changed from MIT to Boost 1.0
>   - Member types with non-const `opEquals` overloads finally work correctly
>   - Various other bug fixes and documentation improvements
>
> Links:
>   - Documentation: https://pbackus.github.io/sumtype/sumtype.html
>   - DUB: https://sumtype.dub.pm
>   - Github: https://github.com/pbackus/sumtype

Hello,

Older version of sumtype accept this code:

void main(){
    import sumtype;
    alias Val = SumType!(bool);

    const bool b = true;
    Val val = b;  //fail in newest version
    val = b;      //fail in newest version
}

but new version need exact type:


void main(){
    import sumtype;
    alias Val = SumType!(bool);

    bool b = true;   //cannot be const
    Val val = b;
    val = b;
}

is it bug in new version or old version?

On Tuesday, 27 October 2020 at 16:26:10 UTC, vitamin wrote:
>
> Hello,
>
> Older version of sumtype accept this code:
>
> void main(){
>     import sumtype;
>     alias Val = SumType!(bool);
>
>     const bool b = true;
>     Val val = b;  //fail in newest version
>     val = b;      //fail in newest version
> }
>
> but new version need exact type:
>
>
> void main(){
>     import sumtype;
>     alias Val = SumType!(bool);
>
>     bool b = true;   //cannot be const
>     Val val = b;
>     val = b;
> }
>
> is it bug in new version or old version?

It's a bug in the new version. Thanks for reporting. I've opened an issue on Github for this:

https://github.com/pbackus/sumtype/issues/47