As you can see, the type factory function is a generic function that takes as many type arguments (`A, B`) as your target class defines.
Then you have to call `f` with your generic type.

After that, whenever you have a generic type argument or type variable, you can use the following properties on it:

```dart
void myGenericFunction() {
String name = T.name; // the full name of the type
String id = T.id; // a unique id of the type

Type base = T.base; // the base type of a generic type
List args = T.args; // the type arguments of a generic type
}
```

> Read on for a more detailed explanation of the available properties or take a look at the example.

## Working with types

There are two ways you can get an instance of a `Type` in dart:

1. **Generic type argument**
This can either come from a generic class or generic function.

```dart
class MyClass {
String get name => T.name;
}
// or
void myFunction() {
String name = T.name;
}
```

2. **Type variable**
Types can also be used as variables.

*Prior to Dart 2.15 when using generic types you have to use the `typeOf()` helper function*

```dart
void main() {
Type a = int;
Type b = List; // for dart < 2.15 instead do typeOf>()

String aName = a.name;
String bName = b.name;

// or use in expressions wrapped in ()
print((MyClass).name);
}
```

## Type decomposition

With this package, you can decompose a generic type into its type components.
Let's say we have the type `Map`, then:

- the decomposed base type would be `Map` (or more concrete `Map` because of how darts type system works) and
- the decomposed type arguments would be `String` and `int`.

```dart
void main() {
var type = Map;

String name = T.name; // = "Map"

Type base = T.base; // = Map
List args = T.args; // = [String, int]
}
```

## Generic invocation

Normally in dart, a generic type argument can only be provided statically. This means you cannot invoke a generic method when you only have a type variable.

With this package however, you can call a generic method and provide type variables for the generic arguments:

```dart
void printType() {
print(T.name);
}

void main() {
var type = typeOf>();

// prints: "Map"
printType.callWith(typeArguments: [type]);

// prints: "String"
printType.callWith(typeArguments: [type.args.first]);
}
```

## Type IDs

With type_plus, every type has a unique id.

Additionally to identifying a type, you can use ids to construct a generic type from a string:

```dart
void main() {
Type a = List;
Type b = int;

Type newType = TypePlus.fromId('${a.id}<${b.id}>');
assert(newType.base == a);
assert(newType.args.first == b);
}
```

When registering a type, you can provide a custom id to be used:

```dart
void main() {
TypePlus.add(id: 'CoolId');

Type myType = TypePlus.fromId('CoolId');
assert(myType == MyClass);
}
```

## Type inheritance

When dealing with object variables, there exists the `is` operator for checking the inheritance of an object. However there exists nothing like this for types.

With type_plus, you can do

- `typeA.implements(typeB)` and
- `typeB.implementedBy(typeA)`

to check the inheritance of types.

In order for this to work, you have to explicitly set the supertypes of any type when registering it. This includes any extends, implements and mixins.

```
class MyClass extends List {}