feat: Add deref_or and destruct to Nullable, add destruct to Box

[enitrat]

Feature Request

• Add a fn deref(self: Nullable<T>, value: T) -> T to NullableTrait to either deref a Nullable or return the provided value
• Add the Destruct implementation in nullable.cairo
• Add the Destruct implementation in box.cairo
  Describe the Feature Request

Describe Preferred Solution

    fn deref_or(self: Nullable<T>, default: T) -> T {
        match match_nullable(self) {
            FromNullableResult::Null => default,
            FromNullableResult::NotNull(value) => value.unbox(),
        }
    }

impl NullableDestruct<T, impl TDestruct: Destruct<T>> of Destruct<Nullable<T>> {
    fn destruct(self: Nullable<T>) nopanic {}
}

impl BoxDestruct<T, impl TDestruct: Destruct<T>> of Destruct<Box<T>> {
    fn destruct(self: Box<T>) nopanic {}
}

Describe Alternatives

Related Code

Additional Context

If the feature request is approved, would you be willing to submit a PR?
(Help can be provided if you need assistance submitting a PR)

• Yes
• No

[orizi]

The destruct part would probably require additional features in the language,
Since we'd have several implementations of Destruct in the droppable cases (as Drop creates a default Destruct impl)
Solutions:

1. Impl ranking for when inferring a type
2. Enforcing not having a particular impl available (in this case, when implementing destruct, no Drop<T> can be available.

[enitrat]

Hm, I don't really get it. What would be the correct way of deriving Destruct on a struct that contains Box or Nullable then? I naively added empty destruct functions as provided in the example here.

[orizi]

you'd need to have a specific one - not a generic one.

The issue is this:

If you have both a Drop and Destruct for the nullable - type, anywhere that requires a destruct, would have 2 impls of destruct for nullable, and would not know which one to choose.

Currently - just adding a specific Destruct impl for the nullable<Specific> you have would work.

[enitrat]

Okay, indeed that's whay I ended up doing; thanks :)