Some related discussions: making parameters optional certainly makes many of
the Attrs more informative during compile-time.
### Benefit of `Optional<T>` and Non-Nullable Refs.
For example, in the case of the topi operator `sum(x, axis)`, the true type of
axis is `Optional<Array<Integer>>`. Making this intention clear would help to
make the code more readable. Because we need to explicitly call `value()`
function in `Optional<T>` to get the underlying type `T`, it would reminds the
developer to do not null check before doing so.
Another example is that in most cases our IR nodes's fields are expected to be
not-null. Making some of the IR refs(Expr, Stmt) not non-nullable will
increases the robustness in our codebase via statically type checking.
### Engineering Cost for non-nullable ObjectRefs
Non-nullable refs does introduce a bit of engineering overhead. In particular,
non-nullable refs may not have a default constructor(the default behavior of
nullable refs defaults to nullptr) to let us enjoy more compile time checks.
This means we need to introduce the member init constructor for each ObjectNode.
Say PrimExpr is notnullable.
```c++
class RangeNode : public Object {
public:
PrimExpr min;
PrimExpr extent;
// because min/extent does not have default constructor
// we have to explicitly create such constructors
RangeNode(PrimExpr min, PrimExpr extent)
: min(min), extent(extent) {}
// rest of the code
};
class Range : public ObjectRef {
public:
Range make_by_min_extent(PrimExpr min, PrimExpr extent) {
// old-style no longer works, because there is no default constructor.
// auto n = make_object<RangeNode>();
// n->min = std::move(min);
// n->extent = std::move(extent);
// return Range(n);
// Need to directly call the constructor of RangeNode to intialize the
fields.
return Range(make_object<RangeNode>(min, extent));
}
};
```
### Sugars Enabled by Optional
Because `Optional<T>` overloads `operator bool`, and comparison operators, it
enables certain sugars to reduce the length of the code
```
// get a value for return null
Optional<String> GetValueOrNull();
void Example() {
if (auto opt = GetValueOrNull()) {
// opt contains not-null value
String value = opt.value();
// code
}
}
```
`Optional<T>` can directly compares to `T`, by checking the optional to be
notnull then run the comparison.
```c++
void Example(PrimFunc f) {
if (f->GetAttr<Integer>(key, 0) == 10) {
}
}
```
---
[Visit
Topic](https://discuss.tvm.ai/t/allow-non-nullable-object-and-introduce-optional-t/6337/3)
to respond.
You are receiving this because you enabled mailing list mode.
To unsubscribe from these emails, [click
here](https://discuss.tvm.ai/email/unsubscribe/962bea9fbbb0469a610b167963f5b7ac9ba053faef74f1c754e210b47df29f7b).
