domn1995 / dunet Goto Github PK

using Result = Result<System.Exception, string>;

// No `new Result.Err()` required here.
Result exception = new Exception("Boom!");
// No `new Result.Ok()` required here.
Result success = "Success!";
// Compiler error.
Result invalid = 1;

[Union]
public partial record Result<TError, TSuccess>
{
    partial record Ok(TSuccess Value);
    partial record Err(TError Error);
}

using System;

[Union]
interface IResult
{
    void Created(Guid id);
    void Failure(Exception error);
}

Xunit.Sdk.XunitException
Expected actualArea to be "0.5", but "0,5" differs near ",5" (index 1).
   at FluentAssertions.Execution.XUnit2TestFramework.Throw(String message)
   at FluentAssertions.Execution.TestFrameworkProvider.Throw(String message)
   at FluentAssertions.Execution.DefaultAssertionStrategy.HandleFailure(String message)
   at FluentAssertions.Execution.AssertionScope.FailWith(Func`1 failReasonFunc)
   at FluentAssertions.Execution.AssertionScope.FailWith(Func`1 failReasonFunc)
   at FluentAssertions.Execution.AssertionScope.FailWith(String message, Object[] args)
   at FluentAssertions.Primitives.StringEqualityValidator.ValidateAgainstMismatch()
   at FluentAssertions.Primitives.StringValidator.Validate()
   at FluentAssertions.Primitives.StringAssertions`1.Be(String expected, String because, Object[] becauseArgs)
   at Dunet.Test.GenerateUnionRecord.GenericGenerationTests.CanReturnImplementationsOfGenericUnion(Int32 dividend, Int32 divisor, String expectedOutput) in C:\repos\external-repo\dunet\test\GenerateUnionRecord\GenericGenerationTests.cs:line 104

[Union]
public partial record Foo
{
    partial record Bar(IEnumerable<string> Bars);
}

// Types.cs
[Union]
partial record Animal {
  partial record Dog(string Sound) : Animal;
  partial record Cat(string Sound) : Animal;
}

// Types.gen.cs
partial record Animal {
  // possibly getter would be better
  public string Sound() => this switch {
    Dog(sound) => sound,
    Cat(sound) => sound
  }
}

[Union]
public partial record Option<T>
{
    partial record Some(T Value);
    partial record None();
}

var option = new Option<string>.Some("foo");

var value = option.Match(
    some => some.Value,
    none => ""
);

Console.WriteLine(value); // "foo"

[Union]
public partial record Result<TFailure, TSuccess>
{
    partial record Success(TSuccess Value);
    partial record Failure(TFailure Error);
}

var result = new Result<Exception, string>.Failure(new Exception("Boom!"));
var message = result.Match(
    success => success.Value,
    failure => failure.Error.Message
);

Console.WriteLine(message); // "Boom!"

public partial record struct Number : Union<int, double>;

var integer = new Number.Int();
var @double = new Number.Double();

using static Option<int>;

Option<int> option = new Some(1);

var output = option switch
{
    Some some => some.Value.ToString(),
    None => "",
};

[Union]
public partial record Option<T>
{
    partial record Some(T Value);
    partial record None();
}

[Union]
public partial record Option<T>
{
    public partial record Some(T Value);
    public partial record None;
}

Option<int> integer = 42;

// If `integer` is `Option<int>.None` this would throw at runtime.
Option<int>.Some value = integer.UnwrapSome();

var value = integer.SomeOrThrow();
var value = integer.ForceSome();
var value = integer.ToSome();

using Dunet;

[Union]
partial record struct Option<T>
{
    partial record struct Some(T Value);
    partial record struct None;
}

[Union]
public partial record Result
{
    partial record Ok(string Message);

    partial record Error(Exception Exception)
    {
        // Can override specific methods on the generated types
        public override string ToString() => Exception.ToString();

        // ...or add new ones without resorting to extension methods
        public bool CanIgnore => Exception is OperationCanceledException;
    }
}

// Instantiate the Error case directly:
var result = new Result.Error(new Exception("hi :)"));

// Use the factory methods that return `Result`:
var otherResult = Result.NewError(new Exception("another way"));

result.Match(
    (Result.Ok _) => 1,
    (Result.Error e) => e.CanIgnore ? 1 : 0);

// Can use named arguments to make `match` more explicit:
result.Match(
    error: e => e.CanIgnore ? 1 : 0,
    ok: m => m.Message.Length);

abstract partial record Result
{
    // No other classes can derive from this class
    private Result() {}

    public static Result NewOk(string message) => new Ok(message);
    public static Result NewError(Exception exception) => new Error(exception);

    public abstract T Match<T>(Func<Ok, T> ok, Func<Error, T> error);

    public sealed partial record Ok : Result
    {
        public override T Match<T>(Func<Ok, T> ok, Func<Error, T> error) =>
            ok(this);
    }

    public sealed partial record Error : Result
    {
        public override T Match<T>(Func<Ok, T> ok, Func<Error, T> error) =>
            error(this);
    }
}

[Union]
partial record Result
{
    partial record Ok();
    partial record Error(string Id);
}

Result result = GetResult();

if(result is not Result.Error error)
    Console.WriteLine("Success");
else
    Console.WriteLine($"Error happened: {error.Id}");

Result result = GetResult();

Console.WriteLine(result switch {
    Result.Ok => "Success",
    Result.Error error => $"Error happened: {error.Id}",
    _ => $"Unknown: {result}"
});

    [Dunet.Union]
    public partial record BussinesLogicResult<T>
    {
        public partial record Ok(T Value);
        public partial record EntityNotFound();
        public partial record UnauthorizedAccess();
    }

    [Dunet.Union]
    public partial record BussinesLogicResult<T>
    {
        public partial record Ok(T Value);
        public partial record EntityNotFound();
        public partial record UnauthorizedAccess();

        public override string ToString()
        {
            return this.Match<string>(ok => ok.Value.ToString(),
                entityNotFound => "Not found.",
                unauthorizedAccess => "Unauthorized access.");
        }
    }

[Union]
public partial record struct MathResult<T>
    : where T : INumber<T>
{
    public partial record struct Infinity;
    public partial record struct Success(T Value);
    public partial record struct NaN;
    public partial record struct Undefined;
}

MathResult<double> result = // Some complex math calculation.

// A `MatchX()` is generated for each member `X` of the union. You must provide an else case.
var value = result.MatchSuccess(
    // If `Infinity, NaN, or Undefined` return 0.
    () => 0
);

// A `TryGetX` is generated for each member `X` of the union.
if (result.TryGetSuccess(out var success))
{
    Console.WriteLine(success.Value);
}

[Union]
public interface IShape
{
    IShape Circle(double radius);
    IShape Rectangle(double length, double width);
    IShape Triangle(double @base, double height);
}

var shape = new Rectangle(3, 4);
var area = shape.Match(
    circle => 3.14 * circle.Radius * circle.Radius,
    rectangle => rectangle.Length * rectangle.Width,
    triangle => triangle.Base * triangle.Height / 2
);

Console.WriteLine(area); // "12"

using Dunet.Choices;
using Dunet.Shapes;

var rectangle = Shape.Rectangle(10, 10);
var triangle =  Shape.Triangle(10, 10);
var circle = Shape.Circle(10);

var getArea = (IShape shape) =>
    shape switch
    {
        Rectangle rect => rect.Length * rect.Width,
        Circle circle => 2.0 * Math.PI * circle.Radius,
        Triangle triangle => 1.0 / 2.0 * triangle.Base * triangle.Height,
        _ => 0d,
    };

var rectangleArea = getArea(rectangle);
var triangleArea = getArea(triangle);
var circleArea = getArea(circle);

Console.WriteLine($"Rectangle area: {rectangleArea}");
Console.WriteLine($"Triangle area: {triangleArea}");
Console.WriteLine($"Circle area: {circleArea}");

var choice = GetChoice();

if (choice is Yes)
{
    Console.WriteLine("YES!!!");
}

if (choice is No)
{
    Console.WriteLine("NO!!!");
}

static IChoice GetChoice() =>
    Console.ReadLine() switch
    {
        "yes" => Option.Yes(),
        _ => Option.No()
    };

[Union]
public partial record Option<T>
{
    public partial record Some(T Value);
    public partial record None;
}

var some = new Option<int>.Some(42);

// Inferred as `Option<int>.Some` since `42` is an integer.
var someInt = Option.Some(42);
// Inferred as `Option<string>.Some`.
var someStr = Option.Some("foo");

// Adapted from https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/discriminated-unions#using-discriminated-unions-for-tree-data-structures

using System.Collections.Immutable;
using Dunet;
using static Expression;

var environment = new Dictionary<string, int>()
{
    ["a"] = 1,
    ["b"] = 2,
    ["c"] = 3,
};

var expression = new Add(new Variable("a"), new Multiply(new Number(2), new Variable("b")));

// Evaluate a + 2 * b
var result = Evaluate(environment, expression);

Console.WriteLine(result); // 5

static int Evaluate(Dictionary<string, int> env, Expression exp) =>
    exp.Match(
        number => number.Value,
        add => Evaluate(env, add.Left) + Evaluate(env, add.Right),
        multiply => Evaluate(env, multiply.Left) * Evaluate(env, multiply.Right),
        variable => env[variable.Value]
    );

// Allows to evaluate expressions without allocating lambdas
static int StaticEvaluate(Dictionary<string, int> env, Expression exp) =>
    exp.FoldMatch(
        env,
        static (_, number) => number.Value,
        static (e, add) => StaticEvaluate(e, add.Left) + StaticEvaluate(e, add.Right),
        static (e, multiply) => StaticEvaluate(e, multiply.Left) * StaticEvaluate(e, multiply.Right),
        static (e, variable) => e[variable.Value]
    );

// An example of how to thread state through a recursive function
// It simulates a (made up) use case where variables can be used only once
static (IImmutableDictionary<string, int> state, int result) 
    EvaluateUniqueVar(IImmutableDictionary<string, int> env, Expression exp) =>
    exp.FoldMatch(
        env,
        static (e, number) => (e, number.Value),
        static (e, add) =>
        {
            (e, var left) = EvaluateUniqueVar(e, add.Left);
            (e, var right) = EvaluateUniqueVar(e, add.Right);
            
            return (e, left + right);
        },
        static (e, multiply) =>
        {
            (e, var left) = EvaluateUniqueVar(e, multiply.Left);
            (e, var right) = EvaluateUniqueVar(e, multiply.Right);
            
            return (e, left * right);
        },
        static (e, variable) => (e.Remove(variable.Value), e[variable.Value])
    );

[Union]
public partial record Expression
{
    partial record Number(int Value);

    partial record Add(Expression Left, Expression Right);

    partial record Multiply(Expression Left, Expression Right);

    partial record Variable(string Value);
    
    public T FoldMatch<T, TState>(
        TState state,
        Func<TState, Number, T> number,
        Func<TState, Add, T> add,
        Func<TState, Multiply, T> multiply,
        Func<TState, Variable, T> variable
    ) => this switch
    {
        Number x   => number(state, x),
        Add x      => add(state, x),
        Multiply x => multiply(state, x),
        Variable x => variable(state, x),
        _          => throw new InvalidOperationException()
    };
}

[Union]
internal partial record HttpQueryResult<TBody>
{
  public required HttpStatusCode StatusCode { get; init; }
  public required Uri? RequestUri { get; init; }

  public partial record Success(TBody Body);
  public partial record Failure(string Error);
}