如何使用 generics 与 Dart 中的组合？

Question

I'm having issues with generics types in Dart. Take the following entities example in consideration:

enum ProductType { book }

abstract class ProductMetadata {
  ProductMetadata(this.type);
  
  final ProductType type;
}

class BookProductMetadata extends ProductMetadata {
  BookProductMetadata(this.pages) : super(ProductType.book);
  
  final int pages;
}

abstract class Product<M> {
  Product(this.metadata);
  
  final M metadata;
}

class BookProduct extends Product<BookProductMetadata> {
  BookProduct(BookProductMetadata metadata) : super(metadata);
}

Where we would have multiple different kinds of product with different kinds of metadata . I'm trying to build a serializer that support this structure, and I stuck with the following:

class ProductSerializer {
  Product<M> from<M extends ProductMetadata>(Map<String, dynamic> json) {
    final metadata = json['metadata'] as Map<String, dynamic>;
    final type = metadata['type'] as ProductType;
    
    ProductMetadata formattedMetadata;
    
    switch (type) {
      case ProductType.book:
        formattedMetadata = BookProductMetadata(123);
    }
    
    return BookProduct(metadata: formattedMetadata);
    }
}

Which gives me the error A value of type 'BookProduct' can't be returned from the method 'from' because it has a return type of 'Product<M>' .

The goal in this serializer was to avoid at most type-casting using as and to use generics for whoever uses this serializer to determine what should be its returning type. I was able to achieve a similar example in a Typescript project, but I am not being able to take full advantage of generics in Dart and I can't understand why, since it seems natural to me that BookProduct<BookMetadata> should be accepted as Product<M> when M extends ProductMetadata .

Answer 1

You can't avoid casting.

The code

    switch (type) {
      case ProductType.book:
        formattedMetadata = BookProductMetadata(123);
    }
    
    return BookProduct(metadata: formattedMetadata);

suggests that your function always returns a BookProduct .

Which it does, because book is the only existing product type, but I'd expect that to change. If there were more product types, then the switch would not be exhaustive, and the following code would not be able to know that the formattedMetadata is always BookProductMetata .

Assume there was also a MovieProductMetadata implementing Metadata , and a MovieProduct implementing Product<MovieProductMetadata> . In that case, the static type system sees a function with type Product<M> Function<M extends ProductMetadata>(...) which returns a BookProduct implementing Product<BookProductMetadata> . It cannot assume that to be valid, because M could be MovieProductMetadata . (Or, even without those extra types, M could always be Never , it's a subtype of any type.)

If you had more cases, the return should probably be inside the switch case. If it was inside the switch case, you don't need the shared formattedMetadata variable, and could have done:

    switch (type) {
      case ProductType.book:
        var formattedMetadata = BookProductMetadata(123);
        return BookProduct(metadata: formattedMetadata) as Product<M>;
      case ProductType.movie: ...
    }

You still need the as cast , because static analysis cannot see why a BookProduct should be guaranteed to be a Product<M> for every valid M . It requires the caller to know, ahead of time, which type of product is going to be returned for the JSON they put in. Which is fine, but that still means at least one runtime check, like the as .

The type of the returned object depends on the value of the metadata type in the incoming JSON. That's dependent typing (types depending on runtime values), and Dart's static type system can't do that. That's why you need runtime type checks too.