All properties available on all factory methods about freezed HOT 6 CLOSED

Closing in favor of #907, which enables more advanced class hierarchies.

Alternatively, you can use @Implements/@With to do things by hand.

from freezed.

That is currently not supported.
But, it is not impossible to support it.

A more complex case I would like to fully support is:

abstract class Complex with _$Complex {
  const factory Complex.a(int value) = ComplexA;
  const factory Complex.b(double value) = ComplexB;
}

I'm thinking of a few things for these cases:

Complex example = Complex.a(42);

num value = example.value; // fine
double value = example.value // implicit-cast error, value is a num not a double

example.value would be num because that is the nearest common type between double and int

Then one more difficult scenario would be:

abstract class ReallyComplex with _$ReallyComplex {
  const factory ReallyComplex.a(int variable) = ReallyComplexA;
  const factory ReallyComplex.b(double variable) = ReallyComplexB;
  const factory ReallyComplex.c() = ReallyComplexC;
}

In which case I think I'd go with:

ReallyComplex example;

example.$variable(
  (num variable) => print(variable),
  orElse: () => print('nothing'),
);

The $ being necessary so that we can still do:

ReallyComplex example;
if (example is ReallyComplexA) {
  print(example.value);
} 

from freezed.

what would that look like for my example?

abstract class Result with _$Result {
  const factory Result.Continue(Action action) = Result_Continue;
  const factory Result.Retry(Action action) = Result_Retry;
  const factory Result.Complete() = Result_Complete;
}

result.$variable(
  (Action action) => process(action),
  orElse: () => print('nothing'),
);

and if I wanted to differentiate between continue and retry I would have to vary my type (ActionContinue or ActionRetry or something like that)

abstract class Result with _$Result {
  const factory Result.Continue(ActionContinue action) = Result_Continue;
  const factory Result.Retry(ActionRetry action) = Result_Retry;
  const factory Result.Complete() = Result_Complete;
}

result.$variable(
  (ActionContinue action) => process(action),
  (ActionRetry action) => wait 5.then(process(action)),
  orElse: () => print('nothing'),
);

...if I have that right then I think that would work well. It would be nice to vary by the continue and Retry types though and not by the parameters. In my example an Action is always an Action but the Result is the type that determines whether an action should Continue or Retry), maybe that is impossible as everything works around the parameters and not the types? but, if the syntax is possible, maybe an as keyword could work?

abstract class Result with _$Result {
  const factory Result.Continue(Action action) = Result_Continue as ResultAction;
  const factory Result.Retry(Action action) = Result_Retry as ResultAction;
  const factory Result.Complete() = Result_Complete;
}

result.maybeWhen(
  ResultAction: (action) => process(action,
  orElse: () => 'fallback',

or

result.maybeWhen(
  Result_Continue: (action) => process(action),
  Result_Retry: (action) => retry(action),
  orElse: () => 'fallback',

from freezed.

An alternative is to make the properties that are not shared between all constructors nullable.

Since Dart will "soon" have non-nullable types, it should be compile safe.

Freezed could still generate that$my_property variant for more complex cases.

from freezed.

I haven't thought this through that much (!) but could you go for a ducktyping approach? In my example above all I really want to do is run code wherever I have a property called action of type Action.

abstract class Result with _$Result {
  const factory Result.Continue(Action action) = Result_Continue;
  const factory Result.Retry(Action action, int retryTime) = Result_Retry;
  const factory Result.Complete() = Result_Complete;
}

main() {
  var result = Result_Continue(Action());

  result.maybeWhen(
    action: () => print("action"),
    action_retryTime: () => print("action in retrytime"),
    retryTime: () => print("retry time")
    _void: () => print("everything "),
  );
}

vary by the property names rather than the types because an int may not be descriptive enough - age & height for example could be two different parameters

from freezed.

A more complex case I would like to fully support is:

abstract class Complex with _$Complex {
  const factory Complex.a(int value) = ComplexA;
  const factory Complex.b(double value) = ComplexB;
}

For this specific case, we just have to add an abstract getter with the nearest common type :

abstract class Complex with _$Complex {
  const factory Complex.a(int value) = ComplexA;
  const factory Complex.b(double value) = ComplexB;

  num get value;
}

from freezed.