freezed VS json_serializable.dart

There is the `sealed` class modifier which allows for exhaustive matching on possible types: https://dart.dev/language/class-modifiers#sealed

There's also a package called freezed which offers similar utility (you might already be familiar with this seeing as you mentioned pattern matching): https://pub.dev/packages/freezed

I recall there being a reason unions aren't generally implemented, though I'm not sure where I read it. It was to do with union types being unnecessarily complex for the compiler and the code they tend to produce, at no real benefit to the programmer or the resulting program. Go's lack of unions is essentially based around the same reasoning.

Interesting. May I ask how this differs from something like Freezed https://pub.dev/packages/freezed and its from/ToJson features ? I haven't used it yet, but I'm just curious about the concept and use of these sort of packages.

The official site does show what you can use it for but to explain a bit more, it helps you work faster.

One rather minor suggestion: it took me a while to understand exactly what the benefits were, but the example shown on this page of the docs summarized it well. I would suggest showing an example like that at the top of the main Readme and first page of the site, before or right after the motivation section, similar to how Freezed immediately shows its value proposition.

Read more on what you can do with Freezed.

freezed on pub.dev

We use freezed for our models, and then use withConverter in the firestore SDK to easily translate between firestore and our models... however we run into issues with concurrent updates to documents.

Once the package has been created, we will install freezed for JSON serialization and value equality , as this library provides helpful tools for these tasks. We will use json_serializable for JSON serialization. To install freezed and freezed_annotation, open your terminal inside the models package and use the command:

Data class: freezed

I've recently been exploring a codebase which is heavily using Freezed with Bloc. The resulting code base is almost an entirely different language altogether, and comes with almost triple the files of a non-freezed codebase.

If you really want to write it yourself, sure. This code is very easily automatically generated.

https://pub.dev/packages/json_serializable

Serializing and deserializing json is easy thanks to the json_serializable integration. Makes it impossible to make mistakes like you would normally when working with dynamic values and strings.

We will now create a new file called build.yaml in the failures directory and add the following code. This will change the behaviour of the json_serializable so that it generates JSON keys in snake_case.

Once the package has been created, we will install freezed for JSON serialization and value equality , as this library provides helpful tools for these tasks. We will use json_serializable for JSON serialization. To install freezed and freezed_annotation, open your terminal inside the models package and use the command:

However, we cannot do this kind of JSON de-serialization in Flutter. Without reflection, we need to consider other approaches for these same tasks. For instance, the package json_serializable uses source code generation for decorating classes with methods to serialize and de-serialize JSON strings.

We could work around having to introduce parsing logic by using a package such as json_serializable to parse data to and from JSON to save ourselves some time. However, you'd need to make sure the native platforms are returning the data in the exact format you are expecting, and vice versa. Otherwise the parsing will fail.

json_serializable - Provides Dart Build System builders for handling JSON.

The other ways involve using a package like json_serializable. They automatically generate boilerplate code to convert between your model classes and JSON. The issue is that Flutter doesn't support reflection (Dart does, but Flutter for mobile doesn't due to performance reasons) so any kind of library that generates code needs to do so statically. All packages involve annotating your classes and then running a builder script that generates the boilerplate code.