> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Dart Sealed Class
A `sealed` class in Dart is an implicitly abstract class that restricts its class hierarchy to a single library, enabling the compiler to perform exhaustive pattern matching on its subtypes. By applying the `sealed` modifier, you prevent the class from being extended or implemented from any external library.
```dart theme={"dark"}
// file: result_types.dart
sealed class Result {}
class Success extends Result {
final String data;
Success(this.data);
}
class Failure extends Result {
final Exception error;
Failure(this.error);
}
```
## Core Mechanics and Rules
* **Library Encapsulation:** All direct subtypes (classes that `extend` or `implement` the sealed class) must be declared in the exact same library (typically the same file) as the sealed class itself.
* **Mixin Interactions:** The `sealed` modifier cannot be applied to a `mixin` declaration (i.e., `sealed mixin` is an invalid construct in Dart). Additionally, a `sealed` class cannot be used as a mixin, as Dart does not support the `sealed mixin class` declaration.
* **Implicitly Abstract:** A sealed class cannot be instantiated directly. You do not need to (and cannot) combine the `sealed` modifier with the `abstract` modifier.
* **Exhaustiveness Checking:** Because the compiler is aware of every possible subtype within the library, it enforces exhaustiveness in `switch` statements and `switch` expressions. If a new subtype is added to the sealed class, the compiler will flag an error at every `switch` site that does not handle the new subtype.
```dart theme={"dark"}
// The compiler guarantees all subtypes are handled.
// No 'default' or '_' wildcard branch is required.
String evaluateResult(Result result) {
return switch (result) {
Success(:final data) => 'Data: $data',
Failure(:final error) => 'Error: $error',
};
}
```
## Subclass Inheritance Behavior
While the `sealed` class itself is strictly bound to its defining library, its subclasses are not implicitly sealed. By default, a subclass of a sealed class behaves like a standard Dart class and can be extended or implemented by external libraries.
To maintain strict control over the entire hierarchy, you must apply additional class modifiers (`final`, `base`, or `sealed`) to the subclasses:
```dart theme={"dark"}
sealed class Node {}
// Can be extended outside the library
class StandardNode extends Node {}
// Cannot be extended or implemented outside the library
final class LeafNode extends Node {}
// Can be extended, but cannot be implemented outside the library
base class RootNode extends Node {}
```
## Constructor Behavior
Sealed classes can declare constructors. Because the class is implicitly abstract, these constructors cannot be invoked to create an instance of the sealed class itself. Instead, they are used to initialize shared state via `super` calls from the allowed subclasses, or they are defined as `factory` constructors that return instances of the subclasses.
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
